diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index d5327c7e27..0000000000 --- a/.gitmodules +++ /dev/null @@ -1,3 +0,0 @@ -[submodule "vendor/traceur"] - path = vendor/traceur - url = https://github.com/google/traceur-compiler diff --git a/packages/babel/test/fixtures/traceur b/packages/babel/test/fixtures/traceur deleted file mode 120000 index 6a1d2c380d..0000000000 --- a/packages/babel/test/fixtures/traceur +++ /dev/null @@ -1 +0,0 @@ -../../../../vendor/traceur/test/feature \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/ArrayComprehension/ArgumentsInComprehension.js b/packages/babel/test/fixtures/traceur/ArrayComprehension/ArgumentsInComprehension.js new file mode 100644 index 0000000000..531f540a16 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayComprehension/ArgumentsInComprehension.js @@ -0,0 +1,12 @@ +// Options: --array-comprehension +// https://github.com/google/traceur-compiler/issues/1086 + +function f() { + var a = [for (x of [1]) arguments[0]]; + var b = [for (x of [1]) arguments[0]]; + assert.deepEqual(a, [arguments[0]]); + assert.deepEqual(a, [42]); + assert.deepEqual(a, b); +} + +f(42); diff --git a/packages/babel/test/fixtures/traceur/ArrayComprehension/Closure.js b/packages/babel/test/fixtures/traceur/ArrayComprehension/Closure.js new file mode 100644 index 0000000000..ed29b0b1fe --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayComprehension/Closure.js @@ -0,0 +1,11 @@ +// Options: --array-comprehension --block-binding +// Block binding is needed to get the right scoping semantics inside the arrow +// function in the comprehension. + +var res = [for (x of [0, 1]) for (y of [2, 3]) () => [x, y]]; + +assert.equal(4, res.length); +assertArrayEquals([0, 2], res[0]()); +assertArrayEquals([0, 3], res[1]()); +assertArrayEquals([1, 2], res[2]()); +assertArrayEquals([1, 3], res[3]()); diff --git a/packages/babel/test/fixtures/traceur/ArrayComprehension/Error_Disabled.js b/packages/babel/test/fixtures/traceur/ArrayComprehension/Error_Disabled.js new file mode 100644 index 0000000000..2d02e90841 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayComprehension/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --array-comprehension=false +// Error: :4:14: Unexpected reserved word for + +var array = [for (x of [0, 1, 2, 3, 4]) x]; diff --git a/packages/babel/test/fixtures/traceur/ArrayComprehension/Error_NotDefined.js b/packages/babel/test/fixtures/traceur/ArrayComprehension/Error_NotDefined.js new file mode 100644 index 0000000000..ab0f5f9872 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayComprehension/Error_NotDefined.js @@ -0,0 +1,5 @@ +// Options: --array-comprehension --free-variable-checker +// Error: :5:1: notDefined is not defined + +var array = [for (notDefined of [0]) notDefined]; +notDefined; diff --git a/packages/babel/test/fixtures/traceur/ArrayComprehension/Simple.js b/packages/babel/test/fixtures/traceur/ArrayComprehension/Simple.js new file mode 100644 index 0000000000..92fcdf0ab3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayComprehension/Simple.js @@ -0,0 +1,32 @@ +// Options: --array-comprehension + +function* range() { + for (var i = 0; i < 5; i++) { + yield i; + } +} + +var array = [for (x of [0, 1, 2, 3]) x]; +assertArrayEquals([0, 1, 2, 3], array); + +var array2 = [for (x of [0, 1, 2]) for (y of [0, 1, 2]) x + '' + y]; +assertArrayEquals(['00', '01', '02', '10', '11', '12', '20', '21', '22'], + array2); + +var array3 = [ + for (x of [0, 1, 2, 3, 4]) + for (y of range()) + if (x === y) + x + '' + y]; +assertArrayEquals(['00', '11', '22', '33', '44'], array3); + +// Ensure this works as expression statement +[for (testVar of []) testVar]; + +var array4 = [ + for (x of range()) + if (x % 2 === 0) + for (y of range()) + if (y % 2 === 1) + x + '' + y]; +assertArrayEquals(['01', '03', '21', '23', '41', '43'], array4); diff --git a/packages/babel/test/fixtures/traceur/ArrayComprehension/ThisInComprehension.js b/packages/babel/test/fixtures/traceur/ArrayComprehension/ThisInComprehension.js new file mode 100644 index 0000000000..d2ffba4c71 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayComprehension/ThisInComprehension.js @@ -0,0 +1,14 @@ +// Options: --array-comprehension +// https://github.com/google/traceur-compiler/issues/1086 + +var object = {}; + +function f() { + var a = [for (x of [1]) this]; + var b = [for (x of [1]) this]; + assert.deepEqual(a, [this]); + assert.deepEqual(a, [object]); + assert.deepEqual(a, b); +} + +f.call(object); diff --git a/packages/babel/test/fixtures/traceur/ArrayExtras/Fill.js b/packages/babel/test/fixtures/traceur/ArrayExtras/Fill.js new file mode 100644 index 0000000000..e90f7262e3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayExtras/Fill.js @@ -0,0 +1,47 @@ +// should have a length of 1 +assert.equal(Array.prototype.fill.length, 1); + +// should fill from basic case +assert.deepEqual([1, 2, 3].fill(5), [5, 5, 5]); + +// should fill from start +assert.deepEqual([1, 2, 3].fill(5, 1), [1, 5, 5]); + +// should fill from start to end +assert.deepEqual([1, 2, 3].fill(5, 1, 2), [1, 5, 3]); + +// should fill from negative start +assert.deepEqual([1, 2, 3].fill(5, -1), [1, 2, 5]); + +// should fill from negative start to positive end +assert.deepEqual([1, 2, 3].fill(5, -2, 3), [1, 5, 5]); + +// should fill from negative start to negative end +assert.deepEqual([1, 2, 3].fill(5, -3, -1), [5, 5, 3]); + +// should fill from positive start to negative end +assert.deepEqual([1, 2, 3].fill(5, 1, -1), [1, 5, 3]); + +// should fill custom object +assert.deepEqual(Array.prototype.fill.call({'0': 1, 'length': 3}, 5), {'0': 5, '1': 5, '2': 5, 'length': 3}); + +// should handle custom object with negative length +assert.deepEqual(Array.prototype.fill.call({'0': 2, 'length': -1}, 5), {'0': 2, 'length': -1}); + +// should handle no elements +assert.deepEqual([].fill(5), []); + +// should handle bad start +assert.deepEqual([1, 2, 3].fill(5, 'hello'), [5, 5, 5]); + +// should handle bad end +assert.deepEqual([1, 2, 3].fill(5, 1, {}), [1, 2, 3]); + +// should handle bad start and end +assert.deepEqual([1, 2, 3].fill(5, 'hello', {}), [1, 2, 3]); + + +// should handle bad this +assert.throws(function() { + Array.prototype.fill.call(null, 5) +}, TypeError); diff --git a/packages/babel/test/fixtures/traceur/ArrayExtras/Find.js b/packages/babel/test/fixtures/traceur/ArrayExtras/Find.js new file mode 100644 index 0000000000..123da41810 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayExtras/Find.js @@ -0,0 +1,88 @@ +// should have a length of 1 +assert.equal(Array.prototype.find.length, 1); + +// should handle basic case +assert.equal([1, 2, 3].find(function(v) { + return v * v === 4; +}), 2); + +// should handle arrow functions +assert.equal([1, 2, 3].find(v => v * v === 4), 2); + +// should return undefined when not found +assert.equal([1, 2, 3].find(v => v > 10), undefined); + +// should return first match +assert.equal([2, 2, 3].find(v => v * v === 4), 2); + +// should handle custom objects +assert.equal(Array.prototype.find.call({ + 'length': 2, + '0': false, + '1': true +}, v => v), true); + +// should handle bad predicate +assert.throws(function() { + [1, 2, 3].find(1) +}, TypeError); + +// should handle bad this +assert.throws(function() { + Array.prototype.find.call(null, function() {}) +}, TypeError); + +// should correctly handle this +var global = this; +({ + assert: function() { + var self = this; + + // should be global this + [1, 2, 3].find(function() { + assert.notEqual(this, self); + assert.equal(this, global); + }); + + // should be the same this + [1, 2, 3].find(function() { + assert.equal(this, self); + }, self); + + // should not have an effect on arrow functions + [1, 2, 3].find(() => assert.equal(this, self)); + [1, 2, 3].find(() => assert.equal(this, self), self); + + // should call with correct args + var arr = [5]; + arr.find(function(value, i, object) { + assert.equal(value, 5); + assert.equal(i, 0); + assert.equal(arr, object); + }); + } +}).assert(); + +var lengthCalls = 0; +var itemCalls = 0; +var callbackCalls = 0; +var object = { + length: { + valueOf() { + lengthCalls++; + return 3; + } + }, + get 2() { + itemCalls++; + return 'a'; + } +}; + +assert.equal(Array.prototype.find.call(object, (v) => { + callbackCalls++; + return v === 'a'; +}), 'a'); +assert.equal(lengthCalls, 1); +assert.equal(itemCalls, 1); +assert.equal(callbackCalls, 3); diff --git a/packages/babel/test/fixtures/traceur/ArrayExtras/FindIndex.js b/packages/babel/test/fixtures/traceur/ArrayExtras/FindIndex.js new file mode 100644 index 0000000000..f572f7b1e9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayExtras/FindIndex.js @@ -0,0 +1,47 @@ +// should have a length of 1 +assert.equal(Array.prototype.findIndex.length, 1); + +// should handle basic case +assert.equal([1, 2, 3].findIndex(function(v) { + return v * v === 4; +}), 1); + +// should handle arrow functions +assert.equal([1, 2, 3].findIndex(v => v * v === 4), 1); + +// should return -1 when not found +assert.equal([1, 2, 3].findIndex(v => v > 10), -1); + +// should return first match +assert.equal([2, 2, 3].findIndex(v => v * v === 4), 0); + +// should handle custom objects +assert.equal(Array.prototype.findIndex.call({ + 'length': 2, + '0': false, + '1': true +}, v => v), 1); + +var lengthCalls = 0; +var itemCalls = 0; +var callbackCalls = 0; +var object = { + length: { + valueOf() { + lengthCalls++; + return 3; + } + }, + get 2() { + itemCalls++; + return 'a'; + } +}; + +assert.equal(Array.prototype.findIndex.call(object, (v) => { + callbackCalls++; + return v === 'a'; +}), 2); +assert.equal(lengthCalls, 1); +assert.equal(itemCalls, 1); +assert.equal(callbackCalls, 3); diff --git a/packages/babel/test/fixtures/traceur/ArrayExtras/From.js b/packages/babel/test/fixtures/traceur/ArrayExtras/From.js new file mode 100644 index 0000000000..590f14261c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayExtras/From.js @@ -0,0 +1,158 @@ +// should have a length of 1 +assert.equal(Array.from.length, 1); +var arr; +var obj; + +// should make an array from arguments +function arrayFromArgs() { + return Array.from(arguments); +} +arr = arrayFromArgs('a', 1); + +assert.equal(arr.length, 2); +assert.deepEqual(arr, ['a', 1]); +assert.isTrue(Array.isArray(arr)); + +// should handle undefined values +var arrayLike = {0: 'a', 2: 'c', length: 3}; +arr = Array.from(arrayLike); + +assert.equal(arr.length, 3); +assert.deepEqual(arr, ['a', undefined, 'c']); +assert.isTrue(Array.isArray(arr)); + +// should use a mapFn +arr = Array.from([{'a': 1}, {'a': 2}], function(item, i) { + return item.a + i; +}); + +assert.deepEqual(arr, [1, 3]); + +// should set this in mapFn +var thisObj = {a: 10}; +arr = Array.from([{'a': 1}, {'a': 2}], function(item, i) { + return this.a + item.a + i; +}, thisObj); + +assert.deepEqual(arr, [11, 13]); + +// should map on array-like object +arr = Array.from({0: {'a': 5}, length: 1}, function(item, i) { + return item.a + i; +}); + +assert.deepEqual(arr, [5]); + +// should throw on bad map fn +assert.throws(function() { + Array.from([], null) +}, TypeError); + +// should make from an array-like object +var arrayLikeObj = function(len) { + this.length = len; +}; +arrayLikeObj.from = Array.from; +obj = arrayLikeObj.from(['a', 'b', 'c']); + +assert.equal(obj.length, 3); +assert.deepEqual(obj, {0: 'a', 1: 'b', 2: 'c', length: 3}); + +// should make from a non-array iterable +var calledIterator = 0; +var Iterable = function(len) { + var self = this; + + self.length = len; + self[Symbol.iterator] = function*() { + for (var i = 0; i < self.length; i++) { + calledIterator++; + yield self[i]; + } + }; +}; +var it = new Iterable(3); +it[0] = 'a'; +it[1] = 'b'; +it[2] = 'c'; +obj = Array.from(it); + +assert.equal(obj.length, 3); +assert.equal(obj[0], 'a'); +assert.equal(obj[1], 'b'); +assert.equal(obj[2], 'c'); +assert.equal(calledIterator, 3); + +// should make from a sub-classed array +var length = 0; +var constructorCounter = 0; +var lengthSetCounter = 0; +var lengthGetCounter = 0; + +class MyArray extends Array { + constructor(v) { + super(); + constructorCounter++; + assert.isUndefined(v); + } + + set length(v) { + lengthSetCounter++; + length = v; + } + + get length() { + lengthGetCounter++; + return length; + } +} + +var ma = MyArray.from(['a', 'b']); +assert.instanceOf(ma, MyArray); +assert.equal(constructorCounter, 1); +assert.equal(lengthSetCounter, 1); +assert.equal(lengthGetCounter, 0); +assert.isTrue(ma.hasOwnProperty('0')); +assert.isTrue(ma.hasOwnProperty('1')); +assert.isFalse(ma.hasOwnProperty('length')); +assert.equal(ma[0], 'a'); +assert.equal(ma[1], 'b'); +assert.equal(ma.length, 2); + +// should make from a sub-classed array without iterable +length = 0; +constructorCounter = 0; +lengthSetCounter = 0; +lengthGetCounter = 0; + +class MyArray2 extends MyArray { + constructor(v) { + super(); + constructorCounter++; + assert.equal(v, 2); + } +}; +MyArray2.prototype[Symbol.iterator] = undefined; + +class MyArray3 extends Array { + constructor(v) { + super(); + this.length = v; + } +} +MyArray3.prototype[Symbol.iterator] = undefined; + +var ma3 = new MyArray3(2); +ma3[0] = 'a'; +ma3[1] = 'b'; +ma = MyArray2.from(ma3); +assert.instanceOf(ma, MyArray2); +assert.equal(constructorCounter, 2); +assert.equal(lengthSetCounter, 1); +assert.equal(lengthGetCounter, 0); +assert.isTrue(ma.hasOwnProperty('0')); +assert.isTrue(ma.hasOwnProperty('1')); +assert.isFalse(ma.hasOwnProperty('length')); +assert.equal(ma[0], 'a'); +assert.equal(ma[1], 'b'); +assert.equal(ma.length, 2); diff --git a/packages/babel/test/fixtures/traceur/ArrayExtras/Of.js b/packages/babel/test/fixtures/traceur/ArrayExtras/Of.js new file mode 100644 index 0000000000..0616705b43 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayExtras/Of.js @@ -0,0 +1,37 @@ +var arr; + +// should have a length of 0 +assert.equal(Array.of.length, 0); + +//should return an array from arguments +arr = Array.of(1, 'a', 3); +assert.deepEqual(arr, [1, 'a', 3]); +assert.isTrue(arr instanceof Array); + +//should work with no arguments +arr = Array.of(); +assert.deepEqual(arr, []); +assert.isTrue(arr instanceof Array); + +//should work with sub-classed array +class MyArray extends Array {} + +arr = MyArray.of(4, 'b'); +assert.equal(arr[0], 4); +assert.equal(arr[1], 'b'); +assert.equal(arr.length, 2); +assert.isTrue(arr instanceof MyArray); + +//should call with exotic array +class ExoticArray { + constructor(len) { + this.length = len; + } +} +arr = Array.of.call(ExoticArray, 5, 'c', 6, 'd'); +assert.equal(arr[0], 5); +assert.equal(arr[1], 'c'); +assert.equal(arr[2], 6); +assert.equal(arr[3], 'd'); +assert.equal(arr.length, 4); +assert.isTrue(arr instanceof ExoticArray); diff --git a/packages/babel/test/fixtures/traceur/ArrayIterator.js b/packages/babel/test/fixtures/traceur/ArrayIterator.js new file mode 100644 index 0000000000..f9cc9d2ae4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrayIterator.js @@ -0,0 +1,27 @@ +var a = ['a', 'b', 'c']; + +var res = []; +for (var x of a) { + res.push(x); +} +assert.deepEqual(res, ['a', 'b', 'c']); + +assert.equal(a[Symbol.iterator], a.values); + +res = []; +for (var x of a.values()) { + res.push(x); +} +assert.deepEqual(res, ['a', 'b', 'c']); + +res = []; +for (var x of a.keys()) { + res.push(x); +} +assert.deepEqual(res, [0, 1, 2]); + +res = []; +for (var x of a.entries()) { + res.push(x); +} +assert.deepEqual(res, [[0, 'a'], [1, 'b'], [2, 'c']]); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/AlphaRename.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/AlphaRename.js new file mode 100644 index 0000000000..1c181f684e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/AlphaRename.js @@ -0,0 +1,22 @@ +var global = this; +var self = {}; + +function outer() { + var f = () => { + assert.equal(this, self); + + var g = () => { + assert.equal(this, self); + }; + g(); + + var h = function() { + assert.equal(this, global); + }; + h(); + }; + + f(); +} + +outer.call(self); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/AlphaRenameThisArguments.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/AlphaRenameThisArguments.js new file mode 100644 index 0000000000..11d03c767f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/AlphaRenameThisArguments.js @@ -0,0 +1,42 @@ + +var self = {}; + +function f() { + (() => { + assert.equal(self, this); + assert.equal(1, arguments.length); + assert.equal(42, arguments[0]); + + var THIS = 0; + var ARGUMENTS = 1; + + var object = { + function: function() { + return [this, arguments]; + }, + method() { + return [this, arguments]; + }, + arrow: () => { + return [this, arguments]; + } + }; + + assert.equal(object, object.function()[THIS]); + assert.equal(2, object.function('a', 'b')[ARGUMENTS].length); + assert.equal('a', object.function('a', 'b')[ARGUMENTS][0]); + assert.equal('b', object.function('a', 'b')[ARGUMENTS][1]); + + assert.equal(object, object.method()[THIS]); + assert.equal(3, object.method('c', 'd', 'e')[ARGUMENTS].length); + assert.equal('c', object.method('c', 'd', 'e')[ARGUMENTS][0]); + assert.equal('d', object.method('c', 'd', 'e')[ARGUMENTS][1]); + assert.equal('e', object.method('c', 'd', 'e')[ARGUMENTS][2]); + + assert.equal(self, object.arrow()[THIS]); + assert.equal(1, object.arrow('f', 'g')[ARGUMENTS].length); + assert.equal(42, object.arrow('f', 'g')[ARGUMENTS][0]); + })(); +} + +f.call(self, 42); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Arguments.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Arguments.js new file mode 100644 index 0000000000..ad94aa2b4f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Arguments.js @@ -0,0 +1,6 @@ +function f() { + var args = (() => arguments)(); + assert.equal(args, arguments); +} + +f(); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/ArrowFunctions.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/ArrowFunctions.js new file mode 100644 index 0000000000..2aa3255ccd --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/ArrowFunctions.js @@ -0,0 +1,52 @@ +// Options: --block-binding + +// These tests are from: +// http://wiki.ecmascript.org/doku.php?id=strawman:arrow_function_syntax + +let empty = () => undefined; +assert.equal(empty(), undefined); + +// Expression bodies needs no parentheses or braces +let identity = (x) => x; +assert.equal(identity(empty), empty); + +// Object literals needs to be wrapped in parens. +let keyMaker = (val) => ({key: val}); +assert.equal(keyMaker(empty).key, empty); + +// => { starts a block. +let emptyBlock = () => {a: 42}; +assert.equal(emptyBlock(), undefined); + +// Nullary arrow function starts with arrow (cannot begin statement) +const preamble = 'hello'; +const body = 'world'; +let nullary = () => preamble + ': ' + body; +assert.equal('hello: world', nullary()); + +// No need for parens even for lower-precedence expression body +let square = x => x * x; +assert.equal(81, square(9)); + +let oddArray = []; +let array = [2, 3, 4, 5, 6, 7]; +array.forEach((v, i) => { if (i & 1) oddArray[i >>> 1] = v; }); +assert.equal('3,5,7', oddArray.toString()); + +var f = (x = 42) => x; +assert.equal(42, f()); + +{ + let g = (...xs) => xs; + assertArrayEquals([0, 1, true], g(0, 1, true)); +} + +var h = (x, ...xs) => xs; +assertArrayEquals([0, 1, true], h(-1, 0, 1, true)); + +assert.equal(typeof (() => {}), 'function'); +assert.equal(Object.getPrototypeOf(() => {}), Function.prototype); + +var i = ({a = 1}) => a; +assert.equal(i({}), 1); +assert.equal(i({a: 2}), 2); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/CoverInitializer.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/CoverInitializer.js new file mode 100644 index 0000000000..f461959aaa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/CoverInitializer.js @@ -0,0 +1,5 @@ +// https://github.com/google/traceur-compiler/issues/478 + +function f() { + (1 ? ({a=0}) => {} : 1); +} diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer.js new file mode 100644 index 0000000000..b342823845 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer.js @@ -0,0 +1,5 @@ +// Error: :4:16: Unexpected token = + +function f() { + ({a = (0, {a = 0})} = {}) +} diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer2.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer2.js new file mode 100644 index 0000000000..6252ef4fcc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer2.js @@ -0,0 +1,3 @@ +// Error: :3:5: Unexpected token = + +({a = 0}); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer3.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer3.js new file mode 100644 index 0000000000..a5d260c392 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer3.js @@ -0,0 +1,3 @@ +// Error: :3:18: Unexpected token = + +var f = ({x = {y = 1}) => 2; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Disabled.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Disabled.js new file mode 100644 index 0000000000..a0c05a6f30 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --arrow-functions=false +// Error: :4:21: Unexpected token > + +var identity = (x) => x; diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_FreeVariableChecker.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_FreeVariableChecker.js new file mode 100644 index 0000000000..4db02378a2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_FreeVariableChecker.js @@ -0,0 +1,3 @@ +// Options: --arrow-functions --free-variable-checker +// Error: :3:35: missingIdentifier is not defined +var identity = (identityParam) => missingIdentifier; diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_InvalidFormalParameters.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_InvalidFormalParameters.js new file mode 100644 index 0000000000..b0b6078c15 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_InvalidFormalParameters.js @@ -0,0 +1,3 @@ +// Error: :3:15: Unexpected token + + +var f = (a, b + 5) => a + b; diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_LineTerminator.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_LineTerminator.js new file mode 100644 index 0000000000..f6f2497767 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_LineTerminator.js @@ -0,0 +1,4 @@ +// Error: :4:1: Unexpected token => + +x +=>1 diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence.js new file mode 100644 index 0000000000..932532c4b3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence.js @@ -0,0 +1,3 @@ +// Error: :3:26: Semi-colon expected + +var identity = (x) => {x}.bind({}); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence2.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence2.js new file mode 100644 index 0000000000..b064f6d29d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence2.js @@ -0,0 +1,4 @@ +// Error: :4:11: Semi-colon expected +// Error: :4:11: Unexpected token => + +(x) + (y) => y; diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence3.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence3.js new file mode 100644 index 0000000000..c3e1bb2b8c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_Precedence3.js @@ -0,0 +1,4 @@ +// Error: :4:9: Semi-colon expected +// Error: :4:9: Unexpected token => + +(x) + y => y; diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_SpreadNotLast.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_SpreadNotLast.js new file mode 100644 index 0000000000..7276b3b180 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_SpreadNotLast.js @@ -0,0 +1,6 @@ +// Error: :5:17: Unexpected token , +// Error: :5:12: Unexpected token ... + +{ + let f = (...xs, x) => xs; +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_SpreadOutsideFormals.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_SpreadOutsideFormals.js new file mode 100644 index 0000000000..7884adf087 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Error_SpreadOutsideFormals.js @@ -0,0 +1,3 @@ +// Error: :3:13: Unexpected token ... + +var f = (x, ...xs); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/FreeVariableChecker.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/FreeVariableChecker.js new file mode 100644 index 0000000000..d3681bd6b9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/FreeVariableChecker.js @@ -0,0 +1,2 @@ +var identity = (identityParam) => identityParam; +assert.equal(1234, identity(1234)); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Parens.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Parens.js new file mode 100644 index 0000000000..1eae88e41e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Parens.js @@ -0,0 +1,19 @@ +class C { + constructor() { + } +} + +class D extends C { + constructor() { + super(); + this.x = { + y: () => { + return this; + } + }; + } +} + +var o = new D(); +assert.equal(typeof o.x.y, 'function'); +assert.equal(o.x.y(), o); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_Frozen.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_Frozen.js new file mode 100644 index 0000000000..de7f381055 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_Frozen.js @@ -0,0 +1,39 @@ +// Skip. Not implemented. + +// TODO: needs # prefix implemented for freezing +// Use # to freeze and join to nearest relevant closure +function return_pure() { + return #(a) -> a * a; +} + +let p = return_pure(), + q = return_pure(); +assert(p === q); + +function check_frozen(o) { + try { + o.x = "expando"; + assert(! "reached"); + } catch (e) { + // e is something like "TypeError: o is not extensible" + assert(e.name == "TypeError"); + } +} + +check_frozen(p); + +function partial_mul(a) { + return #(b) -> a * b; +} + +let x = partial_mul(3), + y = partial_mul(4), + z = partial_mul(3); + +assert(x !== y); +assert(x !== z); +assert(y !== z); + +check_frozen(x); +check_frozen(y); +check_frozen(z); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_InitializerShorthand.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_InitializerShorthand.js new file mode 100644 index 0000000000..27548d0d58 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_InitializerShorthand.js @@ -0,0 +1,19 @@ +// Skip. Not implemented. + +// TODO: needs the intializer shorthand implemented for arrow functions + +// Object intializer shorthand: "method" = function-valued property with dynamic ''this'' +const obj = { + method() -> { + return => this; + } +}; + +assert(obj.method() === obj); +assert(obj.method.call(u) === u); + +// Name binding forms hoist to body (var) or block (let, const) top +var warmer(a) -> { return a; }; +let warm(b) -> { return b; }; +const colder(c) -> { return c; }; +const #coldest(d) -> {...}; diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_SoftBind.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_SoftBind.js new file mode 100644 index 0000000000..0ef4fd6835 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/Skip_SoftBind.js @@ -0,0 +1,14 @@ +// Skip. Not implemented. + +// TODO: needs soft bind and ??= implemented + +// A special form based on the default operator proposal +const self_default_bound = (this ??= self, a, b) -> { + this.c = a * b; +} +self_default_bound(6, 7); +assert(self.c === 42); + +self_default_bound.call(other, 8, 9); +assert(other.c === 72); +assert(self.c === 42); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/SloppyArguments.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/SloppyArguments.js new file mode 100644 index 0000000000..a00746bc7e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/SloppyArguments.js @@ -0,0 +1,15 @@ + +var f1 = implements => implements; +var f2 = implements => { return implements; }; +var f3 = (implements) => { return implements; }; +assert.equal(1, f1(1)); +assert.equal(2, f2(2)); +assert.equal(3, f1(3)); + +var g = ({static}) => static; +assert.equal(4, g({static: 4})); + +var h1 = ([protected]) => protected; +var h2 = ([...protected]) => protected[0]; +assert.equal(5, h1([5])); +assert.equal(6, h2([6])); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/ThisBindingInPropertyName.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/ThisBindingInPropertyName.js new file mode 100644 index 0000000000..4d2751ec7e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/ThisBindingInPropertyName.js @@ -0,0 +1,15 @@ +var obj = { + name: 'x', + method() { + var f = (x) => ({[this.name]: x}); + + var o = f(1); + assert.equal(1, o.x); + + this.name = 2; + o = f(3); + assert.equal(3, o[2]); + } +}; + +obj.method(); diff --git a/packages/babel/test/fixtures/traceur/ArrowFunctions/ThisBindings.js b/packages/babel/test/fixtures/traceur/ArrowFunctions/ThisBindings.js new file mode 100644 index 0000000000..c3aee86629 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ArrowFunctions/ThisBindings.js @@ -0,0 +1,18 @@ +// Options: --block-binding + +// These tests are from: +// http://wiki.ecmascript.org/doku.php?id=strawman:arrow_function_syntax + +const obj = { + method: function () { + return () => this; + } +}; +assert.equal(obj.method()(), obj); + +let fake = {steal: obj.method()}; +assert.equal(fake.steal(), obj); + +let real = {borrow: obj.method}; +assert.equal(real.borrow()(), real); + diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AlphaRenaming.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AlphaRenaming.js new file mode 100644 index 0000000000..6525b1cc98 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AlphaRenaming.js @@ -0,0 +1,21 @@ +// Options: --async-functions +// Async. + +function asyncComplete(self, arg) { + return new Promise((resolve) => { + resolve([self, arg]); + }); +} + +var self = {}; +var obj = {}; +var value; + +async function A() { + assert.equal(this, self); + var value = await asyncComplete(this, arguments[0]); + assert.deepEqual([self, obj], value); + done(); +} + +A.call(self, obj); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrow.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrow.js new file mode 100644 index 0000000000..c02247d217 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrow.js @@ -0,0 +1,9 @@ +// Options: --async-functions +// Async. + +var f = async () => 1; + +f().then((result) => { + assert.equal(result, 1); + done(); +}).catch(done); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrow2.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrow2.js new file mode 100644 index 0000000000..289ba80d60 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrow2.js @@ -0,0 +1,9 @@ +// Options: --async-functions +// Async. + +var f = async x => x; + +f(1).then((result) => { + assert.equal(result, 1); + done(); +}).catch(done); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrowArguments.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrowArguments.js new file mode 100644 index 0000000000..42e3f472b4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrowArguments.js @@ -0,0 +1,16 @@ +// Options: --async-functions +// Async. + +function g() { + var f = async (x = arguments) => [x, arguments]; + + f().then((result) => { + assert.equal(result[0][0], 1); + assert.equal(result[1][0], 1); + assert.equal(result[0][1], 2); + assert.equal(result[1][1], 2); + done(); + }).catch(done); +} + +g(1, 2); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrowThis.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrowThis.js new file mode 100644 index 0000000000..d4d0f64028 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncArrowThis.js @@ -0,0 +1,15 @@ +// Options: --async-functions +// Async. + +function g() { + var f = async (x = this) => [x, this]; + var p = {}; + f.call(p).then((result) => { + assert.equal(result[0], o); + assert.equal(result[1], o); + done(); + }).catch(done); +} + +var o = {}; +g.call(o); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncMethod.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncMethod.js new file mode 100644 index 0000000000..4c9444da90 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncMethod.js @@ -0,0 +1,31 @@ +// Options: --async-functions +// Async. + +function asyncTimeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +class C { + async test() { + var x = 0; + await asyncTimeout(1); + assert.equal(1, ++x); + await asyncTimeout(1); + assert.equal(2, ++x); + C.test(); + } + + static async test() { + var x = 0; + await asyncTimeout(1); + assert.equal(1, ++x); + await asyncTimeout(1); + assert.equal(2, ++x); + + done(); + } +} + +new C().test(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncMethodObjectLiteral.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncMethodObjectLiteral.js new file mode 100644 index 0000000000..7020a6978d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncMethodObjectLiteral.js @@ -0,0 +1,21 @@ +// Options: --async-functions +// Async. + +function asyncTimeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +var object = { + async test() { + var x = 0; + await asyncTimeout(1); + assert.equal(1, ++x); + await asyncTimeout(1); + assert.equal(2, ++x); + done(); + } +} + +object.test(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncSyntax.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncSyntax.js new file mode 100644 index 0000000000..75be014bc0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/AsyncSyntax.js @@ -0,0 +1,18 @@ +// Options: --async-functions + +var async; +async +function f() { + return async + async; +} + +async = 1; +assert.equal(async, 1); +assert.equal(f(), 2); + +async = async +function g() { + +} + +assert.equal(async, 1); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Basics.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Basics.js new file mode 100644 index 0000000000..9592812858 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Basics.js @@ -0,0 +1,46 @@ +// Options: --async-functions --generators=false +// Async. +// +// The --generators=false part is to test #1231 + +var f = (x, y) => ({x, y}); + +(async function() { + var x = await 1; + assert.equal(1, x); + x = await (await 2); + assert.equal(2, x); + x = (await 3, await 4); + assert.equal(4, x); + + x = f(await 5, await 6); + assert.deepEqual({x: 5, y: 6}, x); + x = await f(await 7, await 8); + assert.deepEqual({x: 7, y: 8}, x); + + if (await true) { + x = 9; + } else { + x = 10; + } + assert.equal(9, x); + if (await false) { + x = 11; + } else { + x = 12; + } + assert.equal(12, x); + + var j = 0; + for (var i = await 0; (await i) < (await 3); await i++) { + assert.equal(i, j++); + } + assert.equal(3, j); + + var g = (x) => x; + var h = () => 13; + x = await g({z: await h()}); + assert.deepEqual({z: 13}, x); + + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Complete.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Complete.js new file mode 100644 index 0000000000..948e11142a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Complete.js @@ -0,0 +1,16 @@ +// Options: --async-functions +// Async. + +function asyncComplete() { + return new Promise((resolve) => { + resolve('complete'); + }); +} + +// ---------------------------------------------------------------------------- + +(async function() { + var value = await asyncComplete(); + assert.equal('complete', value); + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Empty.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Empty.js new file mode 100644 index 0000000000..4cd44b74c9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Empty.js @@ -0,0 +1,10 @@ +// Options: --async-functions +// Async. + +async function empty() { +} + +empty().then((v) => { + assert.isUndefined(v); + done(); +}); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_AsyncArrow.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_AsyncArrow.js new file mode 100644 index 0000000000..3973c62fc5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_AsyncArrow.js @@ -0,0 +1,7 @@ +// Options: --async-functions +// Error: :7:5: Semi-colon expected +// Error: :7:5: Unexpected token => + +var async = () => 1; +var x = async +(y) => y; diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_AsyncArrow2.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_AsyncArrow2.js new file mode 100644 index 0000000000..b48847aa1d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_AsyncArrow2.js @@ -0,0 +1,6 @@ +// Options: --async-functions +// Error: :6:1: Unexpected token => + +var async = () => 1; +var x = async (y) +=> y; diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_Disabled.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_Disabled.js new file mode 100644 index 0000000000..ccfde7dd72 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Error_Disabled.js @@ -0,0 +1,15 @@ +// Disabled by default. +// Error: :13:21: Semi-colon expected + +function asyncComplete() { + return new Promise((resolve) => { + resolve('complete'); + }); +} + +// ---------------------------------------------------------------------------- + +(async function() { + var value = async asyncComplete(); + assert.equal('complete', value); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Export.module.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Export.module.js new file mode 100644 index 0000000000..cd23d5a62b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Export.module.js @@ -0,0 +1,18 @@ +// Options: --async-functions +// Async. + +import {asyncFunction} from './resources/async-function.js'; +import asyncFunctionDefault from './resources/async-function.js'; + +assert.instanceOf(asyncFunction(), Promise); +assert.instanceOf(asyncFunctionDefault(), Promise); + +(async function() { + var x = await asyncFunction(); + assert.equal(x, 1); + + var y = await asyncFunctionDefault(); + assert.equal(y, 2); + + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Finally.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Finally.js new file mode 100644 index 0000000000..4e9f603625 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Finally.js @@ -0,0 +1,25 @@ +// Options: --async-functions +// Async. + +var finallyVisited = false; + +var resolve; +var p = new Promise((r) => { + resolve = r; +}); +var v; + +async function test() { + try { + v = await p; + } finally { + finallyVisited = true; + } + assert.equal(42, v); + assert.isTrue(finallyVisited); + done(); +} + +test(); +assert.isFalse(finallyVisited); +resolve(42); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Finally2.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Finally2.js new file mode 100644 index 0000000000..63cf8e1240 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Finally2.js @@ -0,0 +1,21 @@ +// Options: --async-functions +// Async. + +var finallyVisited = false; +var resolve; + +async function test() { + try { + await new Promise((r) => { + resolve = r; + }); + } finally { + finallyVisited = true; + } + assert.isTrue(finallyVisited); + done(); +} + +test(); +assert.isFalse(finallyVisited); +resolve(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/PromiseCast.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/PromiseCast.js new file mode 100644 index 0000000000..aabac1d0bb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/PromiseCast.js @@ -0,0 +1,12 @@ +// Options: --async-functions +// Async. + +async function f() { + var x = await 1; + assert.equal(x, 1); + x = await undefined; + assert.equal(x, undefined); + done(); +} + +f(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Prototype.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Prototype.js new file mode 100644 index 0000000000..cbdc07aeaa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Prototype.js @@ -0,0 +1,7 @@ +// Options: --async-functions + +async function f() { +} + +assert.equal(Object.getPrototypeOf(f), Function.prototype); +assert.instanceOf(f(), Promise); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Rethrow.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Rethrow.js new file mode 100644 index 0000000000..253b9ddfdf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Rethrow.js @@ -0,0 +1,13 @@ +// Options: --async-functions +// Async. + +async function rethrow(x) { + 1; + throw x; + 2; +} + +rethrow(2).catch((err) => { + assert.equal(err, 2) + done(); +}); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Return.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Return.js new file mode 100644 index 0000000000..fa98200106 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Return.js @@ -0,0 +1,16 @@ +// Options: --async-functions +// Async. + +async function ret(x) { + if (x > 1) + return x - 2; + return x + 3; +} + +(async function() { + var v = await ret(4); + assert.equal(v, 2); + v = await ret(0); + assert.equal(v, 3); + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Throw.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Throw.js new file mode 100644 index 0000000000..452312fae9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Throw.js @@ -0,0 +1,30 @@ +// Options: --async-functions +// Async. + +async function asyncThrow(e) { + if (true) + throw e; + await asyncYield(); +} + +function asyncYield() { + return asyncTimeout(0); +} + +function asyncTimeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +(async function() { + var value; + try { + value = await asyncThrow(1); + fail("shouldn't get here"); + } catch (e) { + assert.equal(1, e); + } + + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Timeout.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Timeout.js new file mode 100644 index 0000000000..a0803b1716 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Timeout.js @@ -0,0 +1,21 @@ +// Options: --async-functions +// Async. + +function asyncTimeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +(async function() { + var x = 0; + await asyncTimeout(1); + assert.equal(1, ++x); + await asyncTimeout(1); + assert.equal(2, ++x); + await asyncTimeout(1); + assert.equal(3, ++x); + await asyncTimeout(1); + assert.equal(4, ++x); + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Value.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Value.js new file mode 100644 index 0000000000..1a1aaf5f8c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Value.js @@ -0,0 +1,24 @@ +// Options: --async-functions +// Async. + +async function asyncValue(value) { + if (true) + return value; + await asyncYield(); +} + +function asyncYield() { + return asyncTimeout(0); +} + +function asyncTimeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +(async function() { + var value = await asyncValue(42); + assert.equal(42, value); + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/Yield.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/Yield.js new file mode 100644 index 0000000000..dfb4bba86a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/Yield.js @@ -0,0 +1,17 @@ +// Options: --async-functions +// Async. + +function asyncYield() { + return asyncTimeout(0); +} + +function asyncTimeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +(async function() { + await asyncYield(); + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncFunctions/resources/async-function.js b/packages/babel/test/fixtures/traceur/AsyncFunctions/resources/async-function.js new file mode 100644 index 0000000000..3431ca98d4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncFunctions/resources/async-function.js @@ -0,0 +1,7 @@ +export async function asyncFunction() { + return 1; +} + +export default async function() { + return 2; +}; diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/Array.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/Array.js new file mode 100644 index 0000000000..e3c2359302 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/Array.js @@ -0,0 +1,14 @@ +// Options: --for-on --async-functions +// Async. + +(async function() { + const list = []; + const g = [1, 2, 3]; + for (var i on g) { + list.push(i); + } + assert.deepEqual(list, [1, 2, 3]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/AsyncGenerator.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/AsyncGenerator.js new file mode 100644 index 0000000000..a04d7239b9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/AsyncGenerator.js @@ -0,0 +1,18 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f() { + yield 1; +} + +(async function() { + var list = []; + var g = f(); + for (var i on g) { + list.push(i); + } + assert.deepEqual(list, [1]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/AsyncObservable.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/AsyncObservable.js new file mode 100644 index 0000000000..cb31ec9a54 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/AsyncObservable.js @@ -0,0 +1,21 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f() { + await yield 1; + await yield 2; + await yield 3; +} + +(async function() { + var list = []; + var g = f(); + for (var i on g) { + list.push(i); + await Promise.resolve().then(() => list.push(i + 3)); + } + assert.deepEqual(list, [1, 4, 2, 5, 3, 6]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/Demo.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/Demo.js new file mode 100644 index 0000000000..a9a854ce70 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/Demo.js @@ -0,0 +1,29 @@ +// Options: --async-functions --async-generators --for-on +// Async. + +function timeout(ms) { + return new Promise((resolve) => { + setTimeout(resolve, ms); + }); +} + +async function* asyncStream() { + var i = 0; + while (true) { + await timeout(5); + yield i; + ++i; + } +} + +(async function() { + var count = 0; + for (value on asyncStream()) { + count += value; + if (value === 3) { + break; // stops the async generator as well + } + } + assert.equal(count, 6); // 6 = 1 + 2 + 3 + done(); +})(); diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/ForOn.module.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/ForOn.module.js new file mode 100644 index 0000000000..6ba98faaf5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/ForOn.module.js @@ -0,0 +1,75 @@ +// Async. +// Options: --async-functions --for-on + +import {AsyncGeneratorFunction} from './resources/observable.js'; + +var o1 = new AsyncGeneratorFunction(function* () { + // TODO(mnieper): As soon as proper async generators are implemented, they + // should be used here. + yield 1; + yield 2; + yield 3; + return 4; +}); + +(async function () { + + // test for on + var squares = []; + for (var i on o1) { + squares.push(i * i); + } + assert.deepEqual(squares, [1, 4, 9]); + + // test break + var cubes = []; + for (var i on o1) { + if (i > 2) { + break; + } + cubes.push(i * i * i); + } + assert.deepEqual(cubes, [1, 8]); + + // test continue + var list = []; + for (var i on o1) { + if (i === 2) { + continue; + } + list.push(i); + } + assert.deepEqual(list, [1, 3]); + + // test outer continue + var almostEmpty = []; + label: do { + for (var i on o1) { + if (i === 2) { + continue label; + } + almostEmpty.push(i); + } + } while (false); + assert.deepEqual(almostEmpty, [1]); + + // test return + var value = await (async function () { + for (var i on o1) { + if (i === 1) { + return 42; + } + } + })(); + assert.equal(value, 42); + + // test asynchronous loop body + var sum = 0; + for (var i on o1) { + sum += i; + await Promise.resolve(); + } + assert.equal(sum, 6); + + done(); +}()).catch(done); diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/ForOnBody.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/ForOnBody.js new file mode 100644 index 0000000000..2d90d1fd8e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/ForOnBody.js @@ -0,0 +1,14 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* x() { +} + +async function y() { + for (let a on x()) + break; +} + +y() + +done(); diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/Method.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/Method.js new file mode 100644 index 0000000000..de739c2d4d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/Method.js @@ -0,0 +1,20 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +class C { + static async* f() { + yield 1; + } +} + +(async function() { + var list = []; + var g = C.f(); + for (var i on g) { + list.push(i); + } + assert.deepEqual(list, [1]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/Property.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/Property.js new file mode 100644 index 0000000000..53e926ac3a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/Property.js @@ -0,0 +1,20 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +var C = { + async* f() { + yield 1; + } +}; + +(async function() { + var list = []; + var g = C.f(); + for (var i on g) { + list.push(i); + } + assert.deepEqual(list, [1]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/ReturnAsyncGenerator.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/ReturnAsyncGenerator.js new file mode 100644 index 0000000000..08e40ca5ab --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/ReturnAsyncGenerator.js @@ -0,0 +1,24 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f() { + yield 1; + yield 2; + yield 3; +} + + +(async function() { + var list = []; + var g = f(); + for (var i on g) { + if (i === 2) { + break; + } + list.push(i); + } + assert.deepEqual(list, [1]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/ThisAndArguments.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/ThisAndArguments.js new file mode 100644 index 0000000000..346ddcf9c8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/ThisAndArguments.js @@ -0,0 +1,19 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f(a) { + yield this[0]; + yield arguments[0]; +} + +(async function() { + var list = []; + var g = f.call([1], 2); + for (var i on g) { + list.push(i); + } + assert.deepEqual(list, [1, 2]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/ThrowInAsyncGenerator.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/ThrowInAsyncGenerator.js new file mode 100644 index 0000000000..633baf4a62 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/ThrowInAsyncGenerator.js @@ -0,0 +1,28 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f() { + for (var i = 1; i < 4; ++i) { + yield i; + } +} + + +(async function() { + var list = []; + var g = f(); + try { + for (var i on g) { + if (i == 2) { + throw 'ex'; + } + list.push(i); + } + } catch (ex) { + assert.equal(ex, 'ex'); + } + assert.deepEqual(list, [1]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/YieldFor.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/YieldFor.js new file mode 100644 index 0000000000..497b4e9fec --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/YieldFor.js @@ -0,0 +1,25 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f1() { + yield 1; + yield* f2(); + yield 4; +} + +async function* f2() { + yield 2; + yield 3; +} + +(async function() { + var list = []; + var g = f1(); + for (var i on g) { + list.push(i); + } + assert.deepEqual(list, [1, 2, 3, 4]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/YieldForOn.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/YieldForOn.js new file mode 100644 index 0000000000..4f25f39719 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/YieldForOn.js @@ -0,0 +1,24 @@ +// Options: --async-generators --for-on --async-functions +// Async. + +async function* f() { + yield 1; + yield 2; +} + +async function* g() { + for (i on f()) { + yield 2 * i; + } +} + +(async function() { + var list = []; + for (var i on g()) { + list.push(i); + } + assert.deepEqual(list, [2, 4]); + + done(); +})().catch(done); + diff --git a/packages/babel/test/fixtures/traceur/AsyncGenerators/resources/observable.js b/packages/babel/test/fixtures/traceur/AsyncGenerators/resources/observable.js new file mode 100644 index 0000000000..bc401dd208 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/AsyncGenerators/resources/observable.js @@ -0,0 +1,71 @@ +const generator = Symbol(); +const onDone = Symbol(); +const generatorFunction = Symbol(); + +function schedule(asyncF) { + return Promise.resolve().then(asyncF); +} + +class DecoratedGenerator { + constructor(_generator, _onDone) { + this[generator] = _generator; + this[onDone] = _onDone; + } + + next(value) { + var result = this[generator].next(); + if (result.done) { + this[onDone].call(this); + } + return result; + } + + throw(error) { + this[onDone].call(this); + return this[generator].throw(error); + } + + return(value) { + this[onDone].call(this); + return this[generator].return(value); + } +} + + +export class AsyncGeneratorFunction { + constructor(_generatorFunction) { + this[generatorFunction] = _generatorFunction; + } + + [Symbol.observer](observer) { + var generator = this[generatorFunction].call(this); + var done = false; + schedule(async function () { + var result; + while (!done) { + try { + result = generator.next(); + } catch (e) { + observer.throw(e); + return; + } + if (result.done) { + observer.return(result.value); + return; + } + try { + result = observer.next(result.value); + } catch (e) { + generator.throw(e); + } + if (result.done) { + generator.return(); + return; + } + await result.value; + } + generator.return(); + }); + return new DecoratedGenerator(observer, () => { done = true }); + } +} diff --git a/packages/babel/test/fixtures/traceur/Classes/ClassMethodInheritance.js b/packages/babel/test/fixtures/traceur/Classes/ClassMethodInheritance.js new file mode 100644 index 0000000000..c957d1188e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ClassMethodInheritance.js @@ -0,0 +1,23 @@ +function B() {} +B.b = function() { + return 'B.b'; +}; + +class C extends B {} + +assert.equal(Object.getPrototypeOf(C), B); +assert.equal(Object.getPrototypeOf(C.prototype), B.prototype); + +assert.equal(C.b(), 'B.b'); + +class D extends Object {} + +assert.equal(Object.getPrototypeOf(D), Object); +assert.equal(Object.getPrototypeOf(D.prototype), Object.prototype); +assert.equal(D.keys, Object.keys); + +class E {} + +assert.equal(Object.getPrototypeOf(E), Function.prototype); +assert.equal(Object.getPrototypeOf(E.prototype), Object.prototype); +assert.isFalse('keys' in E); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Classes/ClassNameBinding.js b/packages/babel/test/fixtures/traceur/Classes/ClassNameBinding.js new file mode 100644 index 0000000000..de7df429f9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ClassNameBinding.js @@ -0,0 +1,41 @@ + +var ClassExpr = class { + m() { + return ClassExpr; + } +} + +var TempClass = ClassExpr; +ClassExpr = 42; + +assert.equal(42, new TempClass().m()); +assert.equal(TempClass.name, ''); + +////////////////////////////////////////////////////////////////////////////// + +var ClassExpr2 = class ClassExprInner { + m() { + return ClassExprInner; + } +} + +TempClass = ClassExpr2; +ClassExpr2 = 42; + +assert.equal(TempClass, new TempClass().m()); +assert.equal(TempClass.name, 'ClassExprInner'); + +////////////////////////////////////////////////////////////////////////////// + +class ClassDef { + m() { + return ClassDef; + } +} + +var TempClass = ClassDef; +ClassDef = 42; + +assert.equal(TempClass, new TempClass().m()); +// IE does not have a name property on functions. +assert.isTrue(TempClass.name === 'ClassDef' || TempClass.name === undefined); diff --git a/packages/babel/test/fixtures/traceur/Classes/ClassNameInStack.js b/packages/babel/test/fixtures/traceur/Classes/ClassNameInStack.js new file mode 100644 index 0000000000..41d1fe4a3f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ClassNameInStack.js @@ -0,0 +1,29 @@ +class MyClassName { + m() { + throw new Error(); + } +} + +try { + new MyClassName().m(); + fail('Should have thrown'); +} catch (ex) { + if (ex.stack) + assert.isTrue(String(ex.stack).indexOf('MyClassName') >= 0); +} + +////////////////////////////////////////////////////////////////////////////// + +class MySecondClass extends MyClassName{ + m() { + throw new Error(); + } +} + +try { + new MySecondClass().m(); + fail('Should have thrown'); +} catch (ex) { + if (ex.stack) + assert.isTrue(String(ex.stack).indexOf('MySecondClass') >= 0); +} diff --git a/packages/babel/test/fixtures/traceur/Classes/Constructor.js b/packages/babel/test/fixtures/traceur/Classes/Constructor.js new file mode 100644 index 0000000000..ce76af6bef --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Constructor.js @@ -0,0 +1,34 @@ +class Point { + constructor(x, y) { + this.x = x; + this.y = y; + } +} + +class A { + classRef() { + return A; + } +}; + +var p = new Point(1, 2); +assert.equal(1, p.x); +assert.equal(2, p.y); + +var p2 = new Point(3, 4); +assert.equal(3, p2.x); +assert.equal(4, p2.y); +assert.equal(1, p.x); +assert.equal(2, p.y); + +for (var element in Point) { + fail('Point contains static member : ' + element); +} + +// Tests to ensure that we're not binding function identifier per class +var a = new A(); +var tmpA = A; +A = 42; +assert.equal(tmpA, a.classRef()); +// IE does not have a name property on functions. +assert.isTrue(tmpA.name === 'A' || tmpA.name === undefined); diff --git a/packages/babel/test/fixtures/traceur/Classes/ConstructorChaining.js b/packages/babel/test/fixtures/traceur/Classes/ConstructorChaining.js new file mode 100644 index 0000000000..7d2a4bd936 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ConstructorChaining.js @@ -0,0 +1,22 @@ +class ConstructorA { + constructor(x) { + this.x = x; + } +} + +class ConstructorB extends ConstructorA { + constructor(x, y) { + super(x); + this.y = y; + } +} + +// ---------------------------------------------------------------------------- + +var a = new ConstructorA('ax'); +assert.equal('ax', a.x); +assert.isFalse(a.hasOwnProperty('y')); + +var b = new ConstructorB('bx', 'by'); +assert.equal('bx', b.x); +assert.equal('by', b.y); diff --git a/packages/babel/test/fixtures/traceur/Classes/ConstructorMember.js b/packages/babel/test/fixtures/traceur/Classes/ConstructorMember.js new file mode 100644 index 0000000000..d437456e1e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ConstructorMember.js @@ -0,0 +1,27 @@ +class ConstructorMember { + constructor() {} +} + +class DerivedConstructorMember extends ConstructorMember { + constructor() { + super(); + } +} + +// ---------------------------------------------------------------------------- + +var cm = new ConstructorMember; +assert.equal(cm.constructor, ConstructorMember.prototype.constructor); +assert.isTrue(ConstructorMember.prototype.hasOwnProperty('constructor')); + +for (var key in ConstructorMember) { + assert.notEqual('constructor should not be enumerable', 'constructor', key); +} + +var dcm = new DerivedConstructorMember; +assert.equal(dcm.constructor, DerivedConstructorMember.prototype.constructor); +assert.isTrue(DerivedConstructorMember.prototype.hasOwnProperty('constructor')); + +for (var key in DerivedConstructorMember) { + assert.notEqual('constructor should not be enumerable', 'constructor', key); +} diff --git a/packages/babel/test/fixtures/traceur/Classes/DefaultConstructor.js b/packages/babel/test/fixtures/traceur/Classes/DefaultConstructor.js new file mode 100644 index 0000000000..057d30e24e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/DefaultConstructor.js @@ -0,0 +1,31 @@ +class B { + constructor(x, y) { + this.x = x; + this.y = y; + } +} + +class C extends B { + // No constructor +} + +var c = new B(1, 2); +assert.equal(1, c.x); +assert.equal(2, c.y); + +assert.isFalse( + Object.getOwnPropertyDescriptor(B.prototype, 'constructor').enumerable); +assert.isFalse( + Object.getOwnPropertyDescriptor(C.prototype, 'constructor').enumerable); + +// Ensure that we don't try to call super() in the default constructor. +class D extends null {} +var d = new D(); + + +class E extends function(x) { + this.x = x; +} {} + +var e = new E(42) +assert.equal(42, e.x); diff --git a/packages/babel/test/fixtures/traceur/Classes/DeriveFromObject.js b/packages/babel/test/fixtures/traceur/Classes/DeriveFromObject.js new file mode 100644 index 0000000000..852ca2b0fc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/DeriveFromObject.js @@ -0,0 +1,6 @@ +class DerivedFromObject extends Object { +} + +// ---------------------------------------------------------------------------- + +// TODO(rnystrom): No tests for this? diff --git a/packages/babel/test/fixtures/traceur/Classes/EmptyClass.js b/packages/babel/test/fixtures/traceur/Classes/EmptyClass.js new file mode 100644 index 0000000000..733584a99b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/EmptyClass.js @@ -0,0 +1,29 @@ +class Empty {} + +class EmptyB extends Empty { +} + +// ---------------------------------------------------------------------------- + +var e = new Empty(); +assert.isNotNull(e); + +for (var element in e) { + assert.equal('constructor', element); +} + +for (var element in Empty) { + fail('Empty contains static member : ' + element); +} + +// Instances should be different. +var e2 = new Empty(); +assert.notEqual(e, e2); + +assert.isTrue(e instanceof Empty); +assert.isFalse(e instanceof EmptyB); + +var b = new EmptyB(); + +assert.isTrue(b instanceof Empty); +assert.isTrue(b instanceof EmptyB); diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_Disabled.js b/packages/babel/test/fixtures/traceur/Classes/Error_Disabled.js new file mode 100644 index 0000000000..8735ad59c0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --classes=false +// Error: :4:1: Unexpected reserved word + +class C {} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_GH1556.js b/packages/babel/test/fixtures/traceur/Classes/Error_GH1556.js new file mode 100644 index 0000000000..88f0c96893 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_GH1556.js @@ -0,0 +1,5 @@ +// Error: :5:19: Unexpected token = + +// extends LeftHandSideExpression +// see https://github.com/google/traceur-compiler/issues/1556 +class A extends B = C {} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_NestedFunctionSuper.js b/packages/babel/test/fixtures/traceur/Classes/Error_NestedFunctionSuper.js new file mode 100644 index 0000000000..4171a7daa5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_NestedFunctionSuper.js @@ -0,0 +1,22 @@ +// Error: :8:14: super is only allowed in methods +// Error: :14:16: super is only allowed in methods +// Error: :19:19: super is only allowed in methods + +class C { + superM() { + return (function() { + return super.m(); + })(); + } + superX2() { + return (function() { + return (function() { + return super.x; + })(); + })(); + } + constructor() { + (function() { super(); })(); + } +} + diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_NewSuper.js b/packages/babel/test/fixtures/traceur/Classes/Error_NewSuper.js new file mode 100644 index 0000000000..abbfa06a88 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_NewSuper.js @@ -0,0 +1,7 @@ +// Error: :5:14: Unexpected token ( + +class C { + m() { + new super(); + } +} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_NewSuper2.js b/packages/babel/test/fixtures/traceur/Classes/Error_NewSuper2.js new file mode 100644 index 0000000000..40622d3632 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_NewSuper2.js @@ -0,0 +1,7 @@ +// Error: :6:3: Unexpected token } + +class C { + m() { + new super + } +} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_NoSuperInDerivedClass.js b/packages/babel/test/fixtures/traceur/Classes/Error_NoSuperInDerivedClass.js new file mode 100644 index 0000000000..184a79a41d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_NoSuperInDerivedClass.js @@ -0,0 +1,9 @@ +// Error: :6:3: Derived constructor must call super() + +class B {} + +class C extends B { + constructor() { + // no super call + } +} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_Super.js b/packages/babel/test/fixtures/traceur/Classes/Error_Super.js new file mode 100644 index 0000000000..9855970fb1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_Super.js @@ -0,0 +1,10 @@ +// Error: :7:17: Unexpected token ; + +class A {} + +class ImproperSuper extends A { + method() { + return super; + } +} + diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_SuperAsTemplateTag.js b/packages/babel/test/fixtures/traceur/Classes/Error_SuperAsTemplateTag.js new file mode 100644 index 0000000000..0947e2ad35 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_SuperAsTemplateTag.js @@ -0,0 +1,10 @@ +// Error: :7:18: Unexpected token ` + +class A {} + +class ImproperSuper extends A { + method() { + return super ``; + } +} + diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_SuperCallInNonDerived.js b/packages/babel/test/fixtures/traceur/Classes/Error_SuperCallInNonDerived.js new file mode 100644 index 0000000000..1c936ac286 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_SuperCallInNonDerived.js @@ -0,0 +1,7 @@ +// Error: :5:5: super call is only allowed in derived constructor + +class C { + constructor() { + super(); + } +} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_SuperNestedClass.js b/packages/babel/test/fixtures/traceur/Classes/Error_SuperNestedClass.js new file mode 100644 index 0000000000..2ad46de00a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_SuperNestedClass.js @@ -0,0 +1,15 @@ +// Error: :12:5: 'this' is not allowed before super() + +class Animal {} + +class Roo extends Animal { + constructor() { + class Koala extends Animal { + constructor() { + super(); + } + } + this.a = new Koala; + super(); + } +} diff --git a/packages/babel/test/fixtures/traceur/Classes/Error_SuperPropertyOutsideMethod.js b/packages/babel/test/fixtures/traceur/Classes/Error_SuperPropertyOutsideMethod.js new file mode 100644 index 0000000000..923804325c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Error_SuperPropertyOutsideMethod.js @@ -0,0 +1,10 @@ +// Error: :6:3: super is only allowed in methods +// Error: :9:15: super is only allowed in methods +// Error: :10:17: super is only allowed in methods + +function f() { + super.x; +} + +var g = () => super.y; +var h = () => { super.z; } diff --git a/packages/babel/test/fixtures/traceur/Classes/ExtendCoverFormals.js b/packages/babel/test/fixtures/traceur/Classes/ExtendCoverFormals.js new file mode 100644 index 0000000000..bebe84c82c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ExtendCoverFormals.js @@ -0,0 +1,10 @@ +class C {} + +var x = 1; +var y = C; +class D extends (x, y) { + +} + +assert.instanceOf(new D(), C); +assert.instanceOf(new D(), D); diff --git a/packages/babel/test/fixtures/traceur/Classes/ExtendNonConstructableFunction.js b/packages/babel/test/fixtures/traceur/Classes/ExtendNonConstructableFunction.js new file mode 100644 index 0000000000..8093c9534a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ExtendNonConstructableFunction.js @@ -0,0 +1,11 @@ + +assert.throw(function() { + class C extends Math {} +}, 'Super expression must either be null or a function'); + +assert.throw(function() { + function f() {} + // prototype needs to be an Object or null. + f.prototype = 42; + class C extends f {} +}, 'super prototype must be an Object or null'); diff --git a/packages/babel/test/fixtures/traceur/Classes/ExtendObject.js b/packages/babel/test/fixtures/traceur/Classes/ExtendObject.js new file mode 100644 index 0000000000..e5b11ffe2d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ExtendObject.js @@ -0,0 +1,4 @@ +// Can no longer extend objects. +assert.throw(function() { + class C extends {} {} +}, TypeError); diff --git a/packages/babel/test/fixtures/traceur/Classes/ExtendStrange.js b/packages/babel/test/fixtures/traceur/Classes/ExtendStrange.js new file mode 100644 index 0000000000..3911d03ddb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/ExtendStrange.js @@ -0,0 +1,54 @@ +class C extends null {} + +var c = new C; +assert.isTrue(c instanceof C); +assert.isFalse(c instanceof Object); + +// Closure testing framework tries to toString the object and fails. +assert.isTrue(Object.getPrototypeOf(c) === C.prototype); +assert.isTrue(Object.getPrototypeOf(Object.getPrototypeOf(c)) === null); + +assert.equal(c.toString, undefined); + +class D extends null { + constructor(...args) { + super(...args); + } +} + +// super() does not depend on the [HomeObject]. It just calls the [Prototype] +// of the function. +new D(); + +class E extends function() { return null }() { + constructor(...args) { + super(...args); + } +} + +// super() does not depend on the [HomeObject]. It just calls the [Prototype] +// of the function. +new E(); + +function f() {}; +f.prototype = null; + +class F extends f { + get x() { + return 1; + } +} + +assert.equal(1, new F().x); + + +function g() {} +function h() {} +g.prototype = h; +class G extends g { + get x() { + return 2; + } +} + +assert.equal(2, new G().x); diff --git a/packages/babel/test/fixtures/traceur/Classes/FieldInheritance.js b/packages/babel/test/fixtures/traceur/Classes/FieldInheritance.js new file mode 100644 index 0000000000..c9b863aaee --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/FieldInheritance.js @@ -0,0 +1,26 @@ +class Point2D { + constructor() { + this.x = 1; + this.y = 2; + } +} + +class Point3D extends Point2D { + constructor() { + super(); + this.z = 3; + } +} + +// ---------------------------------------------------------------------------- + +var a = new Point2D(); +assert.isTrue(a.hasOwnProperty('x')); +assert.isTrue(a.hasOwnProperty('y')); +assert.isFalse(a.hasOwnProperty('z')); +assert.isUndefined(a.z); + +var b = new Point3D(); +assert.isTrue(b.hasOwnProperty('x')); +assert.isTrue(b.hasOwnProperty('y')); +assert.isTrue(b.hasOwnProperty('z')); diff --git a/packages/babel/test/fixtures/traceur/Classes/FieldInitializers.js b/packages/babel/test/fixtures/traceur/Classes/FieldInitializers.js new file mode 100644 index 0000000000..dcd938fc00 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/FieldInitializers.js @@ -0,0 +1,23 @@ +class Point { + constructor() { + this.x = 0; + this.y = 0; + } +} + +// ---------------------------------------------------------------------------- + +var p = new Point(); +assert.equal(0, p.x); +assert.equal(0, p.y); +p.x = 1; +assert.equal(1, p.x); + +var p2 = new Point(); +assert.equal(0, p2.x); +assert.equal(0, p2.y); +assert.equal(1, p.x); + +for (var element in Point) { + fail('Point contains static member : ' + element); +} diff --git a/packages/babel/test/fixtures/traceur/Classes/FieldLookup.js b/packages/babel/test/fixtures/traceur/Classes/FieldLookup.js new file mode 100644 index 0000000000..6afad51a9e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/FieldLookup.js @@ -0,0 +1,47 @@ +// This requires manually constructed classes. + +function fieldLookupA() { } +fieldLookupA.prototype = { + foo : "A.value", + get bar() { + return "A.get.bar"; + }, + set bar(value) { }, + boo : "A.boo.value", + baz : undefined +} + +function fieldLookupB() { } +fieldLookupB.prototype = { + __proto__ : fieldLookupA.prototype, + get foo() { + return "B.get.foo"; + }, + set foo(value) { }, + bar: "B.value", + boo: undefined, + baz: "B.baz.value", +} + +class FieldLookupC extends fieldLookupB { + x() { + return super.foo; + } + y() { + return super.bar; + } + z() { + return super.boo; + } + w() { + return super.baz; + } +} + +// ---------------------------------------------------------------------------- + +var c = new FieldLookupC(); +assert.equal("B.get.foo", c.x()); +assert.equal("B.value", c.y()); +assert.isUndefined(c.z()); +assert.equal("B.baz.value", c.w()); diff --git a/packages/babel/test/fixtures/traceur/Classes/Fields.js b/packages/babel/test/fixtures/traceur/Classes/Fields.js new file mode 100644 index 0000000000..70848ed8fe --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Fields.js @@ -0,0 +1,19 @@ +class Point { + constructor() { + this.x = 0; + this.y = 0; + } +} + +// ---------------------------------------------------------------------------- + +var p = new Point(); + +var keys = []; +for (var key in p) { + keys.push(key); +} + +assert.isTrue(keys.indexOf('x') !== -1); +assert.isTrue(keys.indexOf('y') !== -1); +assert.isTrue(keys.indexOf('constructor') === -1); diff --git a/packages/babel/test/fixtures/traceur/Classes/Getters.js b/packages/babel/test/fixtures/traceur/Classes/Getters.js new file mode 100644 index 0000000000..06bd252815 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Getters.js @@ -0,0 +1,20 @@ +class GetterA { + get x() { return 'getter x'; } + get y() { return 'getter y'; } +} + +class GetterB extends GetterA { + get x() { return super.x; } +} + +class GetterC extends GetterB { + get y() { return super.y; } +} + +// ---------------------------------------------------------------------------- + +var b = new GetterB(); +var c = new GetterC(); + +assert.equal('getter x', b.x); +assert.equal('getter y', c.y); diff --git a/packages/babel/test/fixtures/traceur/Classes/Inheritance.js b/packages/babel/test/fixtures/traceur/Classes/Inheritance.js new file mode 100644 index 0000000000..562e12dadb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Inheritance.js @@ -0,0 +1,9 @@ +class SimpleBase {} +class SimpleDerived extends SimpleBase {} + +// ---------------------------------------------------------------------------- + +var derived = new SimpleDerived(); +assert.isTrue(derived instanceof SimpleDerived); +assert.isTrue(derived instanceof SimpleBase); +assert.isTrue(derived instanceof Object); diff --git a/packages/babel/test/fixtures/traceur/Classes/InheritanceFromMemberExpression.js b/packages/babel/test/fixtures/traceur/Classes/InheritanceFromMemberExpression.js new file mode 100644 index 0000000000..4b8722655d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/InheritanceFromMemberExpression.js @@ -0,0 +1,31 @@ +var baseContainer = { + base: function() { + this.yyy = 'base constructor'; + } +}; + +baseContainer.base.prototype = { + x: 'proto x', + constructor: function() { + this.y = 'base y'; + } +} + +class MemberExprBase extends baseContainer.base { + constructor(w) { + super(); + this.z = 'var z'; + this.w = w; + } +} + +// ---------------------------------------------------------------------------- + +var a = new MemberExprBase('w value'); +var pa = Object.getPrototypeOf(a); +var ppa = Object.getPrototypeOf(pa); + +assertHasOwnProperty(a, 'yyy', 'w', 'z'); +assertLacksOwnProperty(a, 'x'); +assertHasOwnProperty(pa, 'constructor'); +assertHasOwnProperty(ppa, 'x', 'constructor'); diff --git a/packages/babel/test/fixtures/traceur/Classes/InheritanceFromNonclass.js b/packages/babel/test/fixtures/traceur/Classes/InheritanceFromNonclass.js new file mode 100644 index 0000000000..67b767156f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/InheritanceFromNonclass.js @@ -0,0 +1,17 @@ +function noClassA() {} +noClassA.prototype = { + ma: function() { return 'ma'; } +} + +class NoClassB extends noClassA { + mb() { + return 'mb ' + super.ma(); + } +} + +// ---------------------------------------------------------------------------- + +var b = new NoClassB; +assert.isTrue(b instanceof noClassA); +assert.equal('ma', b.ma()); +assert.equal('mb ma', b.mb()); diff --git a/packages/babel/test/fixtures/traceur/Classes/InheritanceNameBinding.js b/packages/babel/test/fixtures/traceur/Classes/InheritanceNameBinding.js new file mode 100644 index 0000000000..d39468d855 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/InheritanceNameBinding.js @@ -0,0 +1,11 @@ +class NameBindingBase {} + +class NameBindingDerived extends NameBindingBase { + getX() { return this.x; } +} + +// ---------------------------------------------------------------------------- + +var derived = new NameBindingDerived(); +derived.x = 12; +assert.equal(12, derived.getX()); diff --git a/packages/babel/test/fixtures/traceur/Classes/Method.js b/packages/babel/test/fixtures/traceur/Classes/Method.js new file mode 100644 index 0000000000..a73c3fc4ac --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Method.js @@ -0,0 +1,21 @@ +class Universe { + answer() { + return 42; + } +} + +// ---------------------------------------------------------------------------- + +var universe = new Universe(); +assert.equal(42, universe.answer()); + +var keys = []; +for (var key in universe) { + keys.push(key); +} +assert.equal(keys.indexOf('answer'), -1); +assert.equal(keys.indexOf('constructor'), -1); + +for (var key in Universe) { + fail('Universe contains static member : ' + key); +} diff --git a/packages/babel/test/fixtures/traceur/Classes/MethodInheritance.js b/packages/babel/test/fixtures/traceur/Classes/MethodInheritance.js new file mode 100644 index 0000000000..c9e0f63baa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/MethodInheritance.js @@ -0,0 +1,32 @@ +class MethodsA { + ma() {} +} + +class MethodsB extends MethodsA { + mb() {} +} + +class MethodsC extends MethodsB { + mc() {} +} + +// ---------------------------------------------------------------------------- + +var a = new MethodsA(); +var b = new MethodsB(); +var c = new MethodsC(); + +var pa = Object.getPrototypeOf(a); +var pb = Object.getPrototypeOf(b); +var pc = Object.getPrototypeOf(c); + +assertNoOwnProperties(a); +assertNoOwnProperties(b); +assertNoOwnProperties(c); + +assertHasOwnProperty(pa, 'ma'); +assertLacksOwnProperty(pa, 'mb', 'mc'); +assertHasOwnProperty(pb, 'mb'); +assertLacksOwnProperty(pb, 'ma', 'mc'); +assertHasOwnProperty(pc, 'mc'); +assertLacksOwnProperty(pc, 'ma', 'mb'); diff --git a/packages/babel/test/fixtures/traceur/Classes/MethodLookup.js b/packages/babel/test/fixtures/traceur/Classes/MethodLookup.js new file mode 100644 index 0000000000..2a11cc3be3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/MethodLookup.js @@ -0,0 +1,34 @@ +class MethodLookupA { + foo() { + return 'A.foo()'; + } + get bar() { + return 'A.get.bar'; + } + set bar(value) { } +} + +class MethodLookupB extends MethodLookupA { + get foo() { + return 'B.foo.get'; + } + set foo(value) { } + bar() { + return 'B.bar()'; + } +} + +class MethodLookupC extends MethodLookupB { + x() { + return super.foo; + } + y() { + return super.bar(); + } +} + +// ---------------------------------------------------------------------------- + +var c = new MethodLookupC(); +assert.equal('B.foo.get', c.x()); +assert.equal('B.bar()', c.y()); diff --git a/packages/babel/test/fixtures/traceur/Classes/NameBinding.js b/packages/babel/test/fixtures/traceur/Classes/NameBinding.js new file mode 100644 index 0000000000..38a6be7c4d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/NameBinding.js @@ -0,0 +1,36 @@ +class ElementHolder { + getElement() { return this.element; } + + makeFilterCapturedThis() { + var capturedThis = this; + return function (x) { + return x == capturedThis.element; + } + } + + makeFilterLostThis() { + return function () { return this; } + } + + makeFilterHidden(element) { + return function (x) { return x == element; } + } +} + +// ---------------------------------------------------------------------------- + +var obj = new ElementHolder(); + +obj.element = 40; +assert.equal(40, obj.getElement()); +assert.isTrue(obj.makeFilterCapturedThis()(40)); + +// http://code.google.com/p/v8/issues/detail?id=1381 +// assert.isUndefined(obj.makeFilterLostThis()()); + +obj.element = 39; +assert.isFalse(obj.makeFilterCapturedThis()(40)); +assert.isTrue(obj.makeFilterCapturedThis()(39)); + +assert.isFalse(obj.makeFilterHidden(41)(40)); +assert.isTrue(obj.makeFilterHidden(41)(41)); diff --git a/packages/babel/test/fixtures/traceur/Classes/NestedClassSuper.js b/packages/babel/test/fixtures/traceur/Classes/NestedClassSuper.js new file mode 100644 index 0000000000..9efce298ce --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/NestedClassSuper.js @@ -0,0 +1,104 @@ +class One { + constructor(o) { o.r = 'c1'; } + m() { return 'm1'; } + get g() { return 'g1'; } + set x(v) { this.x_ = v+1; } + get x() { return this.x_; } +} + +// All OneExt class decls are identical. +// +// Just testing identical behavior in the different contexts: +// constructor, method, method with inner func, getter, setter. +class OneExtWrapper { + constructor() { + class OneExt extends One { + constructor() { + var o = {}; + super(o); + assert.equal('c1', o.r); + } + m() { return super.m(); } + get g() { return super.g; } + set x(v) { super.x = v; } + get x() { return super.x; } + } + this.Cconstr = OneExt; + } + m() { + class OneExt extends One { + constructor() { + var o = {}; + super(o); + assert.equal('c1', o.r); + } + m() { return super.m(); } + get g() { return super.g; } + set x(v) { super.x = v; } + get x() { return super.x; } + } + return OneExt; + } + mf() { + return (function(){ + class OneExt extends One { + constructor() { + var o = {}; + super(o); + assert.equal('c1', o.r); + } + m() { return super.m(); } + get g() { return super.g; } + set x(v) { super.x = v; } + get x() { return super.x; } + } + return OneExt; + })(); + } + get g() { + class OneExt extends One { + constructor() { + var o = {}; + super(o); + assert.equal('c1', o.r); + } + m() { return super.m(); } + get g() { return super.g; } + set x(v) { super.x = v; } + get x() { return super.x; } + } + return OneExt; + } + set Cprop(v) { + class OneExt extends One { + constructor() { + var o = {}; + super(o); + assert.equal('c1', o.r); + } + m() { return super.m(); } + get g() { return super.g; } + set x(v) { super.x = v; } + get x() { return super.x; } + } + this.C = OneExt; + } + get Cprop() { + return this.C; + } +} + +// ---------------------------------------------------------------------------- + +function checkClass(C) { + var o = new C(); + assert.equal('m1', o.m()); + assert.equal('g1', o.g); + o.x = 'x'; + assert.equal('x1', o.x); +} + +var o = new OneExtWrapper(); +o.Cprop = 'dummy value'; + +[o.Cconstr, o.m(), o.mf(), o.g, o.Cprop].forEach(checkClass); diff --git a/packages/babel/test/fixtures/traceur/Classes/NestedClassSuperAnimal.js b/packages/babel/test/fixtures/traceur/Classes/NestedClassSuperAnimal.js new file mode 100644 index 0000000000..f96787256b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/NestedClassSuperAnimal.js @@ -0,0 +1,45 @@ +// a = animal, n = name, sn = super name, fn = full name, wn = with name + +class Animal { + constructor(n) { + this.n1 = n + ' Animal'; + } + get n() { return this.n1; } +} + +class Roo extends Animal { + constructor(n) { + class Koala extends Animal { + constructor(n) { + super(n); + this.n2 = n + ' Koala'; + } + get n() { return this.n2; } + get sn() { return super.n; } + get fn() { return this.n + ' aka ' + this.sn; } + } + + super(n); + this.a = new Koala(n + ' II'); + this.n2 = n + ' Roo'; + } + wn(n) { + return ' (with ' + n + ')'; + } + get n() { return this.n2 + this.wn(this.a.n); } + get sn() { return super.n + this.wn(this.a.sn); } + get fn() { return this.n + ' aka ' + this.sn + this.wn(this.a.fn); } +} + +// ---------------------------------------------------------------------------- + +var o = new Roo('Kanga'); +assert.equal('Kanga II Koala', o.a.n); +assert.equal('Kanga II Animal', o.a.sn); +assert.equal('Kanga II Koala aka Kanga II Animal', o.a.fn); + +assert.equal('Kanga Roo (with Kanga II Koala)', o.n); +assert.equal('Kanga Animal (with Kanga II Animal)', o.sn); +assert.equal('Kanga Roo (with Kanga II Koala) aka ' + + 'Kanga Animal (with Kanga II Animal) ' + + '(with Kanga II Koala aka Kanga II Animal)', o.fn); diff --git a/packages/babel/test/fixtures/traceur/Classes/NewClassExpression.js b/packages/babel/test/fixtures/traceur/Classes/NewClassExpression.js new file mode 100644 index 0000000000..a08d0ff8eb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/NewClassExpression.js @@ -0,0 +1,18 @@ + +assert.equal((new class { + get x() { + return 'x'; + } + getX() { + return this.x; + } +}).getX(), 'x'); + +assert.equal(new class { + get y() { + return 'y'; + } + getY() { + return this.y; + } +}().getY(), 'y'); diff --git a/packages/babel/test/fixtures/traceur/Classes/NonEnum.js b/packages/babel/test/fixtures/traceur/Classes/NonEnum.js new file mode 100644 index 0000000000..243bb30bbf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/NonEnum.js @@ -0,0 +1,23 @@ +class B { + a() {} + get b() {} + set c(v) {} + static d() {} + static get e() {} + static set f(v) {} +} + +class D extends B { + g() {} + get h() {} + set i(v) {} + static j() {} + static get k() {} + static set l(v) {} +} + +assert.equal(0, Object.keys(B).length); +assert.equal(0, Object.keys(B.prototype).length); + +assert.equal(0, Object.keys(D).length); +assert.equal(0, Object.keys(D.prototype).length); diff --git a/packages/babel/test/fixtures/traceur/Classes/OptionalParams.js b/packages/babel/test/fixtures/traceur/Classes/OptionalParams.js new file mode 100644 index 0000000000..4040e25bf9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/OptionalParams.js @@ -0,0 +1,18 @@ +class OptionalParams { + constructor(opt = 1) { + this.opt = opt; + } + instanceMethod(opt = 2) { + return opt; + } +} + +// ---------------------------------------------------------------------------- + +var obj = new OptionalParams(); +assert.equal(1, obj.opt); +assert.equal(2, obj.instanceMethod()); +assert.equal(3, obj.instanceMethod(3)); + +var obj2 = new OptionalParams(2); +assert.equal(2, obj2.opt); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Classes/PropertyAccessors.js b/packages/babel/test/fixtures/traceur/Classes/PropertyAccessors.js new file mode 100644 index 0000000000..94f0028504 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/PropertyAccessors.js @@ -0,0 +1,59 @@ +class ImmutablePoint { + get x () { return this.x_; } + get y () { return this.y_; } +} + +class MutablePoint { + get x () { return this.x_; } + set x (x) { this.x_ = x; } + get y () { return this.y_; } + set y (y) { this.y_ = y; } +} + +// ---------------------------------------------------------------------------- + +var immutable = new ImmutablePoint(); +assert.equal(undefined, immutable.x); +assert.equal(undefined, immutable.y); +immutable.x_ = 10; +immutable.y_ = 20; +assert.equal(10, immutable.x); +assert.equal(20, immutable.y); +assert.equal(10, immutable.x_); +assert.equal(20, immutable.y_); + +try { + immutable.x = 11; + fail('should not be able to set a get only property'); +} catch (except) { +} +try { + immutable.y = 11; + fail('should not be able to set a get only property'); +} catch (except) { +} +assert.equal(10, immutable.x); +assert.equal(20, immutable.y); + +var mutable = new MutablePoint(); +assert.equal(undefined, mutable.x); +assert.equal(undefined, mutable.y); +mutable.x_ = 10; +mutable.y_ = 20; +assert.equal(10, mutable.x); +assert.equal(20, mutable.y); +assert.equal(10, mutable.x_); +assert.equal(20, mutable.y_); + +try { + mutable.x = 11; +} catch (except) { + fail('should be able to set a read/write property'); +} +try { + mutable.y = 12; +} catch (except) { + fail('should be able to set a read/write property'); +} +assert.equal(11, mutable.x); +assert.equal(12, mutable.y); diff --git a/packages/babel/test/fixtures/traceur/Classes/PrototypeDescriptor.js b/packages/babel/test/fixtures/traceur/Classes/PrototypeDescriptor.js new file mode 100644 index 0000000000..1be4d32b2a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/PrototypeDescriptor.js @@ -0,0 +1,7 @@ +class C {} + +var descr = Object.getOwnPropertyDescriptor(C, 'prototype'); +assert.isFalse(descr.enumerable); +assert.isFalse(descr.configurable); +assert.isFalse(descr.writable); +assert.equal(descr.value, C.prototype); diff --git a/packages/babel/test/fixtures/traceur/Classes/RestParams.js b/packages/babel/test/fixtures/traceur/Classes/RestParams.js new file mode 100644 index 0000000000..4720e962b1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/RestParams.js @@ -0,0 +1,15 @@ +class RestParams { + constructor(...rest) { + this.rest = rest; + } + instanceMethod(...rest) { + return rest; + } +} + +// ---------------------------------------------------------------------------- + +var obj = new RestParams(0, 1, 2); +assertArrayEquals([0, 1, 2], obj.rest); +assertArrayEquals([3, 4, 5], obj.instanceMethod(3, 4, 5)); + diff --git a/packages/babel/test/fixtures/traceur/Classes/SemiColon.js b/packages/babel/test/fixtures/traceur/Classes/SemiColon.js new file mode 100644 index 0000000000..64c076d705 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SemiColon.js @@ -0,0 +1,3 @@ +class SemiColon { + ; +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Classes/SimpleSuper.js b/packages/babel/test/fixtures/traceur/Classes/SimpleSuper.js new file mode 100644 index 0000000000..dd5e0a243e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SimpleSuper.js @@ -0,0 +1,31 @@ +class SuperBase { + m() { return 40; } + get x () { return this.baseX; } + set x (value) { this.baseX = value; } + constructor() { + this.baseC = 2; + this.baseX = 4; + } +} + +class SuperDerived extends SuperBase { + m() { return 41; } + superM() { return super.m(); } + superX() { return super.x; } + constructor() { + super(); + this.x = 10; + this.derC = 3; + } +} + +// ---------------------------------------------------------------------------- + +var obj = new SuperDerived(); +assert.equal(41, obj.m()); +assert.equal(40, obj.superM()); +assert.equal(10, obj.baseX); +assert.equal(10, obj.x); +assert.equal(10, obj.superX()); +assert.equal(2, obj.baseC); +assert.equal(3, obj.derC); diff --git a/packages/babel/test/fixtures/traceur/Classes/Skip_DerivedButton.js b/packages/babel/test/fixtures/traceur/Classes/Skip_DerivedButton.js new file mode 100644 index 0000000000..15f63caf26 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Skip_DerivedButton.js @@ -0,0 +1,39 @@ +// Skip. Not implemented. +// Only in browser. + +class CustomButton extends HTMLButtonElement { + constructor() { + this.value = 'Custom Button'; + } +} + +class CustomSelect extends HTMLSelectElement {} +class CustomInput extends HTMLInputElement {} +class CustomDiv extends HTMLDivElement {} +class CustomUIEvent extends UIEvent {} +// class CustomSpan extends HTMLSpanElement {} +class CustomTableRow extends HTMLTableRowElement {} +class CustomHeading extends HTMLHeadingElement {} +class CustomElement extends HTMLElement {} +class CustomUList extends HTMLUListElement {} +class CustomLI extends HTMLLIElement {} +class CustomMenu extends HTMLMenuElement {} +class CustomTextArea extends HTMLTextAreaElement {} + +// ---------------------------------------------------------------------------- + +var button = new CustomButton(); +document.body.appendChild(button); +document.body.appendChild(new CustomSelect()); +document.body.appendChild(new CustomInput()); +document.body.appendChild(new CustomDiv()); +// document.body.appendChild(new CustomSpan()); +document.body.appendChild(new CustomTableRow()); +document.body.appendChild(new CustomHeading()); +document.body.appendChild(new CustomElement()); +document.body.appendChild(new CustomUList()); +document.body.appendChild(new CustomLI()); +document.body.appendChild(new CustomMenu()); +document.body.appendChild(new CustomTextArea()); + +// TODO(rnystrom): Test these. diff --git a/packages/babel/test/fixtures/traceur/Classes/Skip_HTMLBlockquoteElement.js b/packages/babel/test/fixtures/traceur/Classes/Skip_HTMLBlockquoteElement.js new file mode 100644 index 0000000000..8841875d64 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Skip_HTMLBlockquoteElement.js @@ -0,0 +1,16 @@ +// Skip. Not implemented. +// Only in browser. + +class CustomBlockquote extends HTMLBlockquoteElement { + constructor() { + this.custom = 42; + } +} + +var customBlockquote = new CustomBlockquote; +assert.equal(42, customBlockquote.custom); +assert.equal('BLOCKQUOTE', customBlockquote.tagName); +assert.isTrue(customBlockquote instanceof CustomBlockquote); +assert.isTrue(customBlockquote instanceof HTMLBlockquoteElement); +assert.isTrue(customBlockquote instanceof HTMLQuoteElement); +assert.isTrue(customBlockquote instanceof HTMLElement); diff --git a/packages/babel/test/fixtures/traceur/Classes/Static.js b/packages/babel/test/fixtures/traceur/Classes/Static.js new file mode 100644 index 0000000000..08e9228253 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Static.js @@ -0,0 +1,70 @@ +var x = 42; + +class B { + static m() { + return this; + } + + static get x() { + return x; + } + + static set x(value) { + x = value; + } +} + +assert.equal(B, B.m()); +assert.equal(42, B.x); +B.x = 1; +assert.equal(1, x); + +class StaticMethod { + static static() { + return 'static method'; + } +} + +assert.equal('static method', StaticMethod.static()); + +class StaticGetter { + static get static() { + return 'static getter'; + } +} + +assert.equal('static getter', StaticGetter.static); + +class StaticSetter { + static set static(value) { + x = value; + } +} + +StaticSetter.static = 'static setter'; +assert.equal('static setter', x); + +class MethodNamedStatic { + static() { + return this; + } +} + +var c = new MethodNamedStatic(); +assert.equal(c, c.static()); + +class AccessorNamedStatic { + get static() { + return [this, x]; + } + + set static(value) { + x = [this, value]; + } +} + +x = 2; +c = new AccessorNamedStatic(); +assertArrayEquals([c, 2], c.static); +c.static = 3; +assertArrayEquals([c, 3], x); diff --git a/packages/babel/test/fixtures/traceur/Classes/StaticSuper.js b/packages/babel/test/fixtures/traceur/Classes/StaticSuper.js new file mode 100644 index 0000000000..558c5bb334 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/StaticSuper.js @@ -0,0 +1,35 @@ +var x = 'B.getter'; + +class B { + static method() { + return [this, 'B.method']; + } + + static get getter() { + return [this, x]; + } + + static set setter(value) { + x = [this, value]; + } +} + +class C extends B { + static method() { + return super.method(); + } + + static get getter() { + return super.getter; + } + + static set setter(value) { + super.setter = value; + } +} + +assertArrayEquals([C, 'B.method'], C.method()); +assertArrayEquals([C, 'B.getter'], C.getter); + +C.setter = 'B.setter'; +assertArrayEquals([C, 'B.setter'], x); diff --git a/packages/babel/test/fixtures/traceur/Classes/StaticSuperNoExtends.js b/packages/babel/test/fixtures/traceur/Classes/StaticSuperNoExtends.js new file mode 100644 index 0000000000..58c369a789 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/StaticSuperNoExtends.js @@ -0,0 +1,47 @@ +var x = 42; + +Function.prototype.testFunction = function() { + return [this, 42, this.call]; +}; + +Object.defineProperty(Function.prototype, 'testGetter', { + get: function() { + return [this, x, this.call]; + }, + configurable: true +}); + + +Object.defineProperty(Function.prototype, 'testSetter', { + set: function(value) { + x = [this, value, this.call]; + }, + configurable: true +}); + + +class NoExtends { + static method() { + return super.testFunction(); + } + + static get getter() { + return super.testGetter; + } + + static set setter(value) { + super.testSetter = value; + } +} + +var call = Function.prototype.call; +assertArrayEquals([NoExtends, 42, call], NoExtends.method()); + +assertArrayEquals([NoExtends, 42, call], NoExtends.getter); + +NoExtends.setter = 1; +assertArrayEquals([NoExtends, 1, call], x); + +delete Function.prototype.testFunction; +delete Function.prototype.testGetter; +delete Function.prototype.testSetter; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Classes/StaticSymbol.js b/packages/babel/test/fixtures/traceur/Classes/StaticSymbol.js new file mode 100644 index 0000000000..22214d8b37 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/StaticSymbol.js @@ -0,0 +1,7 @@ +var sym = Symbol(); +class C { + static [sym]() { + return 42; + } +} +assert.equal(C[sym](), 42); diff --git a/packages/babel/test/fixtures/traceur/Classes/Strict.js b/packages/babel/test/fixtures/traceur/Classes/Strict.js new file mode 100644 index 0000000000..27e3f43757 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Strict.js @@ -0,0 +1,36 @@ +class C1 { + m() { + return function() { + return this; + }(); + } +} + +class C2 extends C1 { + m() { + return function() { + return this; + }(); + } +} + +var C3 = class { + m() { + return function() { + return this; + }(); + } +}; + +var C4 = class extends C3 { + m() { + return function() { + return this; + }(); + } +}; + +assert.isUndefined(new C1().m()); +assert.isUndefined(new C2().m()); +assert.isUndefined(new C3().m()); +assert.isUndefined(new C4().m()); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperChaining.js b/packages/babel/test/fixtures/traceur/Classes/SuperChaining.js new file mode 100644 index 0000000000..5688aa62fd --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperChaining.js @@ -0,0 +1,28 @@ +class ChainA { + foo() { + return 'A'; + } +} + +class ChainB extends ChainA { + foo() { + return super.foo() + ' B'; + } +} + +class ChainC extends ChainB { + foo() { + return super.foo() + ' C'; + } +} + +class ChainD extends ChainC { + foo() { + return super.foo() + ' D'; + } +} + +// ---------------------------------------------------------------------------- + +var d = new ChainD(); +assert.equal('A B C D', d.foo()); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperChangeProto.js b/packages/babel/test/fixtures/traceur/Classes/SuperChangeProto.js new file mode 100644 index 0000000000..6bf02b2620 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperChangeProto.js @@ -0,0 +1,20 @@ +var log = ''; + +class Base { + p() { log += '[Base]'; } +} + +class OtherBase { + p() { log += '[OtherBase]'; } +} +class Derived extends Base { + p() { + log += '[Derived]'; + super.p(); + Derived.prototype.__proto__ = OtherBase.prototype; + super.p(); + } +} + +new Derived().p(); +assert.equal(log, '[Derived][Base][OtherBase]'); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperInArrow.js b/packages/babel/test/fixtures/traceur/Classes/SuperInArrow.js new file mode 100644 index 0000000000..4b0b62fff8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperInArrow.js @@ -0,0 +1,19 @@ +var x; + +class B { + m(v) { + x = v; + } +} + +class D extends B { + n(x) { + var f = (x) => { + super.m(x); + }; + f(x); + } +} + +new D().n(42); +assert.equal(x, 42); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperMissing.js b/packages/babel/test/fixtures/traceur/Classes/SuperMissing.js new file mode 100644 index 0000000000..6eb4f8679f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperMissing.js @@ -0,0 +1,40 @@ +class MissingSuperA {} + +class MissingSuperB extends MissingSuperA { + method() { + return super.foo(); + } + field() { + return super.foo; + } +} + +// ---------------------------------------------------------------------------- + +// Collect the expected values. +var expectedF; +var expectedM; +var actualF; +var actualM; + +expectedF = ({}).x; +try { + ({}).method(); +} catch (e) { + expectedM = e; +} + +// Test against those. +var b = new MissingSuperB(); +var actualF = b.field(); +var actualM; +try { + b.method(); +} catch (e) { + actualM = e; +} + +assert.equal(actualF, expectedF); +assert.instanceOf(expectedM, TypeError); +assert.instanceOf(actualM, TypeError); +assert.equal(Object.getPrototypeOf(actualM), Object.getPrototypeOf(expectedM)); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperNestedClass.js b/packages/babel/test/fixtures/traceur/Classes/SuperNestedClass.js new file mode 100644 index 0000000000..61c4632799 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperNestedClass.js @@ -0,0 +1,21 @@ +class Animal { + constructor(name) { + this.name = name; + } +} + +class Roo extends Animal { + constructor() { + class Koala extends (super('R'), Animal) { + constructor() { + super('K'); + } + } + this.a = new Koala; + } +} + + +var r = new Roo(); +assert.equal('R', r.name); +assert.equal('K', r.a.name); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperPostfix.js b/packages/babel/test/fixtures/traceur/Classes/SuperPostfix.js new file mode 100644 index 0000000000..843c26891e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperPostfix.js @@ -0,0 +1,23 @@ +class B { + constructor() { + this._x = 0; + } + get x() { + return this._x; + } + set x(x) { + this._x = x; + } +} + +class C extends B { + m() { + assert.equal(this.x, 0); + assert.equal(super.x++, 0); + assert.equal(this.x, 1); + assert.equal(super.x--, 1); + assert.equal(this.x, 0); + } +} + +new C().m(); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperSet.js b/packages/babel/test/fixtures/traceur/Classes/SuperSet.js new file mode 100644 index 0000000000..cb612b9fe0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperSet.js @@ -0,0 +1,56 @@ +class B { + constructor() { + this._y = {v: 321}; + this._z = 1; + } + set x(value) { + this._x = value; + } + get x() { + return this._y; + } + getX() { + return this._x; + } + getV() { + return this._y.v + } + + set z(v) { + this._z = v; + } + get z() { + return this._z; + } +} + +class C extends B { + constructor() { + super(); + } + set x(value) { + assert.equal(super.x = value, value); + } + set v(value) { + return super.x.v = value; + } + inc(val) { + assert.equal(super.z += val, 4); + } + incLookup(val) { + assert.equal(super['z'] += val, 9); + } +} + +var c = new C; +c.x = 42; +assert.equal(42, c.getX()); + +c.v = 123; +assert.equal(123, c.getV()); + +c.inc(3); +assert.equal(4, c.z); + +c.incLookup(5); +assert.equal(9, c.z); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperUnary.js b/packages/babel/test/fixtures/traceur/Classes/SuperUnary.js new file mode 100644 index 0000000000..310041e220 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperUnary.js @@ -0,0 +1,26 @@ +class B { + constructor() { + this._x = 0; + } + get x() { + return this._x; + } + set x(x) { + this._x = x; + } +} + +class C extends B { + m() { + assert.equal(this.x, 0); + assert.equal(++super.x, 1); + assert.equal(this.x, 1); + assert.equal(--super.x, 0); + assert.equal(this.x, 0); + + // Don't use assert.typeOf since we are testing typeof. + assert.equal(typeof super.x, 'number'); + } +} + +new C().m(); diff --git a/packages/babel/test/fixtures/traceur/Classes/SuperWithoutExtends.js b/packages/babel/test/fixtures/traceur/Classes/SuperWithoutExtends.js new file mode 100644 index 0000000000..5b2546b084 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/SuperWithoutExtends.js @@ -0,0 +1,15 @@ +class C { + constructor() { + this.x = true; + } + static m() { + return super.hasOwnProperty('m'); + } + + m() { + return super.hasOwnProperty('x'); + } +} + +assert.isTrue(new C().m()); +assert.isTrue(C.m()); diff --git a/packages/babel/test/fixtures/traceur/Classes/Types.js b/packages/babel/test/fixtures/traceur/Classes/Types.js new file mode 100644 index 0000000000..dbdfd6e262 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Classes/Types.js @@ -0,0 +1,26 @@ +// Options: --types + +class Typed { + constructor(x : number) { + this.x_ = x; + } + + addTo(y : number) : number { + this.x += y; + return this.x; + } + + get x() : number { + return this.x_; + } + + set x(x : number) { + this.x_ = x; + } +} + +// Generics, ClassExpression +var C = class ClassExpression {}; + +assert.equal(1, new Typed(1).x); +assert.equal(2, new Typed(1).addTo(1)); diff --git a/packages/babel/test/fixtures/traceur/Collections/Map.js b/packages/babel/test/fixtures/traceur/Collections/Map.js new file mode 100644 index 0000000000..8dd3004e0c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Collections/Map.js @@ -0,0 +1,240 @@ +var t = new Map(); + +var objectKey = {}; +var stringKey = 'keykeykey'; +var numberKey = 42.24; +var booleanKey = true; +var undefinedKey = undefined; +var nullKey = null; +var nanKey = NaN; +var zeroKey = 0; + + +assert.equal(t.size, 0); + +t.set(undefinedKey, 'value8'); +t.set(nullKey, 'value9'); +t.set(stringKey, 'value5'); +t.set(numberKey, 'value6'); +t.set(booleanKey, 'value7'); +t.set(objectKey, 'value1'); +t.set(nanKey, 'value10'); +t.set(zeroKey, 'value11'); + +assert.equal(t.size, 8); + +assert.equal(t.get(objectKey), 'value1'); +assert.equal(t.get(stringKey), 'value5'); +assert.equal(t.get(numberKey), 'value6'); +assert.equal(t.get(booleanKey), 'value7'); +assert.equal(t.get(undefinedKey), 'value8'); +assert.equal(t.get(nullKey), 'value9'); +assert.equal(t.get(nanKey), 'value10'); +assert.equal(t.get(zeroKey), 'value11'); + +assert.equal(t.get({}), undefined); +assert.equal(t.get('keykeykey'), 'value5'); +assert.equal(t.get(42.24), 'value6'); +assert.equal(t.get(true), 'value7'); +assert.equal(t.get(undefined), 'value8'); +assert.equal(t.get(null), 'value9'); +assert.equal(t.get(NaN), 'value10'); +assert.equal(t.get(0), 'value11'); +assert.equal(t.get(1 / Infinity), 'value11'); + +// V8 is broken for -0 +// https://code.google.com/p/v8/issues/detail?id=3906 +// assert.equal(t.get(-1 / Infinity), 'value11'); + +assert.isTrue(!t.has({})); + +assert.isTrue(t.has(objectKey)); +assert.isTrue(t.has(stringKey)); +assert.isTrue(t.has(numberKey)); +assert.isTrue(t.has(booleanKey)); +assert.isTrue(t.has(undefinedKey)); +assert.isTrue(t.has(nullKey)); +assert.isTrue(t.has(nanKey)); +assert.isTrue(t.has(zeroKey)); + +assert.isTrue(t.has('keykeykey')); +assert.isTrue(t.has(42.24)); +assert.isTrue(t.has(true)); +assert.isTrue(t.has(undefined)); +assert.isTrue(t.has(null)); +assert.isTrue(t.has(NaN)); +assert.isTrue(t.has(0)); + +// V8 is broken for -0 +// https://code.google.com/p/v8/issues/detail?id=3906 +// assert.isTrue(t.has(-0)); + + +// forEach +var arrKeys = []; +var arr = []; +var cnt = 0; +t.forEach(function (value, key, map) { + if (cnt === 0) { + t.set('foo', 42); + } + assert.equal(map, t); + arrKeys.push(key); + arr.push(value); + cnt++; +}); +assert.equal(cnt, 9); +t.delete('foo'); + +assertArrayEquals(arrKeys, [ + undefinedKey, + nullKey, + stringKey, + numberKey, + booleanKey, + objectKey, + nanKey, + zeroKey, + 'foo' +]); +assertArrayEquals(arr, [ + 'value8', + 'value9', + 'value5', + 'value6', + 'value7', + 'value1', + 'value10', + 'value11', + 42 +]); + +// iterator +arrKeys = []; +arr = []; +cnt = 0; + +for (var mapIterItem of t) { + if (cnt === 0) { + t.set('foo', 42); + } + var [mapIterItemKey, mapIterItemVal] = mapIterItem; + arrKeys.push(mapIterItemKey); + arr.push(mapIterItemVal); + cnt++; +} +assert.equal(cnt, 9); +t.delete('foo'); + +assertArrayEquals(arrKeys, [ undefinedKey, nullKey, stringKey, + numberKey, booleanKey, objectKey, + nanKey, zeroKey, 'foo' ]); +assertArrayEquals(arr, [ + 'value8', + 'value9', + 'value5', + 'value6', + 'value7', + 'value1', + 'value10', + 'value11', + 42 +]); + + +// .entries() +arrKeys = []; +arr = []; +cnt = 0; + +for (var mapIterItem of t.entries()) { + var [mapIterItemKey, mapIterItemVal] = mapIterItem; + arrKeys.push(mapIterItemKey); + arr.push(mapIterItemVal); + cnt++; +} +assert.equal(cnt, 8); + +assertArrayEquals(arrKeys, [ + undefinedKey, + nullKey, + stringKey, + numberKey, + booleanKey, + objectKey, + nanKey, + zeroKey +]); +assertArrayEquals(arr, [ + 'value8', + 'value9', + 'value5', + 'value6', + 'value7', + 'value1', + 'value10', + 'value11' +]); + + +// .keys() +arrKeys = []; +cnt = 0; + +for (var mapIterKey of t.keys()) { + arrKeys.push(mapIterKey); + cnt++; +} +assert.equal(cnt, 8); + +assertArrayEquals(arrKeys, [ + undefinedKey, + nullKey, + stringKey, + numberKey, + booleanKey, + objectKey, + nanKey, + zeroKey +]); + + +// .values() +arr = []; +cnt = 0; + +for (var mapIterVal of t.values()) { + arr.push(mapIterVal); + cnt++; +} +assert.equal(cnt, 8); + +assertArrayEquals(arr, [ + 'value8', + 'value9', + 'value5', + 'value6', + 'value7', + 'value1', + 'value10', + 'value11' +]); + + +var t3 = new Map([ [[],[]], [{},{}], [NaN,NaN] ]); +var deleteReturnValue; + +assert.equal(t3.size, 3); +assert.isTrue(t3.has(NaN)); +assert.isTrue(isNaN(t3.get(NaN))); +assert.equal(t3.set(NaN, NaN), t3); // test of 23.1.3.9.11 +deleteReturnValue = t3.delete(NaN); +assert.equal(t3.size, 2); +assert.isTrue(deleteReturnValue); +deleteReturnValue = t3.delete(NaN); +assert.equal(t3.size, 2); +assert.isFalse(deleteReturnValue); +t3.clear(); +assert.equal(t3.size, 0); + +assert.equal(Map.prototype[Symbol.iterator], Map.prototype.entries); diff --git a/packages/babel/test/fixtures/traceur/Collections/Set.js b/packages/babel/test/fixtures/traceur/Collections/Set.js new file mode 100644 index 0000000000..460253a857 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Collections/Set.js @@ -0,0 +1,145 @@ +var t = new Set(); + +var objectKey = {}; +var stringKey = 'keykeykey'; +var numberKey = 42.24; +var booleanKey = true; +var undefinedKey = undefined; +var nullKey = null; +var nanKey = NaN; +var zeroKey = 0; +var addReturnValue; + +t.add(objectKey); +t.add(stringKey); +t.add(numberKey); +t.add(booleanKey); +t.add(undefinedKey); +t.add(nullKey); +t.add(nanKey); +addReturnValue = t.add(zeroKey); + +assert.equal(t.size, 8); +assert.equal(t, addReturnValue); + +assert.isTrue(!t.has({})); + +assert.isTrue(t.has(objectKey)); +assert.isTrue(t.has(stringKey)); +assert.isTrue(t.has(numberKey)); +assert.isTrue(t.has(booleanKey)); +assert.isTrue(t.has(undefinedKey)); +assert.isTrue(t.has(nullKey)); +assert.isTrue(t.has(nanKey)); +assert.isTrue(t.has(zeroKey)); + +assert.isTrue(t.has('keykeykey')); +assert.isTrue(t.has(42.24)); +assert.isTrue(t.has(true)); +assert.isTrue(t.has(undefined)); +assert.isTrue(t.has(null)); +assert.isTrue(t.has(NaN)); +assert.isTrue(t.has(0)); + +// V8 is broken for -0 +// https://code.google.com/p/v8/issues/detail?id=3906 +// assert.isTrue(t.has(-0)); + +var expected = [ + undefinedKey, + nullKey, + stringKey, + numberKey, + booleanKey, + objectKey, + nanKey, + zeroKey +]; +expected.sort(); + + +// forEach +var arr = []; +var cnt = 0; +var context = {}; + +t.forEach(function(val, val2, obj) { + if (isNaN(val)) { + assert.isTrue(isNaN(val2)); + } else { + assert.equal(val, val2); + } + assert.equal(obj, t); + assert.equal(this, context) + arr.push(val); + cnt++; +}, context); + +assert.equal(cnt, 8); + +arr.sort(); +assertArrayEquals(arr, expected); + +// iterator +arr = []; +cnt = 0; + +for (var setIterVal of t) { + arr.push(setIterVal); + cnt++; +} +assert.equal(cnt, 8); + + +arr.sort(); +assertArrayEquals(arr, expected); + +// .values() +arr = []; +cnt = 0; + +for (var setIterVal of t.values()) { + arr.push(setIterVal); + cnt++; +} +assert.equal(cnt, 8); + + +arr.sort(); +assertArrayEquals(arr, expected); + +var t3 = new Set([[], {}, NaN]); +assert.equal(t3.size, 3); +assert.isTrue(t3.has(NaN)); +t3.delete(NaN); +assert.equal(t3.size, 2); +t3.delete(NaN); +assert.equal(t3.size, 2); +t3.clear(); +assert.equal(t3.size, 0); + +// .keys() +var t4 = new Set(); +var iter = t4.keys(); +t4.add(objectKey); +t4.add(stringKey); +t4.add(nanKey); +assert.deepEqual(iter.next(), {value: objectKey, done: false}); +assert.deepEqual(iter.next(), {value: stringKey, done: false}); +t4.delete(nanKey); +assert.deepEqual(iter.next(), {value: undefined, done: true}); + +assert.equal(Set.prototype.keys, Set.prototype.values); + +// .entries() +var t5 = new Set(); +var iter = t5.entries(); +t5.add(objectKey); +t5.add(stringKey); +t5.add(nanKey); +assert.deepEqual(iter.next(), {value: [objectKey, objectKey], done: false}); +assert.deepEqual(iter.next(), {value: [stringKey, stringKey], done: false}); +t5.delete(nanKey); +assert.deepEqual(iter.next(), {value: undefined, done: true}); + +assert.equal(Set.prototype[Symbol.iterator], Set.prototype.values); diff --git a/packages/babel/test/fixtures/traceur/Collections/SetWithSymbols.js b/packages/babel/test/fixtures/traceur/Collections/SetWithSymbols.js new file mode 100644 index 0000000000..a454bf6bf7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Collections/SetWithSymbols.js @@ -0,0 +1,2 @@ +var s = new Set(['Banana', 'Orange', 'Apple', 'Mango', 'Apple', 'Apple']); +assert.equal(s.size, 4); diff --git a/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Class.js b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Class.js new file mode 100644 index 0000000000..c9900c48ca --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Class.js @@ -0,0 +1,48 @@ +var x = '0'; +var y; + +class C { + [x]() { + return 0; + } + get [1]() { + return 1; + } + set [2](v) { + y = v; + } + *[3]() { + yield 3; + } + + static [4]() { + return 4; + } + static get [5]() { + return 5; + } + static set [6](v) { + y = v; + } + static *[7]() { + yield 7; + } +} + +var object = new C; +assert.equal(object[0](), 0); +assert.equal(object[1], 1); +object[2] = 2; +assert.equal(y, 2); +var g = object[3](); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); + + +assert.equal(C[4](), 4); +assert.equal(C[5], 5); +C[6] = 6; +assert.equal(y, 6); +var g = C[7](); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); diff --git a/packages/babel/test/fixtures/traceur/ComputedPropertyNames/ComputedPropertyNames.js b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/ComputedPropertyNames.js new file mode 100644 index 0000000000..722c0fc180 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/ComputedPropertyNames.js @@ -0,0 +1,35 @@ +var x = '0'; +var y; +var object = { + [x]: 0, + [1]: 1, + [2]() { + return 2; + }, + get [3]() { + return 3; + }, + set [4](v) { + y = v; + }, + *[5]() { + yield 5; + } +}; + +assert.equal(object[0], 0); +assert.equal(object[1], 1); +assert.equal(object[2](), 2); +object[4] = 4; +assert.equal(y, 4); +var g = object[5](); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); + +var object2 = { + __proto__: object, + [6]: 6 +}; + +assert.equal(object2[6], 6); +assert.equal(object2[0], 0); diff --git a/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Error_Disabled.js b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Error_Disabled.js new file mode 100644 index 0000000000..099c8907e3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Error_Disabled.js @@ -0,0 +1,6 @@ +// Options: --computed-property-names=false +// Error: :5:3: Unexpected token [ + +var object = { + [1]: 2 +}; diff --git a/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Symbol.js b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Symbol.js new file mode 100644 index 0000000000..9f4aad203c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ComputedPropertyNames/Symbol.js @@ -0,0 +1,7 @@ +var s = Symbol(); + +var object = { + [s]: 42 +}; + +assert.equal(object[s], 42); diff --git a/packages/babel/test/fixtures/traceur/DefaultParameters/Error_SetAccessor.js b/packages/babel/test/fixtures/traceur/DefaultParameters/Error_SetAccessor.js new file mode 100644 index 0000000000..039a0fc438 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/DefaultParameters/Error_SetAccessor.js @@ -0,0 +1,6 @@ +// Error: :5:15: Unexpected token = + +var object = { + // Default parameters are not allowed on setters. + set x(value = 42) {} +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/DefaultParameters/Simple.js b/packages/babel/test/fixtures/traceur/DefaultParameters/Simple.js new file mode 100644 index 0000000000..0f2b26b2c6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/DefaultParameters/Simple.js @@ -0,0 +1,45 @@ +function f(a = 1, b = 2) { + return a + b; +} + +assert.equal(0, f.length); +assert.equal(3, f()); +assert.equal(6, f(4)); +assert.equal(24, f(8, 16)); + +assert.equal(3, f(undefined, undefined)); +assert.equal(33, f(undefined, 32)); + +function g(a, b = a) { + return a + b; +} + +assert.equal(1, g.length); +assert.equal(4, g(2)); +assert.equal(4, g(2, undefined)); +assert.equal(5, g(2, 3)); + +function C(obj = this) { + this.obj = obj; +} + +assert.equal(0, C.length); + +var c = new C; +assert.equal(c, c.obj); + +var c2 = new C(undefined); +assert.equal(c2, c2.obj); + +var c3 = new C(42); +assert.equal(42, c3.obj); + +function h(a = 1, b) { + return {a: a, b: b}; +} + +assert.equal(1, h().a); +assert.equal(2, h(2).a); +assert.isUndefined(h().b); +assert.isUndefined(h(2).b); +assert.equal(4, h(3, 4).b); diff --git a/packages/babel/test/fixtures/traceur/DefaultParameters/Strict.js b/packages/babel/test/fixtures/traceur/DefaultParameters/Strict.js new file mode 100644 index 0000000000..f35bad3590 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/DefaultParameters/Strict.js @@ -0,0 +1,6 @@ +function f(a = 1) { + 'use strict'; + return this; +} + +assert.isUndefined(f()); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Arguments.js b/packages/babel/test/fixtures/traceur/Destructuring/Arguments.js new file mode 100644 index 0000000000..7046316663 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Arguments.js @@ -0,0 +1,8 @@ +function destructureArguments(x, y) { + [arguments[0], [arguments[1]]] = [1, [2]] + return x + y; +} + +// ---------------------------------------------------------------------------- + +assert.equal(3, destructureArguments(1, 2)); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Array.js b/packages/babel/test/fixtures/traceur/Destructuring/Array.js new file mode 100644 index 0000000000..6f6d979e59 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Array.js @@ -0,0 +1,25 @@ +function destructArray() { + var a, b, c, d; + [a, [b], c, d] = ['hello', [',', 'junk'], ['world']]; + return { + a: a, + b: b, + c: c, + d: d + }; +} + +// ---------------------------------------------------------------------------- + +var result = destructArray(); +assert.equal('hello', result.a); +assert.equal(',', result.b); +assertArrayEquals(['world'], result.c); +assert.isUndefined(result.d); + +function testNested() { + var a; + [[a] = ['b']] = []; + return a; +} +assert.equal(testNested(), 'b'); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternTrailingComma.js b/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternTrailingComma.js new file mode 100644 index 0000000000..26dcf17f1b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternTrailingComma.js @@ -0,0 +1,8 @@ +var [a, b, , ] = [0, 1, , ]; +assert.equal(a, 0); +assert.equal(b, 1); + +var c, d; +[c, d, , ] = [0, 1, , ]; +assert.equal(c, 0); +assert.equal(d, 1); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternWithCoverInitializedName.js b/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternWithCoverInitializedName.js new file mode 100644 index 0000000000..89269b0000 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternWithCoverInitializedName.js @@ -0,0 +1,5 @@ +var x, y; +[x, {y = 1}] = [0, {}]; + +assert.equal(x, 0); +assert.equal(y, 1); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternWithInitializer.js b/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternWithInitializer.js new file mode 100644 index 0000000000..6a97645aae --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ArrayPatternWithInitializer.js @@ -0,0 +1,5 @@ +// https://github.com/google/traceur-compiler/issues/969 + +var x; +[x = 1] = []; +assert.equal(x, 1); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ArrowFunction.js b/packages/babel/test/fixtures/traceur/Destructuring/ArrowFunction.js new file mode 100644 index 0000000000..bbc7a75b66 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ArrowFunction.js @@ -0,0 +1,17 @@ +var f = ({x}) => x; +assert.equal(42, f({x: 42})); + +var g = ({x: y, z: [a, b, ...c]}) => [y, a, b, c]; +assertArrayEquals([1, 2, 3, [4, 5]], g({x: 1, z: [2, 3, 4, 5]})); + +var h = ([a, {b: c, d}]) => [a, c, d]; +assertArrayEquals([1, 2, 3], h([1, {b: 2, d: 3}])); + +var i = ([, a]) => a; +assert.equal(i([0, 1]), 1); + +var j = ([, [, a]]) => a; +assert.equal(j([0, [1, 2]]), 2); + +var k = ([a] = new String('b')) => a; +assert.equal(k(), 'b'); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Catch.js b/packages/babel/test/fixtures/traceur/Destructuring/Catch.js new file mode 100644 index 0000000000..6b110c025f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Catch.js @@ -0,0 +1,30 @@ +var head = 'head'; +var tail = 'tail'; +var name = 'name'; + +function MyError(s) { + this.message = new String(s); + this.name = 'Error'; +} + +try { + throw new MyError('abc'); +} catch ({message: [head, ...tail], name}) { + assert.equal('a', head); + assertArrayEquals(['b', 'c'], tail); + assert.equal('Error', name); +} + +assert.equal('head', head); +assert.equal('tail', tail); +assert.equal('name', name); + +assert.throws(() => { + try { + throw [0]; + } catch ([innerX]) { + + } + + innerX; +}, ReferenceError); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Class.js b/packages/babel/test/fixtures/traceur/Destructuring/Class.js new file mode 100644 index 0000000000..c699d39c4c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Class.js @@ -0,0 +1,28 @@ +function MyError(s) { + this.message = new String(s); + this.name = 'Error'; +} + +class C { + constructor({message: [head, ...tail], name}) { + assert.equal('a', head); + assertArrayEquals(['b', 'c'], tail); + assert.equal('Error', name); + } + + method({message: [head, ...tail], name}) { + assert.equal('a', head); + assertArrayEquals(['b', 'c'], tail); + assert.equal('Error', name); + } + + set x({message: [head, ...tail], name}) { + assert.equal('a', head); + assertArrayEquals(['b', 'c'], tail); + assert.equal('Error', name); + } +} + +var c = new C(new MyError('abc')); +c.method(new MyError('abc')); +c.x = new MyError('abc'); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializedName.js b/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializedName.js new file mode 100644 index 0000000000..1b91bd3a8d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializedName.js @@ -0,0 +1,4 @@ +// https://github.com/google/traceur-compiler/issues/183 + +var f = ({x = 42}) => x; +assert.equal(f({}), 42); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializer.js b/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializer.js new file mode 100644 index 0000000000..ed37f7257d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializer.js @@ -0,0 +1,9 @@ +// https://github.com/google/traceur-compiler/issues/1015 + +var x, y; +({x = 1, y = 2} = {}); +assert.equal(x, 1); +assert.equal(y, 2); + +({x: {x = 3}} = {x: {}}); +assert.equal(x, 3); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializerInForOf.js b/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializerInForOf.js new file mode 100644 index 0000000000..eb0a9781d3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/CoverInitializerInForOf.js @@ -0,0 +1,9 @@ +// https://github.com/google/traceur-compiler/issues/836 + +var count = 0; +for ({a = 0} of [{}]) { + count++; + assert.equal(a, 0); +} + +assert.equal(count, 1); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/DefaultParams.js b/packages/babel/test/fixtures/traceur/Destructuring/DefaultParams.js new file mode 100644 index 0000000000..e6a1670b75 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/DefaultParams.js @@ -0,0 +1,5 @@ +function f([x] = [1], {y} = {y: 2}) { + return x + y; +} + +assert.equal(3, f()); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Empty.js b/packages/babel/test/fixtures/traceur/Destructuring/Empty.js new file mode 100644 index 0000000000..275534362b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Empty.js @@ -0,0 +1,32 @@ +var calls = 0; + +var {} = Object(calls++); +assert.equal(calls, 1); + +assert.throw(function() { + var [] = Object(calls++); +}, TypeError); +assert.equal(calls, 2); + +assert.throw(function() { + var {} = Object(calls++), [] = Object(calls++); +}); +assert.equal(calls, 4); + + +/////////////////////// + +calls = 0; + +({} = Object(calls++)); +assert.equal(calls, 1); + +assert.throw(function() { + [] = Object(calls++); +}, TypeError); +assert.equal(calls, 2); + +assert.throw(function() { + ({} = Object(calls++), [] = Object(calls++)); +}, TypeError); +assert.equal(calls, 4); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Error_Disabled.js b/packages/babel/test/fixtures/traceur/Destructuring/Error_Disabled.js new file mode 100644 index 0000000000..f177fe43b3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --destructuring=false +// Error: 4:5: Unexpected token [ + +var [x, y] = [0, 1]; diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Error_ForInWithInitializer.js b/packages/babel/test/fixtures/traceur/Destructuring/Error_ForInWithInitializer.js new file mode 100644 index 0000000000..ea9c29c5f7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Error_ForInWithInitializer.js @@ -0,0 +1,4 @@ +// Error: :3:19: Unexpected token in + +for (var {k} = {} in {}) { +} diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Error_ForOfWithInitializer.js b/packages/babel/test/fixtures/traceur/Destructuring/Error_ForOfWithInitializer.js new file mode 100644 index 0000000000..6a15645310 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Error_ForOfWithInitializer.js @@ -0,0 +1,4 @@ +// Error: :3:19: Unexpected token of + +for (var {k} = {} of []) { +} diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Error_InvalidArrowRest.js b/packages/babel/test/fixtures/traceur/Destructuring/Error_InvalidArrowRest.js new file mode 100644 index 0000000000..c7eca5a9d6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Error_InvalidArrowRest.js @@ -0,0 +1,3 @@ +// Error: :3:16: Unexpected token , + +var f = ([...xs, ys]) => xs; diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Error_InvalidCoverInitializedName.js b/packages/babel/test/fixtures/traceur/Destructuring/Error_InvalidCoverInitializedName.js new file mode 100644 index 0000000000..441d53c8d1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Error_InvalidCoverInitializedName.js @@ -0,0 +1,3 @@ +// Error: :3:5: Unexpected token = + +({x = 42}); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/EvaluatesToRvalue.js b/packages/babel/test/fixtures/traceur/Destructuring/EvaluatesToRvalue.js new file mode 100644 index 0000000000..9027f27207 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/EvaluatesToRvalue.js @@ -0,0 +1,9 @@ +function destructEvaluatesToRvalue() { + var a; + return [a] = [1, 2, 3]; +} + +// ---------------------------------------------------------------------------- + +var result = destructEvaluatesToRvalue(); +assertArrayEquals([1, 2, 3], result); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/EvaluationOrder.js b/packages/babel/test/fixtures/traceur/Destructuring/EvaluationOrder.js new file mode 100644 index 0000000000..50df75e13e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/EvaluationOrder.js @@ -0,0 +1,10 @@ +function destructEvaluationOrder() { + var a; + [a, a, a] = [1, 2, 3, 4]; + return a; +} + +// ---------------------------------------------------------------------------- + +var result = destructEvaluationOrder(); +assert.equal(3, result); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ForInLoop.js b/packages/babel/test/fixtures/traceur/Destructuring/ForInLoop.js new file mode 100644 index 0000000000..42aadf4239 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ForInLoop.js @@ -0,0 +1,28 @@ +// Options: --block-binding + +var object = { + abc: 0, // Keep all the keys at length 3. + def: 1 +}; + +var expectedHeads = ['a', 'd']; +var expectedTails = [['b', 'c'], ['e','f']]; +var i = 0; +for (var [head, ...tail] in object) { + assert.equal(expectedHeads[i], head); + assertArrayEquals(expectedTails[i], tail); + i++; +} +assert.equal(2, i); + +{ + let x = 42; + for (let {length: x} in object) { + assert.equal(3, x); + } + assert.equal(42, x); +} + +var k; +for ({length: k} in {abc: 3}) // No block + assert.equal(3, k); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ForOfLoop.js b/packages/babel/test/fixtures/traceur/Destructuring/ForOfLoop.js new file mode 100644 index 0000000000..cc9260c166 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ForOfLoop.js @@ -0,0 +1,28 @@ +// Options: --block-binding + +function* gen() { + yield new String('abc'); + yield new String('def'); +} + +var expectedHeads = ['a', 'd']; +var expectedTails = [['b', 'c'], ['e','f']]; +var i = 0; +for (var [head, ...tail] of gen()) { + assert.equal(expectedHeads[i], head); + assertArrayEquals(expectedTails[i], tail); + i++; +} +assert.equal(2, i); + +{ + let x = 42; + for (let {length: x} of gen()) { + assert.equal(3, x); + } + assert.equal(42, x); +} + +var k; +for ({length: k} of [new String('abc')]) // No block + assert.equal(3, k); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Destructuring/FunctionArrayPattern.js b/packages/babel/test/fixtures/traceur/Destructuring/FunctionArrayPattern.js new file mode 100644 index 0000000000..9af424c550 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/FunctionArrayPattern.js @@ -0,0 +1,14 @@ +function f([a, b, ...c], d) { + return [a, b, c, d]; +} +assertArrayEquals([1, 2, [3, 4], 5], f([1, 2, 3, 4], 5)); + +function g([, a]) { + return a; +} +assert.equal(g([0, 1]), 1); + +function h([, [, a]]) { + return a; +} +assert.equal(h([0, [1, 2]]), 2); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/FunctionObjectPattern.js b/packages/babel/test/fixtures/traceur/Destructuring/FunctionObjectPattern.js new file mode 100644 index 0000000000..612ae47dd2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/FunctionObjectPattern.js @@ -0,0 +1,5 @@ +function f({a, b: {c}}, d) { + return [a, c, d]; +} + +assertArrayEquals([1, 2, 3], f({a: 1, b: {c: 2}}, 3)); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Initializer.js b/packages/babel/test/fixtures/traceur/Destructuring/Initializer.js new file mode 100644 index 0000000000..ce8a9caa97 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Initializer.js @@ -0,0 +1,74 @@ +var [a = 0] = []; +assert.equal(0, a); + +var {b = 1} = {}; +assert.equal(1, b); + +var {c = 2} = {c: 3}; +assert.equal(3, c); + +var {d = 4} = Object.create({d: 5}); +assert.equal(5, d); + +var {e: f = 6} = {}; +assert.equal(6, f); + +var {g: h = 7} = {h: 8}; +assert.equal(7, h); + +var [, , , i = 9] = [10, 11, 12]; +assert.equal(9, i); + +function j({x = 42}, expected) { + assert.equal(expected, x); +} + +j({}, 42); +j({x: 43}, 43); + +var count = 0; +var [k = 42] = (count++, [21]); +assert.equal(21, k); +assert.equal(1, count); + +var {x = 1} = {x: undefined}; +assert.equal(x, 1); + +var {'x': x = 2} = {x: undefined}; +assert.equal(x, 2); + +var {['x']: x = 3} = {x: undefined}; +assert.equal(x, 3); + +var [y = 4] = [undefined]; +assert.equal(y, 4); + + +var xCount = 0; +var yCount = 0; +var zCount = 0; + +var object = { + get x() { + xCount++; + return { + get y() { + yCount++; + return { + get z() { + zCount++; + return undefined; + } + }; + } + }; + } +}; + +var {y: {z = 5, w = 6}, v = 7} = object.x; +assert.equal(z, 5); +assert.equal(w, 6); +assert.equal(v, 7); +assert.equal(xCount, 1); +assert.equal(yCount, 1); +assert.equal(zCount, 1); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/InitializerObject.js b/packages/babel/test/fixtures/traceur/Destructuring/InitializerObject.js new file mode 100644 index 0000000000..946b0e2a2d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/InitializerObject.js @@ -0,0 +1,12 @@ +var x, z; + +({x = {y: 1}} = {}); +assert.deepEqual(x, {y: 1}); + +({x = {y: {z = 2} = {}}} = {}); +assert.equal(z, 2); +assert.deepEqual(x, {y: {}}); + +({x = {y: {z = 3} = {z: 4}}} = {}); +assert.equal(z, 4); +assert.deepEqual(x, {y: {z: 4}}); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Method.js b/packages/babel/test/fixtures/traceur/Destructuring/Method.js new file mode 100644 index 0000000000..604bdc09fb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Method.js @@ -0,0 +1,14 @@ +function MyError(s) { + this.message = new String(s); + this.name = 'Error'; +} + +var object = { + method({message: [head, ...tail], name}) { + assert.equal('a', head); + assertArrayEquals(['b', 'c'], tail); + assert.equal('Error', name); + } +}; + +object.method(new MyError('abc')); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/MultipleCoverInitializersInArrowFunction.js b/packages/babel/test/fixtures/traceur/Destructuring/MultipleCoverInitializersInArrowFunction.js new file mode 100644 index 0000000000..f980a8fbd8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/MultipleCoverInitializersInArrowFunction.js @@ -0,0 +1,4 @@ +// https://github.com/google/traceur-compiler/issues/838 + +var f = ({a = 0}, {b = 1}) => ({a, b}); +assert.deepEqual(f({}, {}), {a: 0, b: 1}); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/NestedScopeArguments.js b/packages/babel/test/fixtures/traceur/Destructuring/NestedScopeArguments.js new file mode 100644 index 0000000000..692a1bcfd4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/NestedScopeArguments.js @@ -0,0 +1,11 @@ +// Destructuring bind alpha-renames 'arguments'; this ensures that +// renaming doesn't rename in nested scopes. +function destructNestedScopeArguments(x) { + [(function () { return arguments[1]; })(null, x)[0]] = [42]; +} + +// ---------------------------------------------------------------------------- + +var result = []; +destructNestedScopeArguments(result); +assert.equal(42, result[0]); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Object.js b/packages/babel/test/fixtures/traceur/Destructuring/Object.js new file mode 100644 index 0000000000..562f24d4e6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Object.js @@ -0,0 +1,42 @@ +function destructObject() { + var a, b, c, d; + ({a, x: b, y: {c, z: [,d]}} = { + a: 7, // field with shorthand a => a: a syntax + x: 8, // typical syntax + y: { // nested object destructuring + // missing binding 'c' + z: [10, 11, 12] // nested array destructuring + } + }); + return { + a: a, + b: b, + c: c, + d: d + }; +} + +// ---------------------------------------------------------------------------- + +var result = destructObject(); +assert.equal(7, result.a); +assert.equal(8, result.b); +assert.isUndefined(result.c); +assert.equal(11, result.d); + +var {0: x, '1': y, length: z} = [0, 1, 2, 3]; +assert.equal(0, x); +assert.equal(1, y); +assert.equal(4, z); + +var {x: y,} = {x: 5}; +assert.equal(5, y); + +var x; +({x = 6} = {}); +assert.equal(x, 6); + +var z; +({x: {y = 7}, z = 8} = {x: {}}); +assert.equal(y, 7); +assert.equal(z, 8); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Rest.js b/packages/babel/test/fixtures/traceur/Destructuring/Rest.js new file mode 100644 index 0000000000..6000165cf4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Rest.js @@ -0,0 +1,19 @@ +function destructRest() { + var a, b, c, d; + [...a] = [1, 2, 3]; + [b, ...c] = [1, 2, 3]; + [,,, ...d] = [1, 2, 3]; + return {a: a, b: b, c: c, d: d}; +} + +var result = destructRest(); +assertArrayEquals([1, 2, 3], result.a); +assert.equal(1, result.b); +assertArrayEquals([2, 3], result.c); +assertArrayEquals([], result.d); + +assert.throw(function() { + var e; + // No iterator. + [...e] = {x: 'boom'}; +}, TypeError); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/RestIterator.js b/packages/babel/test/fixtures/traceur/Destructuring/RestIterator.js new file mode 100644 index 0000000000..2963e51ed2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/RestIterator.js @@ -0,0 +1,45 @@ +(function() { + var i; + + function* f() { + for (i = 0; i < 8; i++) { + yield i; + } + } + var x, x2, xs; + [, x, , x2, , ...xs] = f(); + assert.equal(1, x); + assert.equal(3, x2); + assertArrayEquals([5, 6, 7], xs); + + [] = f(); + assert.equal(8, i); // Since we never call next(). + + x = -1; + [x] = f(); + assert.equal(0, x); + assert.equal(0, i); // Since we called next once. +})(); + +// Same but with VariableDeclarations instead of AssignmenExpressions. +(function() { + var i; + + function* f() { + for (i = 0; i < 8; i++) { + yield i; + } + } + + var [, x, , x2, , ...xs] = f(); + assert.equal(1, x); + assert.equal(3, x2); + assertArrayEquals([5, 6, 7], xs); + + var [] = f(); + assert.equal(8, i); // Since we never call next(). + + var [y] = f(); + assert.equal(0, y); + assert.equal(0, i); // Since we called next once. +})(); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ScopeThis.js b/packages/babel/test/fixtures/traceur/Destructuring/ScopeThis.js new file mode 100644 index 0000000000..c2f8c80087 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ScopeThis.js @@ -0,0 +1,19 @@ +function destructScopeThis() { + var x; + var o = { + f: function() { + [this.x] = [1]; + } + }; + o.f(); + return { + x: x, + o_x: o.x + }; +} + +// ---------------------------------------------------------------------------- + +var result = destructScopeThis(); +assert.isUndefined(result.x); +assert.equal(1, result.o_x); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/SetAccessor.js b/packages/babel/test/fixtures/traceur/Destructuring/SetAccessor.js new file mode 100644 index 0000000000..2273925139 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/SetAccessor.js @@ -0,0 +1,14 @@ +function MyError(s) { + this.message = new String(s); + this.name = 'Error'; +} + +var object = { + set x({message: [head, ...tail], name}) { + assert.equal('a', head); + assertArrayEquals(['b', 'c'], tail); + assert.equal('Error', name); + } +}; + +object.x = new MyError('abc'); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Simplify.js b/packages/babel/test/fixtures/traceur/Destructuring/Simplify.js new file mode 100644 index 0000000000..0a78850324 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Simplify.js @@ -0,0 +1,167 @@ +// It probably doesn't make a difference to the results, but the private name +// transformation turns array lookup and member access into function calls, and +// I'd like to keep that from being a confounding factor. + +'use strict'; + +var a, b, c, x, y, z; +a = b = c = x = y = z = undefined; + +// ---------------------------------------------------------------------------- + +function checkA() { + assert.equal(1, a); + assert.isUndefined(b); + assert.isUndefined(c); + a = b = c = undefined; +} + +function checkAb() { + assert.equal(1, a); + assert.equal(2, b); + assert.isUndefined(c); + a = b = c = undefined; +} + +function checkAbc() { + assert.equal(1, a); + assert.equal(2, b); + assert.equal(3, c); + a = b = c = undefined; +} + +// ---------------------------------------------------------------------------- + +// misc single assignment +var [a] = 42 === 42 ? [1] : [42]; +checkA(); +[a] = 42 === 42 ? [1] : [42]; +checkA(); + +var [a] = null || [1]; +checkA(); +[a] = null || [1]; +checkA(); + +// ParseTreeType.MEMBER_EXPRESSION +x = {x: {a: 1, b: 2, c: 3}}; +var {a, b, c} = x.x; +checkAbc(); + +var {a} = x.x; +checkA(); + +x = {x: [1, 2, 3]}; +var [a] = x.x; +checkA(); +[a] = x.x; +checkA(); + +// ParseTreeType.MEMBER_LOOKUP_EXPRESSION +x = [[1,2,3]]; +var [a] = x[0]; +checkA(); +[a] = x[0]; +checkA(); +var [a, b, c] = x[0]; +checkAbc(); +[a, b, c] = x[0]; +checkAbc(); + + +// ParseTreeType.PAREN_EXPRESSION +var [a] = 42 === 42 ? [1] : [42]; +checkA(); +[a] = 42 === 42 ? [1] : [42]; +checkA(); + +var [a] = null || [1]; +checkA(); +[a] = null || [1]; +checkA(); + +// ParseTreeType.ARRAY_LITERAL +var [a] = [1, 2, 3]; +checkA(); +[a] = [1, 2, 3]; +checkA(); +var [[a]] = [[1], 2, 3]; +checkA(); +[[a]] = [[1], 2, 3]; +checkA(); + +// ParseTreeType.OBJECT_LITERAL +var {a} = {a: 1, b: 2, c: 3}; +checkA(); +var {x: {a}} = {x: {a: 1, b: 2}, c: 3}; +checkA(); + +// ParseTreeType.CALL_EXPRESSION +x = function() { + return [1, 2, 3]; +}; +var [a, b, c] = x(); +checkAbc(); +[a, b, c] = x(); +checkAbc(); + +x = function() { + return {a: 1, b: 2, c: 3}; +}; +var {a, b, c} = x(); +checkAbc(); +// ParseTreeType.IDENTIFIER_EXPRESSION + +// arrays +x = [1, 2, 3]; +var [a] = x; +checkA(); +[a] = x; +checkA(); + +x = [[1], 2, 3]; +var [[a]] = x; +checkA(); +[[a]] = x; +checkA(); + +x = [[1, 2, 3]]; +var [[a, b, c]] = x; +checkAbc(); +[[a, b, c]] = x; +checkAbc(); + +x = [1, [2, 3]]; +var [ a, [b, c] ] = x; +checkAbc(); +[ a, [b, c] ] = x; +checkAbc(); + +x = [[1, 2], 3]; +var [[a, b], c] = x; +checkAbc(); +[[a, b], c] = x; +checkAbc(); + +x = [[1], 2, [3]]; +var [[a], b, [c]] = x; +checkAbc(); +[[a], b, [c]] = x; +checkAbc(); + +// objects +x = {a: 1, b: 2, c: 3}; +var {a, b, c} = x; +checkAbc(); + +x = {a: 1, b: 2, c: 3}; +var {a} = x; +checkA(); + +x = {a: 1, b: 2, c: 3}; +var {a, b, c} = x; +checkAbc(); + +x = {x: {a: 1, b: 2}, c: 3}; +var {x: {a}} = x; +checkA(); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/StrangeProperties.js b/packages/babel/test/fixtures/traceur/Destructuring/StrangeProperties.js new file mode 100644 index 0000000000..487cbd055d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/StrangeProperties.js @@ -0,0 +1,17 @@ +var x, y; + +({if: x = 1, else: y} = {else: 2}); +assert.equal(x, 1); +assert.equal(y, 2); + +({'': x = 3, ' ': y} = {' ': 4}); +assert.equal(x, 3); +assert.equal(y, 4); + +({true: x = 5, false: y} = {false: 6}); +assert.equal(x, 5); +assert.equal(y, 6); + +({0: x = 7, 1: y} = {1: 8}); +assert.equal(x, 7); +assert.equal(y, 8); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/Strict.js b/packages/babel/test/fixtures/traceur/Destructuring/Strict.js new file mode 100644 index 0000000000..d2b56659ce --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/Strict.js @@ -0,0 +1,6 @@ +function f({x}) { + 'use strict'; + return this; +} + +assert.isUndefined(f({x: 42})); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Destructuring/TopLevel.js b/packages/babel/test/fixtures/traceur/Destructuring/TopLevel.js new file mode 100644 index 0000000000..6409d45b91 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/TopLevel.js @@ -0,0 +1,9 @@ +var a, b, c, d; +[a, [b, c], d] = ['hello', [',', 'junk'], ['world']]; + +// ---------------------------------------------------------------------------- + +assert.equal('hello', a); +assert.equal(',', b); +assert.equal('junk', c); +assertArrayEquals(['world'], d); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/ValueTypes.js b/packages/babel/test/fixtures/traceur/Destructuring/ValueTypes.js new file mode 100644 index 0000000000..b76d12cc6c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/ValueTypes.js @@ -0,0 +1,58 @@ +(function() { + var {toFixed} = 42; + assert.equal(Number.prototype.toFixed, toFixed); + + var {toString, toLocaleString} = 42; + assert.equal(Number.prototype.toString, toString); + assert.equal(Number.prototype.toLocaleString, toLocaleString); + + var [x] = 'string'; + assert.equal('s', x); + + var [x, y] = 'string'; + assert.equal('s', x); + assert.equal('t', y); + + var [x, ...xs] = 'string'; + assert.equal('s', x); + assert.deepEqual(['t', 'r', 'i', 'n', 'g'], xs); + + var {toFixed: {length}} = 42; + assert.equal(1, length); + + var {x: {toString}} = {x: true}; + assert.equal(Boolean.prototype.toString, toString); + + var [[x]] = ['string']; + assert.equal('s', x); + + // Same with assignment expression + + ({toFixed} = 42); + assert.equal(Number.prototype.toFixed, toFixed); + + ({toString, toLocaleString} = 42); + assert.equal(Number.prototype.toString, toString); + assert.equal(Number.prototype.toLocaleString, toLocaleString); + + [x] = 'string'; + assert.equal('s', x); + + [x, y] = 'string'; + assert.equal('s', x); + assert.equal('t', y); + + [x, ...xs] = 'string'; + assert.equal('s', x); + assert.deepEqual(['t', 'r', 'i', 'n', 'g'], xs); + + ({toFixed: {length}} = 42); + assert.equal(1, length); + + ({x: {toString}} = {x: true}); + assert.equal(Boolean.prototype.toString, toString); + + [[x]] = ['string']; + assert.equal('s', x); + +})(); diff --git a/packages/babel/test/fixtures/traceur/Destructuring/VarDecl.js b/packages/babel/test/fixtures/traceur/Destructuring/VarDecl.js new file mode 100644 index 0000000000..ec77aff801 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Destructuring/VarDecl.js @@ -0,0 +1,27 @@ +// Options: --block-binding + +function destructVarDecl() { + // Const; and an array inside an object literal inside an array. + const a = 0, [b, {c, x: [d]}] = [1, {c: 2, x: [3]}]; + + // Now an object literal inside an array inside an object literal. + var {x: [{e}, f], g} = {x: [{e:4}, 5], g: 6}; + + // Two patterns in one var. + var {h} = {h: 7}, {i} = {i: 8}; + + return { a: a, b: b, c: c, d: d, e: e, f: f, g: g, h: h, i: i }; +} + +// ---------------------------------------------------------------------------- + +var result = destructVarDecl(); +assert.equal(0, result.a); +assert.equal(1, result.b); +assert.equal(2, result.c); +assert.equal(3, result.d); +assert.equal(4, result.e); +assert.equal(5, result.f); +assert.equal(6, result.g); +assert.equal(7, result.h); +assert.equal(8, result.i); diff --git a/packages/babel/test/fixtures/traceur/Exponentiation/Basics.js b/packages/babel/test/fixtures/traceur/Exponentiation/Basics.js new file mode 100644 index 0000000000..c6a775f489 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Exponentiation/Basics.js @@ -0,0 +1,42 @@ +// Options: --exponentiation + +(function() { + assert.equal(8, 2 ** 3); + assert.equal(24, 3 * 2 ** 3); + var x = 2; + assert.equal(8, 2 ** ++x); + assert.equal(1, 2 ** -1 * 2); + + var calls = 0; + var q = {q: 3}; + var o = { + get p() { + calls++; + return q; + } + }; + + o.p.q **= 2; + assert.equal(1, calls); + assert.equal(9, o.p.q); + + assert.equal(512, 2 ** (3 ** 2)); + assert.equal(512, 2 ** 3 ** 2); + + var y = 4; + var z = y **= 2; + assert.equal(16, z); + + function f(x) { + assert.equal(1, arguments.length); + return x; + } + var a = 2; + var b = [a **= 2]; + assert.equal(4, a); + assert.equal(1, b.length); + assert.equal(4, b[0]); + + assert.equal(64, f(a **= 3)); + assert.equal(64, a); +})(); diff --git a/packages/babel/test/fixtures/traceur/ForOf/NewNoParens.js b/packages/babel/test/fixtures/traceur/ForOf/NewNoParens.js new file mode 100644 index 0000000000..19e564ac08 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ForOf/NewNoParens.js @@ -0,0 +1,21 @@ +function C() {} +C.prototype[Symbol.iterator] = function() { + var n = 0; + return { + next() { + return {value: n++, done: n > 3}; + } + }; +}; + +var s = ''; +for (var x of new C()) { + s += x; +} +assert.equal(s, '012'); + +s = ''; +for (var x of new C) { + s += x; +} +assert.equal(s, '012'); diff --git a/packages/babel/test/fixtures/traceur/GeneratorComprehension/Error_Disabled.js b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Error_Disabled.js new file mode 100644 index 0000000000..e87ed8b891 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --generator-comprehension=false +// Error: :4:13: Unexpected reserved word for + +var iter = (for (x of [0, 1, 2, 3, 4]) x); diff --git a/packages/babel/test/fixtures/traceur/GeneratorComprehension/Error_NotDefined.js b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Error_NotDefined.js new file mode 100644 index 0000000000..66c7e28002 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Error_NotDefined.js @@ -0,0 +1,5 @@ +// Options: --generator-comprehension --free-variable-checker +// Error: :5:1: notDefined is not defined + +var iter = (for (notDefined of [0]) notDefined); +notDefined; diff --git a/packages/babel/test/fixtures/traceur/GeneratorComprehension/Simple.js b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Simple.js new file mode 100644 index 0000000000..ffeae46555 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Simple.js @@ -0,0 +1,40 @@ +// Options: --generator-comprehension + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +function* range() { + for (var i = 0; i < 5; i++) { + yield i; + } +} + +var iter = (for (x of [0, 1, 2, 3, 4]) x); +assert.equal('01234', accumulate(iter)); + +var iter2 = (for (x of [0, 1, 2, 3, 4]) for (y of [0, 1, 2, 3, 4]) x + '' + y ); +assert.equal('00010203041011121314202122232430313233344041424344', + accumulate(iter2)); + +var iter3 = ( + for (x of [0, 1, 2, 3, 4]) + for (y of range()) + if (x === y) + x + '' + y); +assert.equal('0011223344', accumulate(iter3)); + +// Ensure this works as expression statement +(for (testVar of []) testVar); + +var iter4 = ( + for (x of range()) + if (x % 2 === 0) + for (y of range()) + if (y % 2 === 1) + x + '' + y); +assert.equal('010321234143', accumulate(iter4)); diff --git a/packages/babel/test/fixtures/traceur/GeneratorComprehension/Skip_Closure.js b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Skip_Closure.js new file mode 100644 index 0000000000..5442161373 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/GeneratorComprehension/Skip_Closure.js @@ -0,0 +1,23 @@ +// Options: --generator-comprehension +// Skip. The sugaring uses var instead of let which leads to wrong closure. + +var iter = (for (x of [0, 1]) for (y of [2, 3]) () => [x, y] ); + +assert.isTrue(iter.moveNext()); +var f1 = iter.current; + +assert.isTrue(iter.moveNext()); +var f2 = iter.current; + +assert.isTrue(iter.moveNext()); +var f3 = iter.current; + +assert.isTrue(iter.moveNext()); +var f4 = iter.current; + +assert.isFalse(iter.moveNext()); + +assertArrayEquals([0, 2], f1()); +assertArrayEquals([0, 3], f2()); +assertArrayEquals([1, 2], f3()); +assertArrayEquals([1, 3], f4()); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/LICENSE b/packages/babel/test/fixtures/traceur/LICENSE new file mode 100644 index 0000000000..6d00d2ecac --- /dev/null +++ b/packages/babel/test/fixtures/traceur/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2011 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/packages/babel/test/fixtures/traceur/Math/acosh.module.js b/packages/babel/test/fixtures/traceur/Math/acosh.module.js new file mode 100644 index 0000000000..716e3c02bc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/acosh.module.js @@ -0,0 +1,8 @@ +import {acosh} from '../../../src/runtime/polyfills/Math.js'; + +function testAcosh(acosh) { + assert.equal(0, acosh(1)); +} + +testAcosh(acosh); +testAcosh(Math.acosh); diff --git a/packages/babel/test/fixtures/traceur/Math/asinh.module.js b/packages/babel/test/fixtures/traceur/Math/asinh.module.js new file mode 100644 index 0000000000..2590ef121d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/asinh.module.js @@ -0,0 +1,8 @@ +import {asinh} from '../../../src/runtime/polyfills/Math.js'; + +function testAsinh(asinh) { + assert.equal(0, asinh(0)); +} + +testAsinh(asinh); +testAsinh(Math.asinh); diff --git a/packages/babel/test/fixtures/traceur/Math/atanh.module.js b/packages/babel/test/fixtures/traceur/Math/atanh.module.js new file mode 100644 index 0000000000..0a96869e6b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/atanh.module.js @@ -0,0 +1,8 @@ +import {atanh} from '../../../src/runtime/polyfills/Math.js'; + +function testAtanh(atanh) { + assert.equal(0, atanh(0)); +} + +testAtanh(atanh); +testAtanh(Math.atanh); diff --git a/packages/babel/test/fixtures/traceur/Math/cbrt.module.js b/packages/babel/test/fixtures/traceur/Math/cbrt.module.js new file mode 100644 index 0000000000..726ff94e2a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/cbrt.module.js @@ -0,0 +1,8 @@ +import {cbrt} from '../../../src/runtime/polyfills/Math.js'; + +function testCbrt(cbrt) { + assert.equal(0, cbrt(0)); +} + +testCbrt(cbrt); +testCbrt(Math.cbrt); diff --git a/packages/babel/test/fixtures/traceur/Math/clz32.module.js b/packages/babel/test/fixtures/traceur/Math/clz32.module.js new file mode 100644 index 0000000000..2d21aaeaa9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/clz32.module.js @@ -0,0 +1,9 @@ +import {clz32} from '../../../src/runtime/polyfills/Math.js'; + +function testClz32(clz32) { + [NaN, Infinity, -Infinity, 0, -0, 'abc', 'Infinity', '-Infinity', {}].forEach( + (x) => assert.equal(32, clz32(x))); +} + +testClz32(clz32); +testClz32(Math.clz32); diff --git a/packages/babel/test/fixtures/traceur/Math/cosh.module.js b/packages/babel/test/fixtures/traceur/Math/cosh.module.js new file mode 100644 index 0000000000..c61ab85d06 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/cosh.module.js @@ -0,0 +1,11 @@ +import {cosh} from '../../../src/runtime/polyfills/Math.js'; + +function testCosh(cosh) { + assert.equal(Infinity, cosh(-Infinity)); + assert.equal(Infinity, cosh(Infinity)); + assert.equal(1, cosh(0)); + assert.equal(1, cosh(-0)); +} + +testCosh(cosh); +testCosh(Math.cosh); diff --git a/packages/babel/test/fixtures/traceur/Math/expm1.module.js b/packages/babel/test/fixtures/traceur/Math/expm1.module.js new file mode 100644 index 0000000000..0bbeb63d26 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/expm1.module.js @@ -0,0 +1,9 @@ +import {expm1} from '../../../src/runtime/polyfills/Math.js'; + +function testExpm1(expm1) { + assert.equal(Infinity, expm1(Infinity)); + assert.equal(-1, expm1(-Infinity)); +} + +testExpm1(expm1); +testExpm1(Math.expm1); diff --git a/packages/babel/test/fixtures/traceur/Math/fround.module.js b/packages/babel/test/fixtures/traceur/Math/fround.module.js new file mode 100644 index 0000000000..65fe328483 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/fround.module.js @@ -0,0 +1,22 @@ +import {fround} from '../../../src/runtime/polyfills/Math.js'; +import {fround as jsFround} from '../../../src/runtime/polyfills/fround.js'; + +function testFround(x, expected) { + assert.strictEqual(expected, Math.fround(x)); + assert.strictEqual(expected, fround(x)); + assert.strictEqual(expected, jsFround(x)); +} + +testFround(0, 0); +testFround(-0, -0); +testFround(Infinity, Infinity); +testFround(-Infinity, -Infinity); + +assert.isTrue(isNaN(Math.fround(NaN))); +assert.isTrue(isNaN(fround(NaN))); +assert.isTrue(isNaN(jsFround(NaN))); + +testFround(1, 1); +testFround(1.5, 1.5); +testFround(1.6, 1.600000023841858); +testFround(1.337, 1.3370000123977661); diff --git a/packages/babel/test/fixtures/traceur/Math/hypot.module.js b/packages/babel/test/fixtures/traceur/Math/hypot.module.js new file mode 100644 index 0000000000..097e5b5318 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/hypot.module.js @@ -0,0 +1,9 @@ +import {hypot} from '../../../src/runtime/polyfills/Math.js'; + +function testHypot(hypot) { + assert.equal(1, hypot(1)); + assert.equal(Math.PI, hypot(Math.PI)); +} + +testHypot(hypot); +testHypot(Math.hypot); diff --git a/packages/babel/test/fixtures/traceur/Math/imul.module.js b/packages/babel/test/fixtures/traceur/Math/imul.module.js new file mode 100644 index 0000000000..e67624dca2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/imul.module.js @@ -0,0 +1,8 @@ +import {imul} from '../../../src/runtime/polyfills/Math.js'; + +function testImul(imul) { + assert.equal(8, imul(2, 4)); +} + +testImul(imul); +testImul(Math.imul); diff --git a/packages/babel/test/fixtures/traceur/Math/log10.module.js b/packages/babel/test/fixtures/traceur/Math/log10.module.js new file mode 100644 index 0000000000..64cae99669 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/log10.module.js @@ -0,0 +1,9 @@ +import {log10} from '../../../src/runtime/polyfills/Math.js'; + +function testLog10(log10) { + assert.equal(1, log10(10)); + assert.equal(2, log10(100)); +} + +testLog10(log10); +testLog10(Math.log10); diff --git a/packages/babel/test/fixtures/traceur/Math/log1p.module.js b/packages/babel/test/fixtures/traceur/Math/log1p.module.js new file mode 100644 index 0000000000..2fd94cbf2f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/log1p.module.js @@ -0,0 +1,8 @@ +import {log1p} from '../../../src/runtime/polyfills/Math.js'; + +function testLog1p(log1p) { + assert.equal(0, log1p(0)); +} + +// testLog1p(log1p); +testLog1p(Math.log1p); diff --git a/packages/babel/test/fixtures/traceur/Math/log2.module.js b/packages/babel/test/fixtures/traceur/Math/log2.module.js new file mode 100644 index 0000000000..fc5935d091 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/log2.module.js @@ -0,0 +1,9 @@ +import {log2} from '../../../src/runtime/polyfills/Math.js'; + +function testLog2(log2) { + assert.equal(1, log2(2)); + assert.equal(2, log2(4)); +} + +testLog2(log2); +testLog2(Math.log2); diff --git a/packages/babel/test/fixtures/traceur/Math/sign.module.js b/packages/babel/test/fixtures/traceur/Math/sign.module.js new file mode 100644 index 0000000000..35c816a583 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/sign.module.js @@ -0,0 +1,11 @@ +import {sign} from '../../../src/runtime/polyfills/Math.js'; + +function testSign(sign) { + assert.equal(1, sign(1)); + assert.equal(-1, sign(-1)); + assert.equal(0, sign(0)); + assert.equal(-0, sign(-0)); +} + +testSign(sign); +testSign(Math.sign); diff --git a/packages/babel/test/fixtures/traceur/Math/sinh.module.js b/packages/babel/test/fixtures/traceur/Math/sinh.module.js new file mode 100644 index 0000000000..c09335be35 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/sinh.module.js @@ -0,0 +1,11 @@ +import {sinh} from '../../../src/runtime/polyfills/Math.js'; + +function testSinh(sinh) { + assert.equal(0, sinh(0)); + assert.equal(-0, sinh(-0)); + assert.equal(Infinity, sinh(Infinity)); + assert.equal(-Infinity, sinh(-Infinity)); +} + +testSinh(sinh); +testSinh(Math.sinh); diff --git a/packages/babel/test/fixtures/traceur/Math/tanh.module.js b/packages/babel/test/fixtures/traceur/Math/tanh.module.js new file mode 100644 index 0000000000..056ce2fa32 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/tanh.module.js @@ -0,0 +1,11 @@ +import {tanh} from '../../../src/runtime/polyfills/Math.js'; + +function testTanh(tanh) { + assert.equal(0, tanh(0)); + assert.equal(-0, tanh(-0)); + assert.equal(1, tanh(Infinity)); + assert.equal(-1, tanh(-Infinity)); +} + +testTanh(tanh); +testTanh(Math.tanh); diff --git a/packages/babel/test/fixtures/traceur/Math/trunc.module.js b/packages/babel/test/fixtures/traceur/Math/trunc.module.js new file mode 100644 index 0000000000..c9841d70ef --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Math/trunc.module.js @@ -0,0 +1,14 @@ +import {trunc} from '../../../src/runtime/polyfills/Math.js'; + +function testTrunc(trunc) { + assert.equal(0, trunc(0)); + assert.equal(-0, trunc(-0)); + assert.equal(Infinity, trunc(Infinity)); + assert.equal(-Infinity, trunc(-Infinity)); + assert.equal(42, trunc(42)); + assert.equal(2, trunc(2.5)); + assert.equal(-2, trunc(-2.5)); +} + +testTrunc(trunc); +testTrunc(Math.trunc); diff --git a/packages/babel/test/fixtures/traceur/Modules/EmptyNamedImport.module.js b/packages/babel/test/fixtures/traceur/Modules/EmptyNamedImport.module.js new file mode 100644 index 0000000000..866efd0a87 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/EmptyNamedImport.module.js @@ -0,0 +1 @@ +import {} from './resources/m.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_DuplicateImport.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_DuplicateImport.module.js new file mode 100644 index 0000000000..1b8242c196 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_DuplicateImport.module.js @@ -0,0 +1,10 @@ +// Error: test/feature/Modules/Error_DuplicateImport.module.js:6:9: 'a' was previously imported at test/feature/Modules/Error_DuplicateImport.module.js:5:9 +// Error: test/feature/Modules/Error_DuplicateImport.module.js:9:8: 'd' was previously imported at test/feature/Modules/Error_DuplicateImport.module.js:8:8 +// Error: test/feature/Modules/Error_DuplicateImport.module.js:10:9: 'd' was previously imported at test/feature/Modules/Error_DuplicateImport.module.js:8:8 + +import {a} from './resources/a.js'; +import {c as a} from './resources/c.js'; + +import d from './resources/default-class.js'; +import d from './resources/default-name.js'; +import {a as d} from './resources/a2.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_ExportKeyword.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_ExportKeyword.module.js new file mode 100644 index 0000000000..be6eb05625 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_ExportKeyword.module.js @@ -0,0 +1,3 @@ +// Error: :3:9: Unexpected token if + +export {if}; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_ExportKeyword2.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_ExportKeyword2.module.js new file mode 100644 index 0000000000..ac5e6de748 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_ExportKeyword2.module.js @@ -0,0 +1,3 @@ +// Error: :3:9: Unexpected token if + +export {if as x}; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_ExportStarConflict.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_ExportStarConflict.module.js new file mode 100644 index 0000000000..da408f30cb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_ExportStarConflict.module.js @@ -0,0 +1,3 @@ +// Error: test/feature/Modules/resources/export-conflict.js:2:8: Duplicate export. 'a' was previously exported at test/feature/Modules/resources/export-conflict.js:1:12 + +import {a} from './resources/export-conflict.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_ExportStarDuplicateExport.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_ExportStarDuplicateExport.module.js new file mode 100644 index 0000000000..2e9c0cea53 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_ExportStarDuplicateExport.module.js @@ -0,0 +1,6 @@ +// Error: test/feature/Modules/Error_ExportStarDuplicateExport.module.js:4:8: Duplicate export. 'a' was previously exported at test/feature/Modules/Error_ExportStarDuplicateExport.module.js:3:8 + +export * from './resources/a.js'; +export * from './resources/a2.js'; + +assert.equal(1, 2); diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_ImportDefault.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_ImportDefault.module.js new file mode 100644 index 0000000000..45f14c2c5a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_ImportDefault.module.js @@ -0,0 +1,3 @@ +// Error: test/feature/Modules/Error_ImportDefault.module.js:3:8: 'default' is not exported by 'test/feature/Modules/resources/a.js' + +import error from './resources/a.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_ImportStar.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_ImportStar.module.js new file mode 100644 index 0000000000..e13fb713fe --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_ImportStar.module.js @@ -0,0 +1,4 @@ +// Error: :3:10: Unexpected token from + +import * from './resources/m.js'; +assert.equal(3, a + b); diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport.module.js new file mode 100644 index 0000000000..85fa2002dc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport.module.js @@ -0,0 +1,3 @@ +// Error: :3:9: 'c' is not exported by 'test/feature/Modules/resources/a.js' + +export {c} from './resources/a.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport2.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport2.module.js new file mode 100644 index 0000000000..25554def04 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport2.module.js @@ -0,0 +1,3 @@ +// Error: :3:9: 'c' is not exported by 'test/feature/Modules/resources/a.js' + +export {c as d} from './resources/a.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport3.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport3.module.js new file mode 100644 index 0000000000..0617075628 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidExport3.module.js @@ -0,0 +1,3 @@ +// Error: test/feature/Modules/Error_InvalidExport3.module.js:3:9: 'c' is not exported by 'test/feature/Modules/resources/b.js' + +export {c as d} from './resources/b.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_InvalidModuleDeclaration.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidModuleDeclaration.module.js new file mode 100644 index 0000000000..d44ede0b29 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidModuleDeclaration.module.js @@ -0,0 +1,7 @@ +// Error: 'test/feature/Modules/resources/no_such_file.js' +// Error: Specified as ./resources/no_such_file.js. +// Error: Imported by test/feature/Modules/Error_InvalidModuleDeclaration.module.js. +// Error: Normalizes to test/feature/Modules/resources/no_such_file.js +// Error: locate resolved against base + +import * as b from './resources/no_such_file.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_InvalidModuleDeclaration2.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidModuleDeclaration2.module.js new file mode 100644 index 0000000000..7702371f2d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_InvalidModuleDeclaration2.module.js @@ -0,0 +1,3 @@ +// Error: 3:38: Unexpected token . + +import * as b from './resources/a.js'.c; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Modules/Error_MissingExport.module.js b/packages/babel/test/fixtures/traceur/Modules/Error_MissingExport.module.js new file mode 100644 index 0000000000..9328df7011 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Error_MissingExport.module.js @@ -0,0 +1,7 @@ +// Error: :5:12: 'y' is not exported by 'test/feature/Modules/resources/x.js' +// Error: :5:15: 'z' is not exported by 'test/feature/Modules/resources/x.js' +// Error: :6:9: 'w' is not exported by 'test/feature/Modules/resources/x.js' + +import {x, y, z} from './resources/x.js'; +import {w} from './resources/x.js'; + diff --git a/packages/babel/test/fixtures/traceur/Modules/ExportDestructuring.module.js b/packages/babel/test/fixtures/traceur/Modules/ExportDestructuring.module.js new file mode 100644 index 0000000000..414a577f1d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ExportDestructuring.module.js @@ -0,0 +1,4 @@ +import {x, y} from './resources/export-destructuring.js'; + +assert.equal(x, 1); +assert.equal(y, 2); diff --git a/packages/babel/test/fixtures/traceur/Modules/ExportForwardDefault.module.js b/packages/babel/test/fixtures/traceur/Modules/ExportForwardDefault.module.js new file mode 100644 index 0000000000..eaaf689394 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ExportForwardDefault.module.js @@ -0,0 +1,7 @@ +// Options: --export-from-extended + +import {a, b, default as C} from './resources/export-forward-default-as.js'; + +assert.equal(42, a); +assert.equal(123, b()); +assert.equal('m', new C().m()); diff --git a/packages/babel/test/fixtures/traceur/Modules/ExportStar.module.js b/packages/babel/test/fixtures/traceur/Modules/ExportStar.module.js new file mode 100644 index 0000000000..72ddf57887 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ExportStar.module.js @@ -0,0 +1,7 @@ +import * as o from './resources/o.js'; + +assert.equal(1, o.a); +assert.equal(2, o.b); +assert.equal(3, o.c); +assert.equal(4, o.d); +assert.equal(undefined, o.default); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Modules/ExportStarAs.module.js b/packages/babel/test/fixtures/traceur/Modules/ExportStarAs.module.js new file mode 100644 index 0000000000..9fc38c8ead --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ExportStarAs.module.js @@ -0,0 +1,6 @@ +import {a, b} from './resources/export-star-as.js'; + +assert.equal(1, a.a); +assert.equal(2, a.b); +assert.equal(3, b.c); +assert.equal(4, b.d); diff --git a/packages/babel/test/fixtures/traceur/Modules/Exports.module.js b/packages/babel/test/fixtures/traceur/Modules/Exports.module.js new file mode 100644 index 0000000000..10a4d9a5d0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/Exports.module.js @@ -0,0 +1,17 @@ +import * as a from './resources/i.js'; + +(function() { + 'use strict'; + assert.equal(0, a.i); + a.inc(); + assert.equal(1, a.i); + + assert.throws(function() { + a.i = 2; + }, TypeError); +})(); + +assert.equal(1, a.i); + +import * as d from './resources/d.js'; +assert.equal('A', d.a); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportAsExportAs.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportAsExportAs.module.js new file mode 100644 index 0000000000..148782a5d0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportAsExportAs.module.js @@ -0,0 +1,2 @@ +import * as m from './resources/m3.js'; +assert.equal(m.x, 'z'); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportBasic.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportBasic.module.js new file mode 100644 index 0000000000..b30516766c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportBasic.module.js @@ -0,0 +1,3 @@ +import {p} from './resources/p.js'; +assert.equal('P', p); +assert(typeof q === 'undefined'); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportCircular.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportCircular.module.js new file mode 100644 index 0000000000..200b0d798a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportCircular.module.js @@ -0,0 +1,6 @@ +// Error: Unsupported circular dependency between test/feature/Modules/ImportCircular.module.js and test/feature/Modules/resources/clockwise.js + +import {clockwise} from './resources/clockwise.js'; +export function counterclockwise() { + return clockwise(); +} diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportDefault.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportDefault.module.js new file mode 100644 index 0000000000..2dfc7591cb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportDefault.module.js @@ -0,0 +1,17 @@ +import x from './resources/default.js'; +assert.equal(x, 42); + +import C from './resources/default-class.js'; +assert.equal(new C().m(), 'm'); + +import {default as D} from './resources/default-name.js'; +assert.equal(D, 4); + +import f from './resources/default-function.js'; +assert.equal(f(), 123); + +import E from './resources/default-class-expression.js'; +assert.equal(new E().n(), 'n'); + +import g from './resources/default-function-expression.js'; +assert.equal(g(), 456); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportEmptyImportClause.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportEmptyImportClause.module.js new file mode 100644 index 0000000000..865e5c437e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportEmptyImportClause.module.js @@ -0,0 +1,4 @@ +this.sideEffect = 1; +import {} from './resources/side-effect2.js'; +assert.equal(2, this.sideEffect); +this.sideEffect = 1; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportFromModule.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportFromModule.module.js new file mode 100644 index 0000000000..99ac97a287 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportFromModule.module.js @@ -0,0 +1,17 @@ +import {a as renamedX, b} from './resources/m.js'; +import {a} from './resources/m.js'; +import * as m2 from './resources/m.js'; + +assert.equal(1, a); +assert.equal(1, renamedX); +assert.equal(2, b); + +import * as m from './resources/m.js'; + +assert.equal(a, renamedX); +assert.equal(a, m.a); + +import * as m3 from './resources/m.js'; + +assert.isTrue(m === m3); +assert.equal(b, m.b); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportNoImportClause.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportNoImportClause.module.js new file mode 100644 index 0000000000..e83308df8d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportNoImportClause.module.js @@ -0,0 +1,4 @@ +this.sideEffect = 1; +import './resources/side-effect.js'; +assert.equal(2, this.sideEffect); +this.sideEffect = 1; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportPair.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportPair.module.js new file mode 100644 index 0000000000..a02f1039d0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportPair.module.js @@ -0,0 +1,10 @@ +import def, * as m from './resources/default-and-named.js'; +import def2, {x} from './resources/default-and-named.js'; +import def3, {x as y} from './resources/default-and-named.js'; + +assert.equal(def, 'default'); +assert.equal(def2, 'default'); +assert.equal(def3, 'default'); + +assert.equal(x, 'x'); +assert.equal(y, 'x'); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportReExportDefault.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportReExportDefault.module.js new file mode 100644 index 0000000000..383f8241c6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportReExportDefault.module.js @@ -0,0 +1,2 @@ +import x from './resources/re-export-default.js'; +assert.equal(x, 42); diff --git a/packages/babel/test/fixtures/traceur/Modules/ImportReExportDefaultAs.module.js b/packages/babel/test/fixtures/traceur/Modules/ImportReExportDefaultAs.module.js new file mode 100644 index 0000000000..75071473a5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ImportReExportDefaultAs.module.js @@ -0,0 +1,2 @@ +import {x} from './resources/re-export-default-as.js'; +assert.equal(x, 42); diff --git a/packages/babel/test/fixtures/traceur/Modules/ModuleDefault.module.js b/packages/babel/test/fixtures/traceur/Modules/ModuleDefault.module.js new file mode 100644 index 0000000000..e2fe225850 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ModuleDefault.module.js @@ -0,0 +1,3 @@ +import * as m from './resources/default.js'; + +assert.equal(m.default, 42); diff --git a/packages/babel/test/fixtures/traceur/Modules/ModuleName.module.js b/packages/babel/test/fixtures/traceur/Modules/ModuleName.module.js new file mode 100644 index 0000000000..4ce1f52df8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ModuleName.module.js @@ -0,0 +1,3 @@ +var re = /([^\s']+?)(?=test(?:[\/\\])feature(?:[\/\\]))/g; + +assert.equal(__moduleName.replace(re, ''), 'test/feature/Modules/ModuleName.module.js'); diff --git a/packages/babel/test/fixtures/traceur/Modules/StaticMethod.module.js b/packages/babel/test/fixtures/traceur/Modules/StaticMethod.module.js new file mode 100644 index 0000000000..cc37654001 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/StaticMethod.module.js @@ -0,0 +1,2 @@ +import {TestClass} from './resources/TestClass.js'; +assert.equal(TestClass.method(), 42); diff --git a/packages/babel/test/fixtures/traceur/Modules/ThisInModules.module.js b/packages/babel/test/fixtures/traceur/Modules/ThisInModules.module.js new file mode 100644 index 0000000000..0056ac4272 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/ThisInModules.module.js @@ -0,0 +1,4 @@ +var global = this; + +import * as m from './resources/f.js'; +assert.equal(global, m.f()); diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/TestClass.js b/packages/babel/test/fixtures/traceur/Modules/resources/TestClass.js new file mode 100644 index 0000000000..723df2b773 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/TestClass.js @@ -0,0 +1,5 @@ +export class TestClass { + static method() { + return 42; + } +} diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/a.js b/packages/babel/test/fixtures/traceur/Modules/resources/a.js new file mode 100644 index 0000000000..d0ba61cbde --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/a.js @@ -0,0 +1 @@ +export var a = 'A'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/a2.js b/packages/babel/test/fixtures/traceur/Modules/resources/a2.js new file mode 100644 index 0000000000..da6520dad9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/a2.js @@ -0,0 +1 @@ +export var a = 'A2'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/b.js b/packages/babel/test/fixtures/traceur/Modules/resources/b.js new file mode 100644 index 0000000000..e7d0cc71ec --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/b.js @@ -0,0 +1 @@ +import * as c from './c.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/c.js b/packages/babel/test/fixtures/traceur/Modules/resources/c.js new file mode 100644 index 0000000000..fc55ed1488 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/c.js @@ -0,0 +1 @@ +export var c = 'C'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/clockwise.js b/packages/babel/test/fixtures/traceur/Modules/resources/clockwise.js new file mode 100644 index 0000000000..02e22761f8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/clockwise.js @@ -0,0 +1,4 @@ +import {counterclockwise} from '../ImportCircular.module.js'; +export function clockwise() { + return 'The circle is complete'; +} diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/d.js b/packages/babel/test/fixtures/traceur/Modules/resources/d.js new file mode 100644 index 0000000000..4a9ab8813e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/d.js @@ -0,0 +1 @@ +export * from './a.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default-and-named.js b/packages/babel/test/fixtures/traceur/Modules/resources/default-and-named.js new file mode 100644 index 0000000000..aa4a2a19e1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default-and-named.js @@ -0,0 +1,2 @@ +export default 'default'; +export var x = 'x'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default-class-expression.js b/packages/babel/test/fixtures/traceur/Modules/resources/default-class-expression.js new file mode 100644 index 0000000000..4dcbb96368 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default-class-expression.js @@ -0,0 +1,5 @@ +export default class { + n() { + return 'n'; + } +} diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default-class.js b/packages/babel/test/fixtures/traceur/Modules/resources/default-class.js new file mode 100644 index 0000000000..8c1e65c3be --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default-class.js @@ -0,0 +1,7 @@ +export default class C { + m() { + return 'm'; + } +} + +assert.instanceOf(C, Function); diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default-function-expression.js b/packages/babel/test/fixtures/traceur/Modules/resources/default-function-expression.js new file mode 100644 index 0000000000..442eb2ccac --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default-function-expression.js @@ -0,0 +1,3 @@ +export default function() { + return 456; +} diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default-function.js b/packages/babel/test/fixtures/traceur/Modules/resources/default-function.js new file mode 100644 index 0000000000..3522838092 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default-function.js @@ -0,0 +1,5 @@ +export default function f() { + return 123; +} + +assert.instanceOf(f, Function); diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default-name.js b/packages/babel/test/fixtures/traceur/Modules/resources/default-name.js new file mode 100644 index 0000000000..fc9ffb7a38 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default-name.js @@ -0,0 +1,2 @@ +var p = 4; +export {p as default}; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/default.js b/packages/babel/test/fixtures/traceur/Modules/resources/default.js new file mode 100644 index 0000000000..7a4e8a723a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/default.js @@ -0,0 +1 @@ +export default 42; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/export-conflict.js b/packages/babel/test/fixtures/traceur/Modules/resources/export-conflict.js new file mode 100644 index 0000000000..830463412f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/export-conflict.js @@ -0,0 +1,2 @@ +export var a = 'a'; +export * from './a.js'; // also exports a diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/export-destructuring.js b/packages/babel/test/fixtures/traceur/Modules/resources/export-destructuring.js new file mode 100644 index 0000000000..1c64065e9c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/export-destructuring.js @@ -0,0 +1 @@ +export var {x, y = 2} = {x: 1}; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/export-forward-default-as.js b/packages/babel/test/fixtures/traceur/Modules/resources/export-forward-default-as.js new file mode 100644 index 0000000000..3a9bce6634 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/export-forward-default-as.js @@ -0,0 +1,3 @@ +export a from './default.js'; +export b from './default-function.js'; +export default from './default-class.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/export-star-as.js b/packages/babel/test/fixtures/traceur/Modules/resources/export-star-as.js new file mode 100644 index 0000000000..0f92446363 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/export-star-as.js @@ -0,0 +1,2 @@ +export * as a from './m.js'; +export * as b from './n.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/f.js b/packages/babel/test/fixtures/traceur/Modules/resources/f.js new file mode 100644 index 0000000000..dff8ba2f28 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/f.js @@ -0,0 +1 @@ +export var f = () => this; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/i.js b/packages/babel/test/fixtures/traceur/Modules/resources/i.js new file mode 100644 index 0000000000..1096ab76ca --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/i.js @@ -0,0 +1,4 @@ +export var i = 0; +export function inc() { + i++; +} diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/m.js b/packages/babel/test/fixtures/traceur/Modules/resources/m.js new file mode 100644 index 0000000000..0b0c3304ff --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/m.js @@ -0,0 +1,2 @@ +export var a = 1; +export var b = 2; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/m2.js b/packages/babel/test/fixtures/traceur/Modules/resources/m2.js new file mode 100644 index 0000000000..4fce0644f6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/m2.js @@ -0,0 +1,2 @@ +var z = 'z'; +export {z as var}; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/m3.js b/packages/babel/test/fixtures/traceur/Modules/resources/m3.js new file mode 100644 index 0000000000..d0b61d8faf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/m3.js @@ -0,0 +1,2 @@ +import {var as x} from './m2.js'; +export {x}; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/n.js b/packages/babel/test/fixtures/traceur/Modules/resources/n.js new file mode 100644 index 0000000000..6e7457c073 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/n.js @@ -0,0 +1,3 @@ +export var c = 3; +export var d = 4; +export default 5; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/o.js b/packages/babel/test/fixtures/traceur/Modules/resources/o.js new file mode 100644 index 0000000000..e0a1758a6a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/o.js @@ -0,0 +1,2 @@ +export * from './m.js'; +export * from './n.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/p.js b/packages/babel/test/fixtures/traceur/Modules/resources/p.js new file mode 100644 index 0000000000..b85dc962a7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/p.js @@ -0,0 +1,2 @@ +export var p = 'P'; +export var q = 'Q'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/re-export-default-as.js b/packages/babel/test/fixtures/traceur/Modules/resources/re-export-default-as.js new file mode 100644 index 0000000000..d6ee20f83c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/re-export-default-as.js @@ -0,0 +1 @@ +export {default as x} from './default.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/re-export-default.js b/packages/babel/test/fixtures/traceur/Modules/resources/re-export-default.js new file mode 100644 index 0000000000..a2229f0904 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/re-export-default.js @@ -0,0 +1 @@ +export {default} from './default.js'; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/side-effect.js b/packages/babel/test/fixtures/traceur/Modules/resources/side-effect.js new file mode 100644 index 0000000000..cff3fea11b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/side-effect.js @@ -0,0 +1 @@ +this.sideEffect++; diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/side-effect2.js b/packages/babel/test/fixtures/traceur/Modules/resources/side-effect2.js new file mode 100644 index 0000000000..23cc5b9c39 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/side-effect2.js @@ -0,0 +1,3 @@ +this.sideEffect++; + + diff --git a/packages/babel/test/fixtures/traceur/Modules/resources/x.js b/packages/babel/test/fixtures/traceur/Modules/resources/x.js new file mode 100644 index 0000000000..7e0623ea76 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Modules/resources/x.js @@ -0,0 +1 @@ +export var x = 'X'; diff --git a/packages/babel/test/fixtures/traceur/Number/EPSILON.module.js b/packages/babel/test/fixtures/traceur/Number/EPSILON.module.js new file mode 100644 index 0000000000..8bb6716b37 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/EPSILON.module.js @@ -0,0 +1,10 @@ +import {EPSILON} from '../../../src/runtime/polyfills/Number.js'; + +function testEpsilon(epsilon) { + assert.equal(epsilon, Math.pow(2, -52)); + assert.equal(1 + epsilon - 1, epsilon); + assert.equal(1 + epsilon / 2 - 1, 0); +} + +testEpsilon(EPSILON); +testEpsilon(Number.EPSILON); diff --git a/packages/babel/test/fixtures/traceur/Number/MAX_SAFE_INTEGER.module.js b/packages/babel/test/fixtures/traceur/Number/MAX_SAFE_INTEGER.module.js new file mode 100644 index 0000000000..44f20fb78b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/MAX_SAFE_INTEGER.module.js @@ -0,0 +1,4 @@ +import {MAX_SAFE_INTEGER} from '../../../src/runtime/polyfills/Number.js'; + +assert.equal(MAX_SAFE_INTEGER, Math.pow(2, 53) - 1); +assert.equal(Number.MAX_SAFE_INTEGER, Math.pow(2, 53) - 1); diff --git a/packages/babel/test/fixtures/traceur/Number/MIN_SAFE_INTEGER.module.js b/packages/babel/test/fixtures/traceur/Number/MIN_SAFE_INTEGER.module.js new file mode 100644 index 0000000000..450d5b0b07 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/MIN_SAFE_INTEGER.module.js @@ -0,0 +1,4 @@ +import {MIN_SAFE_INTEGER} from '../../../src/runtime/polyfills/Number.js'; + +assert.equal(MIN_SAFE_INTEGER, -Math.pow(2, 53) + 1); +assert.equal(Number.MIN_SAFE_INTEGER, -Math.pow(2, 53) + 1); diff --git a/packages/babel/test/fixtures/traceur/Number/isFinite.module.js b/packages/babel/test/fixtures/traceur/Number/isFinite.module.js new file mode 100644 index 0000000000..51e5d5d66f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/isFinite.module.js @@ -0,0 +1,30 @@ +import {isFinite} from '../../../src/runtime/polyfills/Number.js'; + +function testIsFinite(isFinite) { + assert.isTrue(isFinite(-0)); + assert.isTrue(isFinite(0)); + assert.isTrue(isFinite(Number.EPSILON)); + assert.isTrue(isFinite(Number.MAX_SAFE_INTEGER + 23)); + assert.isTrue(isFinite(Number.MAX_VALUE)); + assert.isTrue(isFinite(Number.MIN_SAFE_INTEGER - 13)); + assert.isTrue(isFinite(Number.MIN_VALUE)); + + assert.isFalse(isFinite('-0')); + assert.isFalse(isFinite('0')); + assert.isFalse(isFinite('x')); + assert.isFalse(isFinite(-Infinity)); + assert.isFalse(isFinite(-NaN)); + assert.isFalse(isFinite(Infinity)); + assert.isFalse(isFinite(NaN)); + assert.isFalse(isFinite(Number.NEGATIVE_INFINITY)); + assert.isFalse(isFinite(Number.POSITIVE_INFINITY)); + assert.isFalse(isFinite(false)); + assert.isFalse(isFinite(new Number(1))); + assert.isFalse(isFinite(null)); + assert.isFalse(isFinite(true)); + assert.isFalse(isFinite(undefined)); + assert.isFalse(isFinite({valueOf() { return 1; }})); +} + +testIsFinite(isFinite); +testIsFinite(Number.isFinite); diff --git a/packages/babel/test/fixtures/traceur/Number/isInteger.module.js b/packages/babel/test/fixtures/traceur/Number/isInteger.module.js new file mode 100644 index 0000000000..73df049c1d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/isInteger.module.js @@ -0,0 +1,30 @@ +import {isInteger} from '../../../src/runtime/polyfills/Number.js'; + +function testIsInteger(isInteger) { + assert.isTrue(isInteger(-0)); + assert.isTrue(isInteger(0)); + assert.isTrue(isInteger(Number.MAX_SAFE_INTEGER + 23)); + assert.isTrue(isInteger(Number.MAX_VALUE)); + assert.isTrue(isInteger(Number.MIN_SAFE_INTEGER - 13)); + + assert.isFalse(isInteger('-0')); + assert.isFalse(isInteger('0')); + assert.isFalse(isInteger('x')); + assert.isFalse(isInteger(-Infinity)); + assert.isFalse(isInteger(-NaN)); + assert.isFalse(isInteger(Infinity)); + assert.isFalse(isInteger(NaN)); + assert.isFalse(isInteger(Number.EPSILON)); + assert.isFalse(isInteger(Number.MIN_VALUE)); + assert.isFalse(isInteger(Number.NEGATIVE_INFINITY)); + assert.isFalse(isInteger(Number.POSITIVE_INFINITY)); + assert.isFalse(isInteger(false)); + assert.isFalse(isInteger(new Number(1))); + assert.isFalse(isInteger(null)); + assert.isFalse(isInteger(true)); + assert.isFalse(isInteger(undefined)); + assert.isFalse(isInteger({valueOf() { return 1; }})); +} + +testIsInteger(isInteger); +testIsInteger(Number.isInteger); diff --git a/packages/babel/test/fixtures/traceur/Number/isNaN.module.js b/packages/babel/test/fixtures/traceur/Number/isNaN.module.js new file mode 100644 index 0000000000..037696594e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/isNaN.module.js @@ -0,0 +1,30 @@ +import {isNaN} from '../../../src/runtime/polyfills/Number.js'; + +function testIsNaN(isNaN) { + assert.isTrue(isNaN(NaN)); + assert.isTrue(isNaN(-NaN)); + + assert.isFalse(isNaN('-0')); + assert.isFalse(isNaN('0')); + assert.isFalse(isNaN('NaN')); + assert.isFalse(isNaN('x')); + assert.isFalse(isNaN(-0)); + assert.isFalse(isNaN(0)); + assert.isFalse(isNaN(Infinity)); + assert.isFalse(isNaN(Number.EPSILON)); + assert.isFalse(isNaN(Number.MAX_SAFE_INTEGER + 23)); + assert.isFalse(isNaN(Number.MAX_VALUE)); + assert.isFalse(isNaN(Number.MIN_SAFE_INTEGER - 13)); + assert.isFalse(isNaN(Number.MIN_VALUE)); + assert.isFalse(isNaN(Number.NEGATIVE_INFINITY)); + assert.isFalse(isNaN(Number.POSITIVE_INFINITY)); + assert.isFalse(isNaN(false)); + assert.isFalse(isNaN(new Number(NaN))); + assert.isFalse(isNaN(null)); + assert.isFalse(isNaN(true)); + assert.isFalse(isNaN(undefined)); + assert.isFalse(isNaN({valueOf() { return NaN; }})); +} + +testIsNaN(isNaN); +testIsNaN(Number.isNaN); diff --git a/packages/babel/test/fixtures/traceur/Number/isSafeInteger.module.js b/packages/babel/test/fixtures/traceur/Number/isSafeInteger.module.js new file mode 100644 index 0000000000..285ce2a8f2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Number/isSafeInteger.module.js @@ -0,0 +1,33 @@ +import {isSafeInteger} from '../../../src/runtime/polyfills/Number.js'; + +function testIsSafeInteger(isSafeInteger) { + assert.isTrue(isSafeInteger(-0)); + assert.isTrue(isSafeInteger(0)); + assert.isTrue(isSafeInteger(Number.MAX_SAFE_INTEGER - 23)); + assert.isTrue(isSafeInteger(Number.MAX_SAFE_INTEGER)); + assert.isTrue(isSafeInteger(Number.MIN_SAFE_INTEGER + 13)); + + assert.isFalse(isSafeInteger('-0')); + assert.isFalse(isSafeInteger('0')); + assert.isFalse(isSafeInteger('x')); + assert.isFalse(isSafeInteger(-Infinity)); + assert.isFalse(isSafeInteger(-NaN)); + assert.isFalse(isSafeInteger(Infinity)); + assert.isFalse(isSafeInteger(NaN)); + assert.isFalse(isSafeInteger(Number.EPSILON)); + assert.isFalse(isSafeInteger(Number.MAX_SAFE_INTEGER + 23)); + assert.isFalse(isSafeInteger(Number.MAX_VALUE)); + assert.isFalse(isSafeInteger(Number.MIN_SAFE_INTEGER - 13)); + assert.isFalse(isSafeInteger(Number.MIN_VALUE)); + assert.isFalse(isSafeInteger(Number.NEGATIVE_INFINITY)); + assert.isFalse(isSafeInteger(Number.POSITIVE_INFINITY)); + assert.isFalse(isSafeInteger(false)); + assert.isFalse(isSafeInteger(new Number(1))); + assert.isFalse(isSafeInteger(null)); + assert.isFalse(isSafeInteger(true)); + assert.isFalse(isSafeInteger(undefined)); + assert.isFalse(isSafeInteger({valueOf() { return 1; }})); +} + +testIsSafeInteger(isSafeInteger); +testIsSafeInteger(Number.isSafeInteger); diff --git a/packages/babel/test/fixtures/traceur/NumericLiteral/Error_Disabled.js b/packages/babel/test/fixtures/traceur/NumericLiteral/Error_Disabled.js new file mode 100644 index 0000000000..dd9ad409cd --- /dev/null +++ b/packages/babel/test/fixtures/traceur/NumericLiteral/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --numeric-literals=false +// Error: :4:2: Semi-colon expected + +0b11; diff --git a/packages/babel/test/fixtures/traceur/NumericLiteral/Error_NoBinaryDigits.js b/packages/babel/test/fixtures/traceur/NumericLiteral/Error_NoBinaryDigits.js new file mode 100644 index 0000000000..5736588322 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/NumericLiteral/Error_NoBinaryDigits.js @@ -0,0 +1,4 @@ +// Options: --numeric-literals +// Error: :4:1: Binary Integer Literal must contain at least one digit + +0b; diff --git a/packages/babel/test/fixtures/traceur/NumericLiteral/Error_NoOctalDigits.js b/packages/babel/test/fixtures/traceur/NumericLiteral/Error_NoOctalDigits.js new file mode 100644 index 0000000000..4f9b85264e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/NumericLiteral/Error_NoOctalDigits.js @@ -0,0 +1,4 @@ +// Options: --numeric-literals +// Error: :4:1: Octal Integer Literal must contain at least one digit + +0o; diff --git a/packages/babel/test/fixtures/traceur/NumericLiteral/Simple.js b/packages/babel/test/fixtures/traceur/NumericLiteral/Simple.js new file mode 100644 index 0000000000..651e03c5b5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/NumericLiteral/Simple.js @@ -0,0 +1,101 @@ +// Options: --numeric-literals + +(function() { + assert.equal(0, 0b0); + assert.equal(1, 0b1); + assert.equal(3, 0b11); + assert.equal(3, 0b011); + assert.equal(0, 0B0); + assert.equal(1, 0B1); + assert.equal(3, 0B11); + assert.equal(3, 0B011); + + assert.equal(0, 0o0); + assert.equal(1, 0o1); + assert.equal(7, 0o7); + assert.equal(8, 0o10); + assert.equal(8, 0o010); + assert.equal(63, 0o77); + assert.equal(0, 0O0); + assert.equal(1, 0O1); + assert.equal(7, 0O7); + assert.equal(8, 0O10); + assert.equal(8, 0O010); + assert.equal(63, 0O77); + + var o = { + 0b0: 0, + 0b1: 1, + 0b10: 2, + 0B11: 3, + 0B0100: 4 + }; + assertArrayEquals(['0', '1', '2', '3', '4'], Object.keys(o)); + + var o = { + 0o0: 0, + 0o1: 1, + 0o7: 7, + 0O10: 8, + 0O011: 9 + }; + assertArrayEquals(['0', '1', '7', '8', '9'], Object.keys(o)); + + var o = { + get 0b0() {}, + get 0b1() {}, + get 0b10() {}, + get 0B11() {}, + get 0B0100() {} + }; + assertArrayEquals(['0', '1', '2', '3', '4'], Object.keys(o)); + + var o = { + set 0o0(v) {}, + set 0o1(v) {}, + set 0o7(v) {}, + set 0O10(v) {}, + set 0O011(v) {} + }; + assertArrayEquals(['0', '1', '7', '8', '9'], Object.keys(o)); + + var o = { + 0b0() {}, + 0b1() {}, + 0b10() {}, + 0B11() {}, + 0B0100() {} + }; + assertArrayEquals(['0', '1', '2', '3', '4'], Object.keys(o)); + + class C { + 0b0() {} + get 0b1() {} + set 0b10(v) {} + static 0B11() {} + static get 0B100() {} + static set 0B101(v) {} + + 0o6() {} + get 0o7() {} + set 0o10(v) {} + static 0O11() {} + static get 0O12() {} + static set 0O13(v) {} + } + + assert.isTrue(C.prototype.hasOwnProperty('0')); + assert.isTrue(C.prototype.hasOwnProperty('1')); + assert.isTrue(C.prototype.hasOwnProperty('2')); + assert.isTrue(C.prototype.hasOwnProperty('6')); + assert.isTrue(C.prototype.hasOwnProperty('7')); + assert.isTrue(C.prototype.hasOwnProperty('8')); + + assert.isTrue(C.hasOwnProperty('3')); + assert.isTrue(C.hasOwnProperty('4')); + assert.isTrue(C.hasOwnProperty('5')); + assert.isTrue(C.hasOwnProperty('9')); + assert.isTrue(C.hasOwnProperty('10')); + assert.isTrue(C.hasOwnProperty('11')); + +})(); diff --git a/packages/babel/test/fixtures/traceur/ObjectAssign.js b/packages/babel/test/fixtures/traceur/ObjectAssign.js new file mode 100644 index 0000000000..05841a614c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectAssign.js @@ -0,0 +1,11 @@ +var target = {a: 0, b: 2}; +var source = {a: 1, c: 3, get d() { return this.b || this.a + 64; }}; +var assigned = Object.assign(target, source); + +// ---------------------------------------------------------------------------- + +assert.isTrue(Object.hasOwnProperty("assign")); +assert.equal(assigned.a, source.a); +assert.equal(assigned.b, target.b); +assert.equal(assigned.c, source.c); +assert.equal(assigned.d, source.d); diff --git a/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_Disabled.js b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_Disabled.js new file mode 100644 index 0000000000..069c869b11 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_Disabled.js @@ -0,0 +1,5 @@ +// Options: --property-name-shorthand=false +// Error: :5:16: Unexpected token x + +var x = 42; +var object = {x}; diff --git a/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_Keyword.js b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_Keyword.js new file mode 100644 index 0000000000..4d3f5644cb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_Keyword.js @@ -0,0 +1,3 @@ +// Error: :3:18: Unexpected token var + +var object = {var}; diff --git a/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_MissingVar.js b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_MissingVar.js new file mode 100644 index 0000000000..e7c4d29fe4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_MissingVar.js @@ -0,0 +1,3 @@ +// Error: missingVarObjectInitializerShorthand is not defined + +var object = {missingVarObjectInitializerShorthand}; diff --git a/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_StrictKeyword.js b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_StrictKeyword.js new file mode 100644 index 0000000000..666ffa7956 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Error_StrictKeyword.js @@ -0,0 +1,12 @@ +// Error: :6:11: implements is a reserved identifier +// Error: :11:11: yield is a reserved identifier + +function f() { + 'use strict'; + return {implements}; +} + +function g() { + 'use strict'; + return {yield}; +} diff --git a/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Ok.js b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Ok.js new file mode 100644 index 0000000000..591866b272 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/Ok.js @@ -0,0 +1,8 @@ +var x = 42; +var y = 43; +var object = {x, y}; + +// ---------------------------------------------------------------------------- + +assert.equal(42, object.x); +assert.equal(43, object.y); diff --git a/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/StrictKeyword.js b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/StrictKeyword.js new file mode 100644 index 0000000000..222aec7a88 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectInitializerShorthand/StrictKeyword.js @@ -0,0 +1,14 @@ +// This only tests the parsing. + +function f() { + return {implements}; +} + +function f2() { + return {yield}; +} + +function* g() { + 'use strict'; + return {yield}; +} diff --git a/packages/babel/test/fixtures/traceur/ObjectIs.js b/packages/babel/test/fixtures/traceur/ObjectIs.js new file mode 100644 index 0000000000..2f19b0edda --- /dev/null +++ b/packages/babel/test/fixtures/traceur/ObjectIs.js @@ -0,0 +1,34 @@ +assert.isTrue(Object.is(1, 1)); +assert.isTrue(Object.is(0, 0)); +assert.isTrue(Object.is(-0, -0)); +assert.isTrue(Object.is(NaN, NaN)); +assert.isTrue(Object.is(Infinity, Infinity)); +assert.isTrue(Object.is(-Infinity, -Infinity)); + +assert.isFalse(Object.is(0, -0)); +assert.isFalse(Object.is(-0, 0)); +assert.isFalse(Object.is(Infinity, -Infinity)); +assert.isFalse(Object.is(-Infinity, Infinity)); + +assert.isTrue(Object.is(true, true)); +assert.isTrue(Object.is(false, false)); + +assert.isTrue(Object.is(null, null)); +assert.isTrue(Object.is(undefined, undefined)); + +assert.isTrue(Object.is('', '')); +assert.isTrue(Object.is('a', 'a')); + +{ + var object = {}; + assert.isTrue(Object.is(object, object)); +} + +assert.isFalse(Object.is(new String('a'), new String('a'))); +assert.isFalse(Object.is(new Boolean, new Boolean)); +assert.isFalse(Object.is(new Number, new Number)); +assert.isFalse(Object.is(new Date(0), new Date(0))); +assert.isFalse(Object.is(/re/, /re/)); +assert.isFalse(Object.is({}, {})); +assert.isFalse(Object.is([], [])); +assert.isFalse(Object.is(function() {}, function() {})); diff --git a/packages/babel/test/fixtures/traceur/PrependStatement.js b/packages/babel/test/fixtures/traceur/PrependStatement.js new file mode 100644 index 0000000000..e50fa07ed4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PrependStatement.js @@ -0,0 +1,18 @@ +var count = 0; +var o = { + get x() { + count++; + return 1; + } +}; + +function f({x}) {} +f(o); +assert.equal(1, count); + +count = 0; +function g({x}) { + 'use strict'; +} +g(o); +assert.equal(1, count); diff --git a/packages/babel/test/fixtures/traceur/Promise.js b/packages/babel/test/fixtures/traceur/Promise.js new file mode 100644 index 0000000000..a5f7679209 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Promise.js @@ -0,0 +1,9 @@ +// Async. + +var p = new Promise((resolve, reject) => { + resolve(42); +}); +p.then((v) => { + assert.equal(v, 42); + done(); +}); diff --git a/packages/babel/test/fixtures/traceur/PromiseAll.js b/packages/babel/test/fixtures/traceur/PromiseAll.js new file mode 100644 index 0000000000..92067b82e2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PromiseAll.js @@ -0,0 +1,17 @@ +// Skip. +// Async. + +// V8 does not yet support iterable argument to Promise.all. +// https://code.google.com/p/v8/issues/detail?id=3705 + +function* gen() { + yield 1; + yield 2; +} + +var p2 = Promise.all(gen()); + +p2.then((v) => { + assert.deepEqual(v, [1,2]); + done(); +}); diff --git a/packages/babel/test/fixtures/traceur/PromiseResolve.js b/packages/babel/test/fixtures/traceur/PromiseResolve.js new file mode 100644 index 0000000000..69c9aadd3c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PromiseResolve.js @@ -0,0 +1,3 @@ +var p = Promise.resolve(42); + +assert.equal(p, Promise.resolve(p)); diff --git a/packages/babel/test/fixtures/traceur/PromiseThrowInResolve.js b/packages/babel/test/fixtures/traceur/PromiseThrowInResolve.js new file mode 100644 index 0000000000..e380f26948 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PromiseThrowInResolve.js @@ -0,0 +1,15 @@ +// Async. + +var message = 'testing'; +var throwInResolve = new Promise((resolve, reject) => { + resolve(42); +}); +throwInResolve.then((v) => { + throw new Error(message); +}).catch(function(ex) { + // When catch() is used in testing, these asserts would + // not be called, just the done() to avoid timeout. + assert(ex instanceof Error); + assert(ex.toString().indexOf(message) !== -1); + done(); +}).catch(done); diff --git a/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/Error_Disabled.js b/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/Error_Disabled.js new file mode 100644 index 0000000000..4badc9f2cf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/Error_Disabled.js @@ -0,0 +1,8 @@ +// Options: --property-methods=false +// Error: :5:9: Unexpected token ( + +var object = { + method() { + return 42; + } +}; diff --git a/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/Error_NotNamed.js b/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/Error_NotNamed.js new file mode 100644 index 0000000000..dbb08846de --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/Error_NotNamed.js @@ -0,0 +1,8 @@ +assert.throws(() => { + var object = { + "notNamedField"() { + return notNamedField; + } + }; + object.notNamedField(); +}, ReferenceError); diff --git a/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/PropertyMethodAssignment.js b/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/PropertyMethodAssignment.js new file mode 100644 index 0000000000..a913227b1b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PropertyMethodAssignment/PropertyMethodAssignment.js @@ -0,0 +1,71 @@ +var object = { + x: { + j() { + return this.j; + } + }, + f() { + return this.f; + }, + 'g'() {}, + "h"() {}, + 42() {}, + null() {}, + true() {}, + false() {}, + function() {}, + var() {}, + 'class'() {} // NodeJS incorrectly flags {class: ...} as an error. +}; + +// ---------------------------------------------------------------------------- + +assertArrayEquals([ + '42', + 'x', + 'f', + 'g', + 'h', + 'null', + 'true', + 'false', + 'function', + 'var', + 'class' +], Object.keys(object)); + +function assertMethod(object, name) { + assert.isTrue(object.hasOwnProperty(name)); + var descriptor = Object.getOwnPropertyDescriptor(object, name); + assert.equal('object', typeof descriptor); + assert.isTrue(descriptor.enumerable); + assert.equal('function', typeof object[name]); + // IE does not have a name property on functions. + assert.isTrue(object[name].name === '' || object[name].name === undefined); +} + +assertMethod(object, 'f'); +assertMethod(object, 'g'); +assertMethod(object, 'h'); +assertMethod(object, '42'); +assertMethod(object, 'null'); +assertMethod(object, 'true'); +assertMethod(object, 'false'); +assertMethod(object, 'function'); +assertMethod(object, 'var'); +assertMethod(object, 'class'); + +assert.equal(object.f, object.f()); + +// Test the nested object. +assertArrayEquals(['j'], Object.keys(object.x)); +assertMethod(object.x, 'j'); + +// Test name binding. +var m = 42; +class C { + m() { + return m; + } +} +assert.equal(42, new C().m()) diff --git a/packages/babel/test/fixtures/traceur/PureES6Transformer/Basic.js b/packages/babel/test/fixtures/traceur/PureES6Transformer/Basic.js new file mode 100644 index 0000000000..e7534d7b18 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/PureES6Transformer/Basic.js @@ -0,0 +1,3 @@ +// Options: --output-language=es6 +// Ironically enough we can't use es6 in this test as node can't eval it. +function foo() {} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/RegularExpression/Simple.js b/packages/babel/test/fixtures/traceur/RegularExpression/Simple.js new file mode 100644 index 0000000000..0e5a4ae451 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/RegularExpression/Simple.js @@ -0,0 +1,12 @@ +// Options: --unicode-expressions + +// Only test if the transformation worked or not. For everything else, defer +// to regexpu's test suite: +// https://github.com/mathiasbynens/regexpu/blob/master/tests/tests.js +(function() { + assert.equal(/a/u.source, 'a'); + assert.equal(/a.b/u.source, + 'a(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|' + + '[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF]' + + '(?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])b'); +})(); diff --git a/packages/babel/test/fixtures/traceur/Rest/Error_NotLast.js b/packages/babel/test/fixtures/traceur/Rest/Error_NotLast.js new file mode 100644 index 0000000000..e6ff97f3cf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Rest/Error_NotLast.js @@ -0,0 +1,6 @@ +// Error: :3:46: Unexpected token , + +function invalidParam(noDefault, ...restParam, noRestAgain) { + // Should fail to parse since non rest param is not allowed after + // param. +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Rest/Error_SetAccessor.js b/packages/babel/test/fixtures/traceur/Rest/Error_SetAccessor.js new file mode 100644 index 0000000000..754e2be8ea --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Rest/Error_SetAccessor.js @@ -0,0 +1,7 @@ +// Error: :4:9: Unexpected token ... + +var object = { + set x(...rest) { + // rest is not allowed for set accessor + } +}; diff --git a/packages/babel/test/fixtures/traceur/Rest/Simple.js b/packages/babel/test/fixtures/traceur/Rest/Simple.js new file mode 100644 index 0000000000..00350014e1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Rest/Simple.js @@ -0,0 +1,16 @@ +function f(...p) { + return p; +} + +function g(a, ...p) { + return p; +} + +assertArrayEquals([], f()); +assertArrayEquals([0], f(0)); +assertArrayEquals([0, 1], f(0, 1)); + +assertArrayEquals([], g()); +assertArrayEquals([], g(0)); +assertArrayEquals([1], g(0, 1)); +assertArrayEquals([1, 2], g(0, 1, 2)); diff --git a/packages/babel/test/fixtures/traceur/Rest/Strict.js b/packages/babel/test/fixtures/traceur/Rest/Strict.js new file mode 100644 index 0000000000..d69126240c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Rest/Strict.js @@ -0,0 +1,6 @@ +function f(...xs) { + 'use strict'; + return this; +} + +assert.isUndefined(f()); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding10.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding10.js new file mode 100644 index 0000000000..d7500efcfd --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding10.js @@ -0,0 +1,15 @@ +// Options: --block-binding + +function f() { + return 'outer'; +} + +{ + var f = function f() { + return 'inner'; + }; + + assert.equal('inner', f()); +} + +assert.equal('inner', f()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding11.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding11.js new file mode 100644 index 0000000000..07ac0a07f1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding11.js @@ -0,0 +1,18 @@ +// Options: --block-binding + +let result = []; +let obj = {a : 'hello a', b : 'hello b', c : 'hello c' }; +let keys = Object.keys(obj); + +// NOTE: Do not fix the deviation from Google JS coding style. This was done in +// order to check codegen for single statements in the body of 'for' loops. +for (let i = 0; i < keys.length; i++) + result.push( + function() { return obj[keys[i]]; } + ); + +// ---------------------------------------------------------------------------- + +assert.equal('hello a', result[0]()); +assert.equal('hello b', result[1]()); +assert.equal('hello c', result[2]()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding2.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding2.js new file mode 100644 index 0000000000..afb64e1664 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding2.js @@ -0,0 +1,15 @@ +// Options: --block-binding + +let result = []; +let obj = {a : 'hello a', b : 'hello b', c : 'hello c' }; +for (let x in obj) { + result.push( + function() { return obj[x]; } + ); +} + +// ---------------------------------------------------------------------------- + +assert.equal('hello a', result[0]()); +assert.equal('hello b', result[1]()); +assert.equal('hello c', result[2]()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding3.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding3.js new file mode 100644 index 0000000000..4d620100ca --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding3.js @@ -0,0 +1,17 @@ +// Options: --block-binding + +var f1, f2; + +{ + let z = 'z1 value'; + f1 = function() { return z; }; +} +{ + let z = 'z2 value'; + f2 = function() { return z; }; +} + +// ---------------------------------------------------------------------------- + +assert.equal('z1 value', f1()); +assert.equal('z2 value', f2()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding4.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding4.js new file mode 100644 index 0000000000..b22f6af158 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding4.js @@ -0,0 +1,14 @@ +// Options: --block-binding + +let result = []; +for (let a = 1; a < 3; a++) { + result.push( + function() { return 'for ' + a; } + ); +} + +// ---------------------------------------------------------------------------- + +assert.equal('for 1', result[0]()); +assert.equal('for 2', result[1]()); +assert.equal(2, result.length); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding5.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding5.js new file mode 100644 index 0000000000..92284dc856 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding5.js @@ -0,0 +1,18 @@ +// Options: --block-binding + +let result = []; +for (let i = 1; i < 3; i ++) { + for (let j = 9; j > 7; j --) { + result.push( + function() { return i + ':' + j; } + ); + } +} + +// ---------------------------------------------------------------------------- + +assert.equal('1:9', result[0]()); +assert.equal('1:8', result[1]()); +assert.equal('2:9', result[2]()); +assert.equal('2:8', result[3]()); +assert.equal(4, result.length); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding6.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding6.js new file mode 100644 index 0000000000..abaf0feb5d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding6.js @@ -0,0 +1,14 @@ +// Options: --block-binding + +function testBlock() { + // Test function expressions. + { + var x = function g() { return 'g'; } || function h() { return 'h'; }; + return x; + } +} + +// ---------------------------------------------------------------------------- + +var result = testBlock(); +assert.equal('g', result()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding7.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding7.js new file mode 100644 index 0000000000..b3fa8ddd15 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding7.js @@ -0,0 +1,15 @@ +// Options: --block-binding + +function blockTest() { + { + let x = 'let x value'; + function g() { + return x; + } + return g; + } +} + +// ---------------------------------------------------------------------------- + +assert.equal('let x value', blockTest()()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding8.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding8.js new file mode 100644 index 0000000000..ed1f6877b0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding8.js @@ -0,0 +1,15 @@ +// Options: --block-binding + +function f() { + return 'outer'; +} + +{ + function f() { + return 'inner'; + } + + assert.equal('inner', f()); +} + +assert.equal('outer', f()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBinding9.js b/packages/babel/test/fixtures/traceur/Scope/BlockBinding9.js new file mode 100644 index 0000000000..3a88b3b819 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBinding9.js @@ -0,0 +1,15 @@ +// Options: --block-binding + +function f() { + return 'outer'; +} + +{ + (function f() { + return 'inner'; + }); + + assert.equal('outer', f()); +} + +assert.equal('outer', f()); diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBindingHiddenOuterLet.js b/packages/babel/test/fixtures/traceur/Scope/BlockBindingHiddenOuterLet.js new file mode 100644 index 0000000000..eae0a1f4f9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBindingHiddenOuterLet.js @@ -0,0 +1,9 @@ +// Options: --block-binding + +// See issue #1671. Pass if no exception +let c; + +function f(c) { + var p; + for (p of g(() => c)); +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Scope/BlockBindingSiblingRefenceError.js b/packages/babel/test/fixtures/traceur/Scope/BlockBindingSiblingRefenceError.js new file mode 100644 index 0000000000..7db18e2948 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/BlockBindingSiblingRefenceError.js @@ -0,0 +1,6 @@ +assert.throws(() => { + { + let inner = 'inner value'; + } + var x = inner; +}, ReferenceError); diff --git a/packages/babel/test/fixtures/traceur/Scope/DeconstructingBlockBinding.js b/packages/babel/test/fixtures/traceur/Scope/DeconstructingBlockBinding.js new file mode 100644 index 0000000000..3f679a351d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/DeconstructingBlockBinding.js @@ -0,0 +1,12 @@ +// Options: --block-binding + +if (true) { + let [a,b] = [1,2]; + const [c,d] = [4,5]; +} +if (true) { + let {x: [{e}, f], g} = {x: [{e:4}, 5], g: 6}; + const a = 0, [b, {c, x: [d]}] = [1, {c: 2, x: [3]}]; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/DeepNestedLet.js b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLet.js new file mode 100644 index 0000000000..c7433749ca --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLet.js @@ -0,0 +1,12 @@ +// Options: --block-binding + +var a = 'var a'; +{ + var b = 'var b'; + { + var c = 'var c'; + let d = 'let d'; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetConst.js b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetConst.js new file mode 100644 index 0000000000..3bf59e93d6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetConst.js @@ -0,0 +1,14 @@ +// Options: --block-binding + +var a = 'var a'; +{ + var b = 'var b'; + { + let c = 'let c'; + { + const d = 'const d'; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetVar.js b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetVar.js new file mode 100644 index 0000000000..fb459cb060 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetVar.js @@ -0,0 +1,14 @@ +// Options: --block-binding + +var a = 'var a'; +{ + var b = 'var b'; + { + let c = 'let c'; + { + var d = 'var d'; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetVarNoInit.js b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetVarNoInit.js new file mode 100644 index 0000000000..e70b8eb3fc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/DeepNestedLetVarNoInit.js @@ -0,0 +1,14 @@ +// Options: --block-binding + +var var_a; +{ + var var_b; + { + let let_c = 'let c'; + { + var var_d; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ConstMissingInitializer.js b/packages/babel/test/fixtures/traceur/Scope/Error_ConstMissingInitializer.js new file mode 100644 index 0000000000..5f7c7ccc43 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ConstMissingInitializer.js @@ -0,0 +1,4 @@ +// Options: --block-binding +// Error: :4:14: const variables must have an initializer + +const x = 1, y; diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_Disabled.js b/packages/babel/test/fixtures/traceur/Scope/Error_Disabled.js new file mode 100644 index 0000000000..d5eeb41b6a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_Disabled.js @@ -0,0 +1,6 @@ +// Options: --block-binding=false +// Error: :5:3: Unexpected reserved word let + +{ + let x = 42; +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerConst.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerConst.js new file mode 100644 index 0000000000..751de8a5d5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerConst.js @@ -0,0 +1,5 @@ +// Options: --block-binding +// Error: :4:18: Unexpected token in + +for (const i = 0 in {}) { +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerLet.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerLet.js new file mode 100644 index 0000000000..9f5fb459e6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerLet.js @@ -0,0 +1,5 @@ +// Options: --block-binding +// Error: :4:16: Unexpected token in + +for (let i = 0 in {}) { +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerVar.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerVar.js new file mode 100644 index 0000000000..f154d2202e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForInWithInitializerVar.js @@ -0,0 +1,10 @@ +// Options: --block-binding +// Error: :7:22: Unexpected token in + +var x = 0; + +// ES6 does not allow this. +for (var i = (x = 1) in {}) { +} + +assert.equal(1, x); diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerConst.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerConst.js new file mode 100644 index 0000000000..d6498c8a36 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerConst.js @@ -0,0 +1,9 @@ +// Options: --block-binding +// Error: :8:18: Unexpected token of + +function* gen() { + yield 1; +} + +for (const i = 0 of gen()) { +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerLet.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerLet.js new file mode 100644 index 0000000000..b7578b9060 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerLet.js @@ -0,0 +1,9 @@ +// Options: --block-binding +// Error: :8:16: Unexpected token of + +function* gen() { + yield 1; +} + +for (let i = 0 of gen()) { +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerVar.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerVar.js new file mode 100644 index 0000000000..c41cf1aff9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForOfWithInitializerVar.js @@ -0,0 +1,9 @@ +// Options: --block-binding +// Error: :8:16: Unexpected token of + +function* gen() { + yield 1; +} + +for (var i = 0 of gen()) { +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_ForWithoutInitializerConst.js b/packages/babel/test/fixtures/traceur/Scope/Error_ForWithoutInitializerConst.js new file mode 100644 index 0000000000..afd9bce632 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_ForWithoutInitializerConst.js @@ -0,0 +1,7 @@ +// Options: --block-binding +// Error: :5:12: const variables must have an initializer + +var i = 0; +for (const x; i < 3; i++) { + +} diff --git a/packages/babel/test/fixtures/traceur/Scope/Error_FunctionExpressionInBlock.js b/packages/babel/test/fixtures/traceur/Scope/Error_FunctionExpressionInBlock.js new file mode 100644 index 0000000000..58ca667d5c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Error_FunctionExpressionInBlock.js @@ -0,0 +1,10 @@ +// Options: --block-binding +// Error: functionExpression is not defined + +{ + (function functionExpression() { + return 'inner'; + }); + + functionExpression; // function expression doesn't add name to the scope. +} diff --git a/packages/babel/test/fixtures/traceur/Scope/ForInInitializers.js b/packages/babel/test/fixtures/traceur/Scope/ForInInitializers.js new file mode 100644 index 0000000000..39b9ef829f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/ForInInitializers.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +(function() { + var y; + for (var x in {a: 'A'}) { + assert.equal(x, 'a'); + y = x; + } + assert.equal(y, 'a'); +})(); diff --git a/packages/babel/test/fixtures/traceur/Scope/FunctionInBlock.js b/packages/babel/test/fixtures/traceur/Scope/FunctionInBlock.js new file mode 100644 index 0000000000..3112dc3d66 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/FunctionInBlock.js @@ -0,0 +1,14 @@ +(function() { + 'use strict'; + var x = 1; + { + function f() { + x = 2; + } + + if (false) {} + + f(); + } + assert.equal(2, x); +})(); diff --git a/packages/babel/test/fixtures/traceur/Scope/LetForInInitializers1.js b/packages/babel/test/fixtures/traceur/Scope/LetForInInitializers1.js new file mode 100644 index 0000000000..c4f02e7790 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetForInInitializers1.js @@ -0,0 +1,22 @@ +// Options: --block-binding + +var result; +{ + let let_result = []; + let let_array = ['one', 'two', 'three']; + for (var index in let_array) { + let let_index = index; + let let_value = let_array[let_index]; + let_result.push( + function() { + return [let_index, let_value]; + }); + } + result = let_result; +} + +// ---------------------------------------------------------------------------- + +assertArrayEquals(['0', 'one'], result[0]()); +assertArrayEquals(['1', 'two'], result[1]()); +assertArrayEquals(['2', 'three'], result[2]()); diff --git a/packages/babel/test/fixtures/traceur/Scope/LetForInitializers1.js b/packages/babel/test/fixtures/traceur/Scope/LetForInitializers1.js new file mode 100644 index 0000000000..19dbcfcab4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetForInitializers1.js @@ -0,0 +1,14 @@ +// Options: --block-binding + +var result; +{ + let let_x = 'let x'; + let let_l = []; + for (var var_x = 1, var_y = 2, var_z = 3; var_x < 10; var_x ++) { + let l_x = var_x, l_y = var_y, l_z = var_z; + let_l.push( function() { return [ l_x, l_y, l_z ]; } ); + } + result = let_l; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInClass.js b/packages/babel/test/fixtures/traceur/Scope/LetInClass.js new file mode 100644 index 0000000000..fa248e8257 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInClass.js @@ -0,0 +1,19 @@ +// Options: --block-binding + +class LetInClass { + get z() { + let let_z = 10; + return let_z; + } + + set z(v) { + let let_zv = v; + } + + distance() { + let dist = this.y - this.x; + return dist; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInClosure.js b/packages/babel/test/fixtures/traceur/Scope/LetInClosure.js new file mode 100644 index 0000000000..9d2e89dd76 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInClosure.js @@ -0,0 +1,25 @@ +// Options: --block-binding + +function letInClosure(n) { + var l = []; + for (var i = 0; i < n; i ++) { + let let_i = i; + if (i % 3 == 0) { + continue; + } + l.push(function() { + return let_i; + }); + } + return l; +} + +// ---------------------------------------------------------------------------- + +var result = letInClosure(10); +assert.equal(1, result[0]()); +assert.equal(2, result[1]()); +assert.equal(4, result[2]()); +assert.equal(5, result[3]()); +assert.equal(7, result[4]()); +assert.equal(8, result[5]()); diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInFor.js b/packages/babel/test/fixtures/traceur/Scope/LetInFor.js new file mode 100644 index 0000000000..c7347c3fea --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInFor.js @@ -0,0 +1,7 @@ +// Options: --block-binding + +for (var x = 0; x < 10; x ++) { + let y = 'let y'; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInForBreak.js b/packages/babel/test/fixtures/traceur/Scope/LetInForBreak.js new file mode 100644 index 0000000000..5ccde528d6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInForBreak.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +for (var x = 0; x < 10; x ++) { + let y = 'let y'; + if (x % 2 == 0) { + break; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInForBreakInner.js b/packages/babel/test/fixtures/traceur/Scope/LetInForBreakInner.js new file mode 100644 index 0000000000..b0374fecac --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInForBreakInner.js @@ -0,0 +1,12 @@ +// Options: --block-binding + +for (var x = 0; x < 10; x ++) { + for (var y = 0; y < 10; y ++) { + let z = 'let z'; + if (x == 7) { + break; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInForBreakNamed.js b/packages/babel/test/fixtures/traceur/Scope/LetInForBreakNamed.js new file mode 100644 index 0000000000..4b72973f4a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInForBreakNamed.js @@ -0,0 +1,13 @@ +// Options: --block-binding + +outer: +for (var x = 0; x < 10; x ++) { + for (var y = 0; y < 10; y ++) { + let z = 'let z'; + if (x == 7) { + break outer; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInForContinue.js b/packages/babel/test/fixtures/traceur/Scope/LetInForContinue.js new file mode 100644 index 0000000000..0d3e0318f7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInForContinue.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +for (var x = 0; x < 10; x ++) { + let y = 'let y'; + if (x % 2 == 0) { + continue; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInForContinueInner.js b/packages/babel/test/fixtures/traceur/Scope/LetInForContinueInner.js new file mode 100644 index 0000000000..7231db3399 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInForContinueInner.js @@ -0,0 +1,12 @@ +// Options: --block-binding + +for (var x = 0; x < 10; x ++) { + for (var y = 0; y < 10; y ++) { + let z = 'let z'; + if (x == 7) { + continue; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInForContinueNamed.js b/packages/babel/test/fixtures/traceur/Scope/LetInForContinueNamed.js new file mode 100644 index 0000000000..5907676016 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInForContinueNamed.js @@ -0,0 +1,13 @@ +// Options: --block-binding + +outer: +for (var x = 0; x < 10; x ++) { + for (var y = 0; y < 10; y ++) { + let z = 'let z'; + if (x == 7) { + continue outer; + } + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInGenerators.js b/packages/babel/test/fixtures/traceur/Scope/LetInGenerators.js new file mode 100644 index 0000000000..28ceea17ef --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInGenerators.js @@ -0,0 +1,15 @@ +function h(t) { + return t(); +} + +function* f() { + for (let i = 0; i < 3; ++i) { + yield h(() => i); + } +} + +var g = f(); +assert.deepEqual(g.next(), {value: 0, done: false}); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); + diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInProperties.js b/packages/babel/test/fixtures/traceur/Scope/LetInProperties.js new file mode 100644 index 0000000000..22c2378e9e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInProperties.js @@ -0,0 +1,19 @@ +// Options: --block-binding + +var object = { + get x() { + while (true) { + let let_x = 'let x'; + return let_x; + } + }, + + set x(v) { + do { + let let_v = v; + this.v = let_v; + } while (false); + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInWhileLoop.js b/packages/babel/test/fixtures/traceur/Scope/LetInWhileLoop.js new file mode 100644 index 0000000000..06bdaab3df --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInWhileLoop.js @@ -0,0 +1,5 @@ +while( true ) { + let foo = 1; + assert.equal(1, (() => foo)()); + break; +} diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor1.js b/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor1.js new file mode 100644 index 0000000000..dd3ac7cc70 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor1.js @@ -0,0 +1,7 @@ +// Options: --block-binding + +for (let x = 1; x < 10; x++) { + x; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor2.js b/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor2.js new file mode 100644 index 0000000000..46f0c97ad5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor2.js @@ -0,0 +1,8 @@ +// Options: --block-binding + +for (let x = 1, y = 2, z = 3; x < 10; x ++) { + y++; + z++; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor3.js b/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor3.js new file mode 100644 index 0000000000..ff742b3cdc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInitializerFor3.js @@ -0,0 +1,9 @@ +// Options: --block-binding + +for (let x = 1, y = x + 1; x < 10 && y != 0; x ++, y *= 2) { + if (y > 300) { + continue; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetInitializerForIn.js b/packages/babel/test/fixtures/traceur/Scope/LetInitializerForIn.js new file mode 100644 index 0000000000..8bab17d1a6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetInitializerForIn.js @@ -0,0 +1,9 @@ +// Options: --block-binding + +let sum = 0; +let a = [1,2,3]; +for (let x in a) { + sum = sum + a[x]; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetNoInitializer.js b/packages/babel/test/fixtures/traceur/Scope/LetNoInitializer.js new file mode 100644 index 0000000000..3018218fc8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetNoInitializer.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +var x = 1; +{ + let x; + assert.equal(undefined, x); + x = 2; + assert.equal(2, x); +} +assert.equal(1, x); diff --git a/packages/babel/test/fixtures/traceur/Scope/LetNoInitializerGlobal.js b/packages/babel/test/fixtures/traceur/Scope/LetNoInitializerGlobal.js new file mode 100644 index 0000000000..58426a151e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetNoInitializerGlobal.js @@ -0,0 +1,6 @@ +// Options: --block-binding + +let x2; +assert.equal(undefined, x2); +x2 = 2; +assert.equal(2, x2); diff --git a/packages/babel/test/fixtures/traceur/Scope/LetReinitializeInLoop.js b/packages/babel/test/fixtures/traceur/Scope/LetReinitializeInLoop.js new file mode 100644 index 0000000000..c16bd2326d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetReinitializeInLoop.js @@ -0,0 +1,9 @@ +(function() { + var i = 0; + while (i < 3) { + let x; + assert.equal(undefined, x); + x = i; + i++; + } +})(); diff --git a/packages/babel/test/fixtures/traceur/Scope/LetWithFor.js b/packages/babel/test/fixtures/traceur/Scope/LetWithFor.js new file mode 100644 index 0000000000..f6ac1982eb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetWithFor.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +for (var x = 0; x < 10; x++) { + let let_y = 'let y'; + for (var for_z = 0; for_z < 2; for_z ++) { + break; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetWithForIn.js b/packages/babel/test/fixtures/traceur/Scope/LetWithForIn.js new file mode 100644 index 0000000000..6b75ebf3b9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetWithForIn.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +for (var x in [1,2,3]) { + let let_y = x; + for (var for_in_z in [4,5,6]) { + continue; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetWithSwitch.js b/packages/babel/test/fixtures/traceur/Scope/LetWithSwitch.js new file mode 100644 index 0000000000..756d7ecba7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetWithSwitch.js @@ -0,0 +1,16 @@ +// Options: --block-binding + +for (var i = 0; i < 5; i ++) { + let let_x = 'let x'; + + switch (i) { + case 0: + break; + case 2: + break; + default: + break; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/LetWithSwitch2.js b/packages/babel/test/fixtures/traceur/Scope/LetWithSwitch2.js new file mode 100644 index 0000000000..ea92dbf7c8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/LetWithSwitch2.js @@ -0,0 +1,16 @@ +// Options: --block-binding + +for (var i = 0; i < 5; i ++) { + let let_x = 'let x'; + + switch (i) { + case 0: + continue; + case 2: + break; + default: + break; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/NameBindingInFunction.js b/packages/babel/test/fixtures/traceur/Scope/NameBindingInFunction.js new file mode 100644 index 0000000000..3bc7634018 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NameBindingInFunction.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +{ + function f() { + return f; + } + var g = f; + f = 42; + assert.equal(42, g()); +} diff --git a/packages/babel/test/fixtures/traceur/Scope/NestedForLoops.js b/packages/babel/test/fixtures/traceur/Scope/NestedForLoops.js new file mode 100644 index 0000000000..0b4f4a194a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NestedForLoops.js @@ -0,0 +1,40 @@ +// Options: --block-binding --for-of + +(function() { + var count = 0; + for (let x = 0; x < 1; x++) { + for (let x = 1; x < 2; x++) { + for (let x = 2; x < 3; x++) { + count++; + assert.equal(2, x); + } + } + } + assert.equal(1, count); +})(); + +(function() { + var count = 0; + for (let x in {0: 0}) { + for (let x in {1: 1}) { + for (let x in {2: 2}) { + count++; + assert.equal('2', x); + } + } + } + assert.equal(1, count); +})(); + +(function() { + var count = 0; + for (let x of [0]) { + for (let x of [1]) { + for (let x of [2]) { + count++; + assert.equal(2, x); + } + } + } + assert.equal(1, count); +})(); diff --git a/packages/babel/test/fixtures/traceur/Scope/NestedFunction1.js b/packages/babel/test/fixtures/traceur/Scope/NestedFunction1.js new file mode 100644 index 0000000000..297042dd57 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NestedFunction1.js @@ -0,0 +1,9 @@ +// Options: --block-binding + +function nestedFunction1() { + return function() { + let let_x = 'let x'; + } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/NestedFunction2.js b/packages/babel/test/fixtures/traceur/Scope/NestedFunction2.js new file mode 100644 index 0000000000..85238bc29e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NestedFunction2.js @@ -0,0 +1,10 @@ +// Options: --block-binding + +function nestedFunction2() { + let let_func = function() { + let let_x = 'let x'; + } + return let_func; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/NestedFunction3.js b/packages/babel/test/fixtures/traceur/Scope/NestedFunction3.js new file mode 100644 index 0000000000..3ffda64978 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NestedFunction3.js @@ -0,0 +1,8 @@ +// Options: --block-binding + +function nestedFunction3() { + let let_x = 'let x'; + function function_foo() { } +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/NestedLet.js b/packages/babel/test/fixtures/traceur/Scope/NestedLet.js new file mode 100644 index 0000000000..54b2e91afa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NestedLet.js @@ -0,0 +1,11 @@ +// Options: --block-binding + +var x = 'var'; +{ + let y = 'let 1'; +} +{ + let y = 'let 2'; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Scope/NestedLetConflict.js b/packages/babel/test/fixtures/traceur/Scope/NestedLetConflict.js new file mode 100644 index 0000000000..808a556509 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/NestedLetConflict.js @@ -0,0 +1,12 @@ +(function() { + var x = 1; + function f() { + assert.equal(x, 1); + { + let x = 2; + assert.equal(x, 2); + } + assert.equal(x, 1); + } + f(); +})(); diff --git a/packages/babel/test/fixtures/traceur/Scope/Regress1381.js b/packages/babel/test/fixtures/traceur/Scope/Regress1381.js new file mode 100644 index 0000000000..ab64e59a9b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/Regress1381.js @@ -0,0 +1,8 @@ +function test() { + let ret = true; + while (false) + for (let i = 0; i < 1; i++) + ret = () => i; + return ret +} +assert.isTrue(test()); diff --git a/packages/babel/test/fixtures/traceur/Scope/RenameFunctionBlock.js b/packages/babel/test/fixtures/traceur/Scope/RenameFunctionBlock.js new file mode 100644 index 0000000000..90e2035365 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/RenameFunctionBlock.js @@ -0,0 +1,11 @@ +// Options: --block-binding +// Issue #1773 +function when() { + function* where() { + var index = 0; + for (let x of Object) { + index++; + } + } + var x = 5; +} diff --git a/packages/babel/test/fixtures/traceur/Scope/SiblingScopes.js b/packages/babel/test/fixtures/traceur/Scope/SiblingScopes.js new file mode 100644 index 0000000000..c3e230e98c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/SiblingScopes.js @@ -0,0 +1,15 @@ +// Options: --free-variable-checker=false + +assert.throws(() => { + { + let testVariable = 1; + assert.equal(testVariable, 1); + } + + { + let testVariable = 2; + assert.equal(testVariable, 2); + } + + testVariable; +}, ReferenceError); diff --git a/packages/babel/test/fixtures/traceur/Scope/TopLevelLet.js b/packages/babel/test/fixtures/traceur/Scope/TopLevelLet.js new file mode 100644 index 0000000000..0f2db5940b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/TopLevelLet.js @@ -0,0 +1,7 @@ +// Options: --block-binding + +let x = 'let'; + +// ---------------------------------------------------------------------------- + +assert.equal(x, 'let'); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Scope/TopLevelLetConst.js b/packages/babel/test/fixtures/traceur/Scope/TopLevelLetConst.js new file mode 100644 index 0000000000..3b3adfbcfc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/TopLevelLetConst.js @@ -0,0 +1,9 @@ +// Options: --block-binding + +let x = 'let'; +const y = 'const'; + +// ---------------------------------------------------------------------------- + +assert.equal('let', x); +assert.equal('const', y); diff --git a/packages/babel/test/fixtures/traceur/Scope/TopLevelLetVar.js b/packages/babel/test/fixtures/traceur/Scope/TopLevelLetVar.js new file mode 100644 index 0000000000..a90a4d5397 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Scope/TopLevelLetVar.js @@ -0,0 +1,9 @@ +// Options: --block-binding + +let x = 'let'; +var y = 'var'; + +// ---------------------------------------------------------------------------- + +assert.equal('let', x); +assert.equal('var', y); diff --git a/packages/babel/test/fixtures/traceur/Spread/Array.js b/packages/babel/test/fixtures/traceur/Spread/Array.js new file mode 100644 index 0000000000..0819b914e1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/Array.js @@ -0,0 +1,14 @@ +var a = []; +var b = [0, ...a]; +var c = [...b, ...b]; +var d; +var e = [0, ...d = [1, 2], 3]; +var f = [0, ...[[1, 2], [3, 4]], 5]; + +// ---------------------------------------------------------------------------- + +assertArrayEquals([0], b); +assertArrayEquals([0, 0], c); +assertArrayEquals([1, 2], d); +assertArrayEquals([0, 1, 2, 3], e); +assertArrayEquals([0, [1, 2], [3, 4], 5], f); diff --git a/packages/babel/test/fixtures/traceur/Spread/Call.js b/packages/babel/test/fixtures/traceur/Spread/Call.js new file mode 100644 index 0000000000..2560165c93 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/Call.js @@ -0,0 +1,22 @@ +function* G() { + yield 'hi'; + yield 'there'; +} + +function f(...args) { + return args; +} + +var result = f(0, ...[1, 2], 3, ...G()); +assertArrayEquals([0, 1, 2, 3, 'hi', 'there'], result); + +result = f(...G()); +assertArrayEquals(['hi', 'there'], result); + +function g() { + 'use strict'; + assert.strictEqual(undefined, this); +} + +g(); +g(...[]); diff --git a/packages/babel/test/fixtures/traceur/Spread/CallWithUndefined.js b/packages/babel/test/fixtures/traceur/Spread/CallWithUndefined.js new file mode 100644 index 0000000000..1243fa0e79 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/CallWithUndefined.js @@ -0,0 +1,8 @@ +function f(...args) { + return args; +} + +assert.throw(function() { + // Should throw due to ToObject(undefined) + f(0, ...undefined, 1); +}, TypeError) diff --git a/packages/babel/test/fixtures/traceur/Spread/Class.js b/packages/babel/test/fixtures/traceur/Spread/Class.js new file mode 100644 index 0000000000..7d9bafc2d3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/Class.js @@ -0,0 +1,17 @@ +class SpreadTestClass { + constructor(x, y) { + this.SpreadTestClass = SpreadTestClass; + this.self = this; + this.x = x; + this.y = y; + } +} + +var object = new SpreadTestClass(...[0, 1]); + +// ---------------------------------------------------------------------------- + +assert.equal(object.x, 0); +assert.equal(object.y, 1); +assert.equal(object.self, object); +assert.isTrue(object instanceof object.SpreadTestClass); diff --git a/packages/babel/test/fixtures/traceur/Spread/Error_Disabled.js b/packages/babel/test/fixtures/traceur/Spread/Error_Disabled.js new file mode 100644 index 0000000000..75b75b251a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --spread=false +// Error: :4:8: Unexpected token ... + +[0, 1, ...[2, 3]]; diff --git a/packages/babel/test/fixtures/traceur/Spread/Iterators.js b/packages/babel/test/fixtures/traceur/Spread/Iterators.js new file mode 100644 index 0000000000..af5dae5f0b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/Iterators.js @@ -0,0 +1,17 @@ +function* G() { + yield 1; + yield 2; + yield 3; +} + +var a = [...G()]; +var b = [4, ...G()]; +var c = [...G(), 4]; +var d = [4, ...G(), 5]; + +// ---------------------------------------------------------------------------- + +assertArrayEquals([1, 2, 3], a); +assertArrayEquals([4, 1, 2, 3], b); +assertArrayEquals([1, 2, 3, 4], c); +assertArrayEquals([4, 1, 2, 3, 5], d); diff --git a/packages/babel/test/fixtures/traceur/Spread/MethodCall.js b/packages/babel/test/fixtures/traceur/Spread/MethodCall.js new file mode 100644 index 0000000000..72f08531f7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/MethodCall.js @@ -0,0 +1,18 @@ +var obj = { + method: function(...args) { + return { + self: this, + args: args + }; + } +}; + +var result = { + obj: obj, + result: obj.method(0, ...[1, 2], 3) +}; + +// ---------------------------------------------------------------------------- + +assert.equal(result.obj, result.result.self); +assertArrayEquals([0, 1, 2, 3], result.result.args); diff --git a/packages/babel/test/fixtures/traceur/Spread/MethodCallQuotedName.js b/packages/babel/test/fixtures/traceur/Spread/MethodCallQuotedName.js new file mode 100644 index 0000000000..7440fd9b97 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/MethodCallQuotedName.js @@ -0,0 +1,18 @@ +var obj = { + method: function(...args) { + return { + self: this, + args: args + }; + } +}; + +var result = { + obj: obj, + result: obj['meth' + 'od'](0, ...[1, 2], 3) +}; + +// ---------------------------------------------------------------------------- + +assert.equal(result.obj, result.result.self); +assertArrayEquals([0, 1, 2, 3], result.result.args); diff --git a/packages/babel/test/fixtures/traceur/Spread/New.js b/packages/babel/test/fixtures/traceur/Spread/New.js new file mode 100644 index 0000000000..edd3204077 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/New.js @@ -0,0 +1,26 @@ +function* G() { + yield 3; + yield 4; +} + +function F(x, y, z, a, b) { + this.x = x; + this.y = y; + this.z = z; + this.a = a; + this.b = b; + this.self = this; + this.F = F; +} + +var object = new F(0, ...[1, 2], ...G()); + +// ---------------------------------------------------------------------------- + +assert.equal(0, object.x); +assert.equal(1, object.y); +assert.equal(2, object.z); +assert.equal(3, object.a); +assert.equal(4, object.b); +assert.equal(object, object.self); +assert.isTrue(object instanceof object.F); diff --git a/packages/babel/test/fixtures/traceur/Spread/New2.js b/packages/babel/test/fixtures/traceur/Spread/New2.js new file mode 100644 index 0000000000..79e9484727 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/New2.js @@ -0,0 +1,23 @@ +function G() {} + +function F(x, y, z) { + var obj = new G; + obj.x = x; + obj.y = y; + obj.z = z; + obj.f = this; + obj.G = G; + obj.F = F; + return obj; +} + +var object = new F(0, ...[1, 2]); + +// ---------------------------------------------------------------------------- + +assert.equal(0, object.x); +assert.equal(1, object.y); +assert.equal(2, object.z); +assert.isFalse(object instanceof object.F); +assert.isTrue(object instanceof object.G); +assert.isTrue(object.f instanceof object.F); diff --git a/packages/babel/test/fixtures/traceur/Spread/NewBuiltin.js b/packages/babel/test/fixtures/traceur/Spread/NewBuiltin.js new file mode 100644 index 0000000000..c718932b90 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/NewBuiltin.js @@ -0,0 +1,7 @@ +var d = new Date(...[2011, 4, 3]); + +// ---------------------------------------------------------------------------- + +assert.equal(2011, d.getFullYear()); +assert.equal(4, d.getMonth()); +assert.equal(3, d.getDate()); diff --git a/packages/babel/test/fixtures/traceur/Spread/NoIterator.js b/packages/babel/test/fixtures/traceur/Spread/NoIterator.js new file mode 100644 index 0000000000..d9f757f408 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/NoIterator.js @@ -0,0 +1 @@ +assert.throw(() => [...{}], TypeError); diff --git a/packages/babel/test/fixtures/traceur/Spread/NotAnObject.js b/packages/babel/test/fixtures/traceur/Spread/NotAnObject.js new file mode 100644 index 0000000000..4b68c2c9e1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/NotAnObject.js @@ -0,0 +1 @@ +assert.throw(() => [...null], TypeError); diff --git a/packages/babel/test/fixtures/traceur/Spread/String.js b/packages/babel/test/fixtures/traceur/Spread/String.js new file mode 100644 index 0000000000..fcef0b86f5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/String.js @@ -0,0 +1,13 @@ +var a = ''; +var b = ['b', ...a]; +var c = [...b, ...b]; +var d; +var e = [0, ...d = '12', 3]; +var f = [... new String('abc')]; + +// ---------------------------------------------------------------------------- + +assertArrayEquals(['b'], b); +assertArrayEquals(['b', 'b'], c); +assertArrayEquals([0, '1', '2', 3], e); +assertArrayEquals(['a', 'b', 'c'], f); diff --git a/packages/babel/test/fixtures/traceur/Spread/Type.js b/packages/babel/test/fixtures/traceur/Spread/Type.js new file mode 100644 index 0000000000..bd46c4200d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Spread/Type.js @@ -0,0 +1,29 @@ + +assert.throw(() => { + [0, ...{}, 1]; +}, TypeError); + +assert.throw(() => { + [0, ...{0: 1, 1: 2, length: 2}, 3]; +}, TypeError); + +assert.throw(() => { + [0, ...true, 1]; +}, TypeError); + +assert.throw(() => { + [0, ...1, 1]; +}, TypeError); + +assert.throw(() => { + [0, ...function() {}, 1]; +}, TypeError); + +assert.throw(function() { + [0, ...null, 1]; +}, TypeError); + +assert.throw(function() { + [0, ...undefined, 1]; +}, TypeError); + diff --git a/packages/babel/test/fixtures/traceur/StringExtras/CodePointAt.js b/packages/babel/test/fixtures/traceur/StringExtras/CodePointAt.js new file mode 100644 index 0000000000..54369eb5a8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringExtras/CodePointAt.js @@ -0,0 +1,76 @@ +// Tests taken from https://mths.be/codepointat + +assert.equal(String.prototype.codePointAt.length, 1); + +// String that starts with a BMP symbol +assert.equal('abc\uD834\uDF06def'.codePointAt(''), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt('_'), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(-Infinity), undefined); +assert.equal('abc\uD834\uDF06def'.codePointAt(-1), undefined); +assert.equal('abc\uD834\uDF06def'.codePointAt(-0), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(0), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(3), 0x1D306); +assert.equal('abc\uD834\uDF06def'.codePointAt(4), 0xDF06); +assert.equal('abc\uD834\uDF06def'.codePointAt(5), 0x64); +assert.equal('abc\uD834\uDF06def'.codePointAt(42), undefined); +assert.equal('abc\uD834\uDF06def'.codePointAt(Infinity), undefined); +assert.equal('abc\uD834\uDF06def'.codePointAt(Infinity), undefined); +assert.equal('abc\uD834\uDF06def'.codePointAt(NaN), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(false), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(null), 0x61); +assert.equal('abc\uD834\uDF06def'.codePointAt(undefined), 0x61); + +// String that starts with an astral symbol +assert.equal('\uD834\uDF06def'.codePointAt(''), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt('1'), 0xDF06); +assert.equal('\uD834\uDF06def'.codePointAt('_'), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt(), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt(-1), undefined); +assert.equal('\uD834\uDF06def'.codePointAt(-0), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt(0), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt(1), 0xDF06); +assert.equal('\uD834\uDF06def'.codePointAt(42), undefined); +assert.equal('\uD834\uDF06def'.codePointAt(false), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt(null), 0x1D306); +assert.equal('\uD834\uDF06def'.codePointAt(undefined), 0x1D306); + +// Lone high surrogates +assert.equal('\uD834abc'.codePointAt(''), 0xD834); +assert.equal('\uD834abc'.codePointAt('_'), 0xD834); +assert.equal('\uD834abc'.codePointAt(), 0xD834); +assert.equal('\uD834abc'.codePointAt(-1), undefined); +assert.equal('\uD834abc'.codePointAt(-0), 0xD834); +assert.equal('\uD834abc'.codePointAt(0), 0xD834); +assert.equal('\uD834abc'.codePointAt(false), 0xD834); +assert.equal('\uD834abc'.codePointAt(NaN), 0xD834); +assert.equal('\uD834abc'.codePointAt(null), 0xD834); +assert.equal('\uD834abc'.codePointAt(undefined), 0xD834); + +// Lone low surrogates +assert.equal('\uDF06abc'.codePointAt(''), 0xDF06); +assert.equal('\uDF06abc'.codePointAt('_'), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(-1), undefined); +assert.equal('\uDF06abc'.codePointAt(-0), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(0), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(false), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(NaN), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(null), 0xDF06); +assert.equal('\uDF06abc'.codePointAt(undefined), 0xDF06); + +assert.throw(function() { String.prototype.codePointAt.call(undefined); }, TypeError); +assert.throw(function() { String.prototype.codePointAt.call(undefined, 4); }, TypeError); +assert.throw(function() { String.prototype.codePointAt.call(null); }, TypeError); +assert.throw(function() { String.prototype.codePointAt.call(null, 4); }, TypeError); +assert.equal(String.prototype.codePointAt.call(42, 0), 0x34); +assert.equal(String.prototype.codePointAt.call(42, 1), 0x32); +assert.equal(String.prototype.codePointAt.call({ 'toString': function() { return 'abc'; } }, 2), 0x63); + +assert.throw(function() { String.prototype.codePointAt.apply(undefined); }, TypeError); +assert.throw(function() { String.prototype.codePointAt.apply(undefined, [4]); }, TypeError); +assert.throw(function() { String.prototype.codePointAt.apply(null); }, TypeError); +assert.throw(function() { String.prototype.codePointAt.apply(null, [4]); }, TypeError); +assert.equal(String.prototype.codePointAt.apply(42, [0]), 0x34); +assert.equal(String.prototype.codePointAt.apply(42, [1]), 0x32); +assert.equal(String.prototype.codePointAt.apply({ 'toString': function() { return 'abc'; } }, [2]), 0x63); diff --git a/packages/babel/test/fixtures/traceur/StringExtras/EndsWith.js b/packages/babel/test/fixtures/traceur/StringExtras/EndsWith.js new file mode 100644 index 0000000000..b4585b2e8d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringExtras/EndsWith.js @@ -0,0 +1,217 @@ +// Tests taken from https://mths.be/endswith + +assert.equal(String.prototype.endsWith.length, 1); + +assert.equal('undefined'.endsWith(), true); +assert.equal('undefined'.endsWith(undefined), true); +assert.equal('undefined'.endsWith(null), false); +assert.equal('null'.endsWith(), false); +assert.equal('null'.endsWith(undefined), false); +assert.equal('null'.endsWith(null), true); + +assert.equal('abc'.endsWith(), false); +assert.equal('abc'.endsWith(''), true); +assert.equal('abc'.endsWith('\0'), false); +assert.equal('abc'.endsWith('c'), true); +assert.equal('abc'.endsWith('b'), false); +assert.equal('abc'.endsWith('ab'), false); +assert.equal('abc'.endsWith('bc'), true); +assert.equal('abc'.endsWith('abc'), true); +assert.equal('abc'.endsWith('bcd'), false); +assert.equal('abc'.endsWith('abcd'), false); +assert.equal('abc'.endsWith('bcde'), false); + +assert.equal('abc'.endsWith('', NaN), true); +assert.equal('abc'.endsWith('\0', NaN), false); +assert.equal('abc'.endsWith('c', NaN), false); +assert.equal('abc'.endsWith('b', NaN), false); +assert.equal('abc'.endsWith('ab', NaN), false); +assert.equal('abc'.endsWith('bc', NaN), false); +assert.equal('abc'.endsWith('abc', NaN), false); +assert.equal('abc'.endsWith('bcd', NaN), false); +assert.equal('abc'.endsWith('abcd', NaN), false); +assert.equal('abc'.endsWith('bcde', NaN), false); + +assert.equal('abc'.endsWith('', false), true); +assert.equal('abc'.endsWith('\0', false), false); +assert.equal('abc'.endsWith('c', false), false); +assert.equal('abc'.endsWith('b', false), false); +assert.equal('abc'.endsWith('ab', false), false); +assert.equal('abc'.endsWith('bc', false), false); +assert.equal('abc'.endsWith('abc', false), false); +assert.equal('abc'.endsWith('bcd', false), false); +assert.equal('abc'.endsWith('abcd', false), false); +assert.equal('abc'.endsWith('bcde', false), false); + +assert.equal('abc'.endsWith('', undefined), true); +assert.equal('abc'.endsWith('\0', undefined), false); +assert.equal('abc'.endsWith('c', undefined), true); +assert.equal('abc'.endsWith('b', undefined), false); +assert.equal('abc'.endsWith('ab', undefined), false); +assert.equal('abc'.endsWith('bc', undefined), true); +assert.equal('abc'.endsWith('abc', undefined), true); +assert.equal('abc'.endsWith('bcd', undefined), false); +assert.equal('abc'.endsWith('abcd', undefined), false); +assert.equal('abc'.endsWith('bcde', undefined), false); + +assert.equal('abc'.endsWith('', null), true); +assert.equal('abc'.endsWith('\0', null), false); +assert.equal('abc'.endsWith('c', null), false); +assert.equal('abc'.endsWith('b', null), false); +assert.equal('abc'.endsWith('ab', null), false); +assert.equal('abc'.endsWith('bc', null), false); +assert.equal('abc'.endsWith('abc', null), false); +assert.equal('abc'.endsWith('bcd', null), false); +assert.equal('abc'.endsWith('abcd', null), false); +assert.equal('abc'.endsWith('bcde', null), false); + +assert.equal('abc'.endsWith('', -Infinity), true); +assert.equal('abc'.endsWith('\0', -Infinity), false); +assert.equal('abc'.endsWith('c', -Infinity), false); +assert.equal('abc'.endsWith('b', -Infinity), false); +assert.equal('abc'.endsWith('ab', -Infinity), false); +assert.equal('abc'.endsWith('bc', -Infinity), false); +assert.equal('abc'.endsWith('abc', -Infinity), false); +assert.equal('abc'.endsWith('bcd', -Infinity), false); +assert.equal('abc'.endsWith('abcd', -Infinity), false); +assert.equal('abc'.endsWith('bcde', -Infinity), false); + +assert.equal('abc'.endsWith('', -1), true); +assert.equal('abc'.endsWith('\0', -1), false); +assert.equal('abc'.endsWith('c', -1), false); +assert.equal('abc'.endsWith('b', -1), false); +assert.equal('abc'.endsWith('ab', -1), false); +assert.equal('abc'.endsWith('bc', -1), false); +assert.equal('abc'.endsWith('abc', -1), false); +assert.equal('abc'.endsWith('bcd', -1), false); +assert.equal('abc'.endsWith('abcd', -1), false); +assert.equal('abc'.endsWith('bcde', -1), false); + +assert.equal('abc'.endsWith('', -0), true); +assert.equal('abc'.endsWith('\0', -0), false); +assert.equal('abc'.endsWith('c', -0), false); +assert.equal('abc'.endsWith('b', -0), false); +assert.equal('abc'.endsWith('ab', -0), false); +assert.equal('abc'.endsWith('bc', -0), false); +assert.equal('abc'.endsWith('abc', -0), false); +assert.equal('abc'.endsWith('bcd', -0), false); +assert.equal('abc'.endsWith('abcd', -0), false); +assert.equal('abc'.endsWith('bcde', -0), false); + +assert.equal('abc'.endsWith('', +0), true); +assert.equal('abc'.endsWith('\0', +0), false); +assert.equal('abc'.endsWith('c', +0), false); +assert.equal('abc'.endsWith('b', +0), false); +assert.equal('abc'.endsWith('ab', +0), false); +assert.equal('abc'.endsWith('bc', +0), false); +assert.equal('abc'.endsWith('abc', +0), false); +assert.equal('abc'.endsWith('bcd', +0), false); +assert.equal('abc'.endsWith('abcd', +0), false); +assert.equal('abc'.endsWith('bcde', +0), false); + +assert.equal('abc'.endsWith('', 1), true); +assert.equal('abc'.endsWith('\0', 1), false); +assert.equal('abc'.endsWith('c', 1), false); +assert.equal('abc'.endsWith('b', 1), false); +assert.equal('abc'.endsWith('ab', 1), false); +assert.equal('abc'.endsWith('bc', 1), false); +assert.equal('abc'.endsWith('abc', 1), false); +assert.equal('abc'.endsWith('bcd', 1), false); +assert.equal('abc'.endsWith('abcd', 1), false); +assert.equal('abc'.endsWith('bcde', 1), false); + +assert.equal('abc'.endsWith('', 2), true); +assert.equal('abc'.endsWith('\0', 2), false); +assert.equal('abc'.endsWith('c', 2), false); +assert.equal('abc'.endsWith('b', 2), true); +assert.equal('abc'.endsWith('ab', 2), true); +assert.equal('abc'.endsWith('bc', 2), false); +assert.equal('abc'.endsWith('abc', 2), false); +assert.equal('abc'.endsWith('bcd', 2), false); +assert.equal('abc'.endsWith('abcd', 2), false); +assert.equal('abc'.endsWith('bcde', 2), false); + +assert.equal('abc'.endsWith('', +Infinity), true); +assert.equal('abc'.endsWith('\0', +Infinity), false); +assert.equal('abc'.endsWith('c', +Infinity), true); +assert.equal('abc'.endsWith('b', +Infinity), false); +assert.equal('abc'.endsWith('ab', +Infinity), false); +assert.equal('abc'.endsWith('bc', +Infinity), true); +assert.equal('abc'.endsWith('abc', +Infinity), true); +assert.equal('abc'.endsWith('bcd', +Infinity), false); +assert.equal('abc'.endsWith('abcd', +Infinity), false); +assert.equal('abc'.endsWith('bcde', +Infinity), false); + +assert.equal('abc'.endsWith('', true), true); +assert.equal('abc'.endsWith('\0', true), false); +assert.equal('abc'.endsWith('c', true), false); +assert.equal('abc'.endsWith('b', true), false); +assert.equal('abc'.endsWith('ab', true), false); +assert.equal('abc'.endsWith('bc', true), false); +assert.equal('abc'.endsWith('abc', true), false); +assert.equal('abc'.endsWith('bcd', true), false); +assert.equal('abc'.endsWith('abcd', true), false); +assert.equal('abc'.endsWith('bcde', true), false); + +assert.equal('abc'.endsWith('', 'x'), true); +assert.equal('abc'.endsWith('\0', 'x'), false); +assert.equal('abc'.endsWith('c', 'x'), false); +assert.equal('abc'.endsWith('b', 'x'), false); +assert.equal('abc'.endsWith('ab', 'x'), false); +assert.equal('abc'.endsWith('bc', 'x'), false); +assert.equal('abc'.endsWith('abc', 'x'), false); +assert.equal('abc'.endsWith('bcd', 'x'), false); +assert.equal('abc'.endsWith('abcd', 'x'), false); +assert.equal('abc'.endsWith('bcde', 'x'), false); + +assert.equal('[a-z]+(bar)?'.endsWith('(bar)?'), true); +assert.throw(function() { '[a-z]+(bar)?'.endsWith(/(bar)?/); }, TypeError); +assert.equal('[a-z]+(bar)?'.endsWith('[a-z]+', 6), true); +assert.throw(function() { '[a-z]+(bar)?'.endsWith(/(bar)?/); }, TypeError); +assert.throw(function() { '[a-z]+/(bar)?/'.endsWith(/(bar)?/); }, TypeError); + +// https://mathiasbynens.be/notes/javascript-unicode#poo-test +var string = 'I\xF1t\xEBrn\xE2ti\xF4n\xE0liz\xE6ti\xF8n\u2603\uD83D\uDCA9'; +assert.equal(string.endsWith(''), true); +assert.equal(string.endsWith('\xF1t\xEBr'), false); +assert.equal(string.endsWith('\xF1t\xEBr', 5), true); +assert.equal(string.endsWith('\xE0liz\xE6'), false); +assert.equal(string.endsWith('\xE0liz\xE6', 16), true); +assert.equal(string.endsWith('\xF8n\u2603\uD83D\uDCA9'), true); +assert.equal(string.endsWith('\xF8n\u2603\uD83D\uDCA9', 23), true); +assert.equal(string.endsWith('\u2603'), false); +assert.equal(string.endsWith('\u2603', 21), true); +assert.equal(string.endsWith('\uD83D\uDCA9'), true); +assert.equal(string.endsWith('\uD83D\uDCA9', 23), true); + +assert.throw(function() { String.prototype.endsWith.call(undefined); }, TypeError); +assert.throw(function() { String.prototype.endsWith.call(undefined, 'b'); }, TypeError); +assert.throw(function() { String.prototype.endsWith.call(undefined, 'b', 4); }, TypeError); +assert.throw(function() { String.prototype.endsWith.call(null); }, TypeError); +assert.throw(function() { String.prototype.endsWith.call(null, 'b'); }, TypeError); +assert.throw(function() { String.prototype.endsWith.call(null, 'b', 4); }, TypeError); +assert.equal(String.prototype.endsWith.call(42, '2'), true); +assert.equal(String.prototype.endsWith.call(42, '4'), false); +assert.equal(String.prototype.endsWith.call(42, 'b', 4), false); +assert.equal(String.prototype.endsWith.call(42, '2', 1), false); +assert.equal(String.prototype.endsWith.call(42, '2', 4), true); +assert.equal(String.prototype.endsWith.call({ 'toString': function() { return 'abc'; } }, 'b', 0), false); +assert.equal(String.prototype.endsWith.call({ 'toString': function() { return 'abc'; } }, 'b', 1), false); +assert.equal(String.prototype.endsWith.call({ 'toString': function() { return 'abc'; } }, 'b', 2), true); +assert.throw(function() { String.prototype.endsWith.call({ 'toString': function() { throw RangeError(); } }, /./); }, RangeError); + +assert.throw(function() { String.prototype.endsWith.apply(undefined); }, TypeError); +assert.throw(function() { String.prototype.endsWith.apply(undefined, ['b']); }, TypeError); +assert.throw(function() { String.prototype.endsWith.apply(undefined, ['b', 4]); }, TypeError); +assert.throw(function() { String.prototype.endsWith.apply(null); }, TypeError); +assert.throw(function() { String.prototype.endsWith.apply(null, ['b']); }, TypeError); +assert.throw(function() { String.prototype.endsWith.apply(null, ['b', 4]); }, TypeError); +assert.equal(String.prototype.endsWith.apply(42, ['2']), true); +assert.equal(String.prototype.endsWith.apply(42, ['4']), false); +assert.equal(String.prototype.endsWith.apply(42, ['b', 4]), false); +assert.equal(String.prototype.endsWith.apply(42, ['2', 1]), false); +assert.equal(String.prototype.endsWith.apply(42, ['2', 4]), true); +assert.equal(String.prototype.endsWith.apply({ 'toString': function() { return 'abc'; } }, ['b', 0]), false); +assert.equal(String.prototype.endsWith.apply({ 'toString': function() { return 'abc'; } }, ['b', 1]), false); +assert.equal(String.prototype.endsWith.apply({ 'toString': function() { return 'abc'; } }, ['b', 2]), true); +assert.throw(function() { String.prototype.endsWith.apply({ 'toString': function() { throw RangeError(); } }, [/./]); }, RangeError); diff --git a/packages/babel/test/fixtures/traceur/StringExtras/FromCodePoint.js b/packages/babel/test/fixtures/traceur/StringExtras/FromCodePoint.js new file mode 100644 index 0000000000..fc4831f708 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringExtras/FromCodePoint.js @@ -0,0 +1,25 @@ +// Tests taken from https://mths.be/fromcodepoint + +assert.equal(String.fromCodePoint.length, 1); + +assert.equal(String.fromCodePoint(''), '\0'); +assert.equal(String.fromCodePoint(), ''); +assert.equal(String.fromCodePoint(-0), '\0'); +assert.equal(String.fromCodePoint(0), '\0'); +assert.equal(String.fromCodePoint(0x1D306), '\uD834\uDF06'); +assert.equal(String.fromCodePoint(0x1D306, 0x61, 0x1D307), '\uD834\uDF06a\uD834\uDF07'); +assert.equal(String.fromCodePoint(0x61, 0x62, 0x1D307), 'ab\uD834\uDF07'); +assert.equal(String.fromCodePoint(false), '\0'); +assert.equal(String.fromCodePoint(null), '\0'); + +assert.throw(function() { String.fromCodePoint('_'); }, RangeError); +assert.throw(function() { String.fromCodePoint('+Infinity'); }, RangeError); +assert.throw(function() { String.fromCodePoint('-Infinity'); }, RangeError); +assert.throw(function() { String.fromCodePoint(-1); }, RangeError); +assert.throw(function() { String.fromCodePoint(0x10FFFF + 1); }, RangeError); +assert.throw(function() { String.fromCodePoint(3.14); }, RangeError); +assert.throw(function() { String.fromCodePoint(3e-2); }, RangeError); +assert.throw(function() { String.fromCodePoint(Infinity); }, RangeError); +assert.throw(function() { String.fromCodePoint(NaN); }, RangeError); +assert.throw(function() { String.fromCodePoint(undefined); }, RangeError); +assert.throw(function() { String.fromCodePoint({}); }, RangeError); diff --git a/packages/babel/test/fixtures/traceur/StringExtras/Includes.js b/packages/babel/test/fixtures/traceur/StringExtras/Includes.js new file mode 100644 index 0000000000..b5cf58373d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringExtras/Includes.js @@ -0,0 +1,114 @@ +// Tests taken from https://mths.be/includes + +assert.equal(String.prototype.includes.length, 1); +assert.equal(String.prototype.propertyIsEnumerable('includes'), false); + +assert.equal('abc'.includes(), false); +assert.equal('aundefinedb'.includes(), true); +assert.equal('abc'.includes(undefined), false); +assert.equal('aundefinedb'.includes(undefined), true); +assert.equal('abc'.includes(null), false); +assert.equal('anullb'.includes(null), true); +assert.equal('abc'.includes(false), false); +assert.equal('afalseb'.includes(false), true); +assert.equal('abc'.includes(NaN), false); +assert.equal('aNaNb'.includes(NaN), true); +assert.equal('abc'.includes('abc'), true); +assert.equal('abc'.includes('def'), false); +assert.equal('abc'.includes(''), true); +assert.equal(''.includes(''), true); + +assert.equal('abc'.includes('b', -Infinity), true); +assert.equal('abc'.includes('b', -1), true); +assert.equal('abc'.includes('b', -0), true); +assert.equal('abc'.includes('b', +0), true); +assert.equal('abc'.includes('b', NaN), true); +assert.equal('abc'.includes('b', 'x'), true); +assert.equal('abc'.includes('b', false), true); +assert.equal('abc'.includes('b', undefined), true); +assert.equal('abc'.includes('b', null), true); +assert.equal('abc'.includes('b', 1), true); +assert.equal('abc'.includes('b', 2), false); +assert.equal('abc'.includes('b', 3), false); +assert.equal('abc'.includes('b', 4), false); +assert.equal('abc'.includes('b', +Infinity), false); +assert.equal('abc'.includes('bc'), true); +assert.equal('abc'.includes('bc\0'), false); + +assert.equal('abc123def'.includes(1, -Infinity), true); +assert.equal('abc123def'.includes(1, -1), true); +assert.equal('abc123def'.includes(1, -0), true); +assert.equal('abc123def'.includes(1, +0), true); +assert.equal('abc123def'.includes(1, NaN), true); +assert.equal('abc123def'.includes(1, 'x'), true); +assert.equal('abc123def'.includes(1, false), true); +assert.equal('abc123def'.includes(1, undefined), true); +assert.equal('abc123def'.includes(1, null), true); +assert.equal('abc123def'.includes(1, 1), true); +assert.equal('abc123def'.includes(1, 2), true); +assert.equal('abc123def'.includes(1, 3), true); +assert.equal('abc123def'.includes(1, 4), false); +assert.equal('abc123def'.includes(1, 5), false); +assert.equal('abc123def'.includes(1, +Infinity), false); + +assert.equal('abc123def'.includes(9, -Infinity), false); +assert.equal('abc123def'.includes(9, -1), false); +assert.equal('abc123def'.includes(9, -0), false); +assert.equal('abc123def'.includes(9, +0), false); +assert.equal('abc123def'.includes(9, NaN), false); +assert.equal('abc123def'.includes(9, 'x'), false); +assert.equal('abc123def'.includes(9, false), false); +assert.equal('abc123def'.includes(9, undefined), false); +assert.equal('abc123def'.includes(9, null), false); +assert.equal('abc123def'.includes(9, 1), false); +assert.equal('abc123def'.includes(9, 2), false); +assert.equal('abc123def'.includes(9, 3), false); +assert.equal('abc123def'.includes(9, 4), false); +assert.equal('abc123def'.includes(9, 5), false); +assert.equal('abc123def'.includes(9, +Infinity), false); + +assert.equal('foo[a-z]+(bar)?'.includes('[a-z]+'), true); +assert.throw(function() { 'foo[a-z]+(bar)?'.includes(/[a-z]+/); }, TypeError); +assert.throw(function() { 'foo/[a-z]+/(bar)?'.includes(/[a-z]+/); }, TypeError); +assert.equal('foo[a-z]+(bar)?'.includes('(bar)?'), true); +assert.throw(function() { 'foo[a-z]+(bar)?'.includes(/(bar)?/); }, TypeError); +assert.throw(function() { 'foo[a-z]+/(bar)?/'.includes(/(bar)?/); }, TypeError); + +// https://mathiasbynens.be/notes/javascript-unicode#poo-test +var string = 'I\xF1t\xEBrn\xE2ti\xF4n\xE0liz\xE6ti\xF8n\u2603\uD83D\uDCA9'; +assert.equal(string.includes(''), true); +assert.equal(string.includes('\xF1t\xEBr'), true); +assert.equal(string.includes('\xE0liz\xE6'), true); +assert.equal(string.includes('\xF8n\u2603\uD83D\uDCA9'), true); +assert.equal(string.includes('\u2603'), true); +assert.equal(string.includes('\uD83D\uDCA9'), true); + +assert.throw(function() { String.prototype.includes.call(undefined); }, TypeError); +assert.throw(function() { String.prototype.includes.call(undefined, 'b'); }, TypeError); +assert.throw(function() { String.prototype.includes.call(undefined, 'b', 4); }, TypeError); +assert.throw(function() { String.prototype.includes.call(null); }, TypeError); +assert.throw(function() { String.prototype.includes.call(null, 'b'); }, TypeError); +assert.throw(function() { String.prototype.includes.call(null, 'b', 4); }, TypeError); +assert.equal(String.prototype.includes.call(42, '2'), true); +assert.equal(String.prototype.includes.call(42, 'b', 4), false); +assert.equal(String.prototype.includes.call(42, '2', 4), false); +assert.equal(String.prototype.includes.call({ 'toString': function() { return 'abc'; } }, 'b', 0), true); +assert.equal(String.prototype.includes.call({ 'toString': function() { return 'abc'; } }, 'b', 1), true); +assert.equal(String.prototype.includes.call({ 'toString': function() { return 'abc'; } }, 'b', 2), false); +assert.throw(function() { String.prototype.includes.call({ 'toString': function() { throw RangeError(); } }, /./); }, RangeError); +assert.throw(function() { String.prototype.includes.call({ 'toString': function() { return 'abc'; } }, /./); }, TypeError); + +assert.throw(function() { String.prototype.includes.apply(undefined); }, TypeError); +assert.throw(function() { String.prototype.includes.apply(undefined, ['b']); }, TypeError); +assert.throw(function() { String.prototype.includes.apply(undefined, ['b', 4]); }, TypeError); +assert.throw(function() { String.prototype.includes.apply(null); }, TypeError); +assert.throw(function() { String.prototype.includes.apply(null, ['b']); }, TypeError); +assert.throw(function() { String.prototype.includes.apply(null, ['b', 4]); }, TypeError); +assert.equal(String.prototype.includes.apply(42, ['2']), true); +assert.equal(String.prototype.includes.apply(42, ['b', 4]), false); +assert.equal(String.prototype.includes.apply(42, ['2', 4]), false); +assert.equal(String.prototype.includes.apply({ 'toString': function() { return 'abc'; } }, ['b', 0]), true); +assert.equal(String.prototype.includes.apply({ 'toString': function() { return 'abc'; } }, ['b', 1]), true); +assert.equal(String.prototype.includes.apply({ 'toString': function() { return 'abc'; } }, ['b', 2]), false); +assert.throw(function() { String.prototype.includes.apply({ 'toString': function() { throw RangeError(); } }, [/./]); }, RangeError); +assert.throw(function() { String.prototype.includes.apply({ 'toString': function() { return 'abc'; } }, [/./]); }, TypeError); diff --git a/packages/babel/test/fixtures/traceur/StringExtras/Repeat.js b/packages/babel/test/fixtures/traceur/StringExtras/Repeat.js new file mode 100644 index 0000000000..08c5d02ae9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringExtras/Repeat.js @@ -0,0 +1,33 @@ +// Tests taken from https://mths.be/repeat + +assert.equal(String.prototype.repeat.length, 1); + +assert.equal('abc'.repeat(), ''); +assert.equal('abc'.repeat(undefined), ''); +assert.equal('abc'.repeat(null), ''); +assert.equal('abc'.repeat(false), ''); +assert.equal('abc'.repeat(NaN), ''); +assert.equal('abc'.repeat('abc'), ''); +assert.throw(function() { 'abc'.repeat(-Infinity); }, RangeError); +assert.throw(function() { 'abc'.repeat(-1); }, RangeError); +assert.equal('abc'.repeat(-0), ''); +assert.equal('abc'.repeat(+0), ''); +assert.equal('abc'.repeat(1), 'abc'); +assert.equal('abc'.repeat(2), 'abcabc'); +assert.equal('abc'.repeat(3), 'abcabcabc'); +assert.equal('abc'.repeat(4), 'abcabcabcabc'); +assert.throw(function() { 'abc'.repeat(+Infinity); }, RangeError); + +assert.throw(function() { String.prototype.repeat.call(undefined); }, TypeError); +assert.throw(function() { String.prototype.repeat.call(undefined, 4); }, TypeError); +assert.throw(function() { String.prototype.repeat.call(null); }, TypeError); +assert.throw(function() { String.prototype.repeat.call(null, 4); }, TypeError); +assert.equal(String.prototype.repeat.call(42, 4), '42424242'); +assert.equal(String.prototype.repeat.call({ 'toString': function() { return 'abc'; } }, 2), 'abcabc'); + +assert.throw(function() { String.prototype.repeat.apply(undefined); }, TypeError); +assert.throw(function() { String.prototype.repeat.apply(undefined, [4]); }, TypeError); +assert.throw(function() { String.prototype.repeat.apply(null); }, TypeError); +assert.throw(function() { String.prototype.repeat.apply(null, [4]); }, TypeError); +assert.equal(String.prototype.repeat.apply(42, [4]), '42424242'); +assert.equal(String.prototype.repeat.apply({ 'toString': function() { return 'abc'; } }, [2]), 'abcabc'); diff --git a/packages/babel/test/fixtures/traceur/StringExtras/StartsWith.js b/packages/babel/test/fixtures/traceur/StringExtras/StartsWith.js new file mode 100644 index 0000000000..8c71a21f95 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringExtras/StartsWith.js @@ -0,0 +1,210 @@ +// Tests taken from https://mths.be/startswith + +Object.prototype[1] = 2; // try to break `arguments[1]` + +assert.equal(String.prototype.startsWith.length, 1); + +assert.equal('undefined'.startsWith(), true); +assert.equal('undefined'.startsWith(undefined), true); +assert.equal('undefined'.startsWith(null), false); +assert.equal('null'.startsWith(), false); +assert.equal('null'.startsWith(undefined), false); +assert.equal('null'.startsWith(null), true); + +assert.equal('abc'.startsWith(), false); +assert.equal('abc'.startsWith(''), true); +assert.equal('abc'.startsWith('\0'), false); +assert.equal('abc'.startsWith('a'), true); +assert.equal('abc'.startsWith('b'), false); +assert.equal('abc'.startsWith('ab'), true); +assert.equal('abc'.startsWith('bc'), false); +assert.equal('abc'.startsWith('abc'), true); +assert.equal('abc'.startsWith('bcd'), false); +assert.equal('abc'.startsWith('abcd'), false); +assert.equal('abc'.startsWith('bcde'), false); + +assert.equal('abc'.startsWith('', NaN), true); +assert.equal('abc'.startsWith('\0', NaN), false); +assert.equal('abc'.startsWith('a', NaN), true); +assert.equal('abc'.startsWith('b', NaN), false); +assert.equal('abc'.startsWith('ab', NaN), true); +assert.equal('abc'.startsWith('bc', NaN), false); +assert.equal('abc'.startsWith('abc', NaN), true); +assert.equal('abc'.startsWith('bcd', NaN), false); +assert.equal('abc'.startsWith('abcd', NaN), false); +assert.equal('abc'.startsWith('bcde', NaN), false); + +assert.equal('abc'.startsWith('', false), true); +assert.equal('abc'.startsWith('\0', false), false); +assert.equal('abc'.startsWith('a', false), true); +assert.equal('abc'.startsWith('b', false), false); +assert.equal('abc'.startsWith('ab', false), true); +assert.equal('abc'.startsWith('bc', false), false); +assert.equal('abc'.startsWith('abc', false), true); +assert.equal('abc'.startsWith('bcd', false), false); +assert.equal('abc'.startsWith('abcd', false), false); +assert.equal('abc'.startsWith('bcde', false), false); + +assert.equal('abc'.startsWith('', undefined), true); +assert.equal('abc'.startsWith('\0', undefined), false); +assert.equal('abc'.startsWith('a', undefined), true); +assert.equal('abc'.startsWith('b', undefined), false); +assert.equal('abc'.startsWith('ab', undefined), true); +assert.equal('abc'.startsWith('bc', undefined), false); +assert.equal('abc'.startsWith('abc', undefined), true); +assert.equal('abc'.startsWith('bcd', undefined), false); +assert.equal('abc'.startsWith('abcd', undefined), false); +assert.equal('abc'.startsWith('bcde', undefined), false); + +assert.equal('abc'.startsWith('', null), true); +assert.equal('abc'.startsWith('\0', null), false); +assert.equal('abc'.startsWith('a', null), true); +assert.equal('abc'.startsWith('b', null), false); +assert.equal('abc'.startsWith('ab', null), true); +assert.equal('abc'.startsWith('bc', null), false); +assert.equal('abc'.startsWith('abc', null), true); +assert.equal('abc'.startsWith('bcd', null), false); +assert.equal('abc'.startsWith('abcd', null), false); +assert.equal('abc'.startsWith('bcde', null), false); + +assert.equal('abc'.startsWith('', -Infinity), true); +assert.equal('abc'.startsWith('\0', -Infinity), false); +assert.equal('abc'.startsWith('a', -Infinity), true); +assert.equal('abc'.startsWith('b', -Infinity), false); +assert.equal('abc'.startsWith('ab', -Infinity), true); +assert.equal('abc'.startsWith('bc', -Infinity), false); +assert.equal('abc'.startsWith('abc', -Infinity), true); +assert.equal('abc'.startsWith('bcd', -Infinity), false); +assert.equal('abc'.startsWith('abcd', -Infinity), false); +assert.equal('abc'.startsWith('bcde', -Infinity), false); + +assert.equal('abc'.startsWith('', -1), true); +assert.equal('abc'.startsWith('\0', -1), false); +assert.equal('abc'.startsWith('a', -1), true); +assert.equal('abc'.startsWith('b', -1), false); +assert.equal('abc'.startsWith('ab', -1), true); +assert.equal('abc'.startsWith('bc', -1), false); +assert.equal('abc'.startsWith('abc', -1), true); +assert.equal('abc'.startsWith('bcd', -1), false); +assert.equal('abc'.startsWith('abcd', -1), false); +assert.equal('abc'.startsWith('bcde', -1), false); + +assert.equal('abc'.startsWith('', -0), true); +assert.equal('abc'.startsWith('\0', -0), false); +assert.equal('abc'.startsWith('a', -0), true); +assert.equal('abc'.startsWith('b', -0), false); +assert.equal('abc'.startsWith('ab', -0), true); +assert.equal('abc'.startsWith('bc', -0), false); +assert.equal('abc'.startsWith('abc', -0), true); +assert.equal('abc'.startsWith('bcd', -0), false); +assert.equal('abc'.startsWith('abcd', -0), false); +assert.equal('abc'.startsWith('bcde', -0), false); + +assert.equal('abc'.startsWith('', +0), true); +assert.equal('abc'.startsWith('\0', +0), false); +assert.equal('abc'.startsWith('a', +0), true); +assert.equal('abc'.startsWith('b', +0), false); +assert.equal('abc'.startsWith('ab', +0), true); +assert.equal('abc'.startsWith('bc', +0), false); +assert.equal('abc'.startsWith('abc', +0), true); +assert.equal('abc'.startsWith('bcd', +0), false); +assert.equal('abc'.startsWith('abcd', +0), false); +assert.equal('abc'.startsWith('bcde', +0), false); + +assert.equal('abc'.startsWith('', 1), true); +assert.equal('abc'.startsWith('\0', 1), false); +assert.equal('abc'.startsWith('a', 1), false); +assert.equal('abc'.startsWith('b', 1), true); +assert.equal('abc'.startsWith('ab', 1), false); +assert.equal('abc'.startsWith('bc', 1), true); +assert.equal('abc'.startsWith('abc', 1), false); +assert.equal('abc'.startsWith('bcd', 1), false); +assert.equal('abc'.startsWith('abcd', 1), false); +assert.equal('abc'.startsWith('bcde', 1), false); + +assert.equal('abc'.startsWith('', +Infinity), true); +assert.equal('abc'.startsWith('\0', +Infinity), false); +assert.equal('abc'.startsWith('a', +Infinity), false); +assert.equal('abc'.startsWith('b', +Infinity), false); +assert.equal('abc'.startsWith('ab', +Infinity), false); +assert.equal('abc'.startsWith('bc', +Infinity), false); +assert.equal('abc'.startsWith('abc', +Infinity), false); +assert.equal('abc'.startsWith('bcd', +Infinity), false); +assert.equal('abc'.startsWith('abcd', +Infinity), false); +assert.equal('abc'.startsWith('bcde', +Infinity), false); + +assert.equal('abc'.startsWith('', true), true); +assert.equal('abc'.startsWith('\0', true), false); +assert.equal('abc'.startsWith('a', true), false); +assert.equal('abc'.startsWith('b', true), true); +assert.equal('abc'.startsWith('ab', true), false); +assert.equal('abc'.startsWith('bc', true), true); +assert.equal('abc'.startsWith('abc', true), false); +assert.equal('abc'.startsWith('bcd', true), false); +assert.equal('abc'.startsWith('abcd', true), false); +assert.equal('abc'.startsWith('bcde', true), false); + +assert.equal('abc'.startsWith('', 'x'), true); +assert.equal('abc'.startsWith('\0', 'x'), false); +assert.equal('abc'.startsWith('a', 'x'), true); +assert.equal('abc'.startsWith('b', 'x'), false); +assert.equal('abc'.startsWith('ab', 'x'), true); +assert.equal('abc'.startsWith('bc', 'x'), false); +assert.equal('abc'.startsWith('abc', 'x'), true); +assert.equal('abc'.startsWith('bcd', 'x'), false); +assert.equal('abc'.startsWith('abcd', 'x'), false); +assert.equal('abc'.startsWith('bcde', 'x'), false); + +assert.equal('[a-z]+(bar)?'.startsWith('[a-z]+'), true); +assert.throw(function() { '[a-z]+(bar)?'.startsWith(/[a-z]+/); }, TypeError); +assert.equal('[a-z]+(bar)?'.startsWith('(bar)?', 6), true); +assert.throw(function() { '[a-z]+(bar)?'.startsWith(/(bar)?/); }, TypeError); +assert.throw(function() { '[a-z]+/(bar)?/'.startsWith(/(bar)?/); }, TypeError); + +// https://mathiasbynens.be/notes/javascript-unicode#poo-test +var string = 'I\xF1t\xEBrn\xE2ti\xF4n\xE0liz\xE6ti\xF8n\u2603\uD83D\uDCA9'; +assert.equal(string.startsWith(''), true); +assert.equal(string.startsWith('\xF1t\xEBr'), false); +assert.equal(string.startsWith('\xF1t\xEBr', 1), true); +assert.equal(string.startsWith('\xE0liz\xE6'), false); +assert.equal(string.startsWith('\xE0liz\xE6', 11), true); +assert.equal(string.startsWith('\xF8n\u2603\uD83D\uDCA9'), false); +assert.equal(string.startsWith('\xF8n\u2603\uD83D\uDCA9', 18), true); +assert.equal(string.startsWith('\u2603'), false); +assert.equal(string.startsWith('\u2603', 20), true); +assert.equal(string.startsWith('\uD83D\uDCA9'), false); +assert.equal(string.startsWith('\uD83D\uDCA9', 21), true); + +assert.throw(function() { String.prototype.startsWith.call(undefined); }, TypeError); +assert.throw(function() { String.prototype.startsWith.call(undefined, 'b'); }, TypeError); +assert.throw(function() { String.prototype.startsWith.call(undefined, 'b', 4); }, TypeError); +assert.throw(function() { String.prototype.startsWith.call(null); }, TypeError); +assert.throw(function() { String.prototype.startsWith.call(null, 'b'); }, TypeError); +assert.throw(function() { String.prototype.startsWith.call(null, 'b', 4); }, TypeError); +assert.equal(String.prototype.startsWith.call(42, '2'), false); +assert.equal(String.prototype.startsWith.call(42, '4'), true); +assert.equal(String.prototype.startsWith.call(42, 'b', 4), false); +assert.equal(String.prototype.startsWith.call(42, '2', 1), true); +assert.equal(String.prototype.startsWith.call(42, '2', 4), false); +assert.equal(String.prototype.startsWith.call({ 'toString': function() { return 'abc'; } }, 'b', 0), false); +assert.equal(String.prototype.startsWith.call({ 'toString': function() { return 'abc'; } }, 'b', 1), true); +assert.equal(String.prototype.startsWith.call({ 'toString': function() { return 'abc'; } }, 'b', 2), false); +assert.throw(function() { String.prototype.startsWith.call({ 'toString': function() { throw RangeError(); } }, /./); }, RangeError); + +assert.throw(function() { String.prototype.startsWith.apply(undefined); }, TypeError); +assert.throw(function() { String.prototype.startsWith.apply(undefined, ['b']); }, TypeError); +assert.throw(function() { String.prototype.startsWith.apply(undefined, ['b', 4]); }, TypeError); +assert.throw(function() { String.prototype.startsWith.apply(null); }, TypeError); +assert.throw(function() { String.prototype.startsWith.apply(null, ['b']); }, TypeError); +assert.throw(function() { String.prototype.startsWith.apply(null, ['b', 4]); }, TypeError); +assert.equal(String.prototype.startsWith.apply(42, ['2']), false); +assert.equal(String.prototype.startsWith.apply(42, ['4']), true); +assert.equal(String.prototype.startsWith.apply(42, ['b', 4]), false); +assert.equal(String.prototype.startsWith.apply(42, ['2', 1]), true); +assert.equal(String.prototype.startsWith.apply(42, ['2', 4]), false); +assert.equal(String.prototype.startsWith.apply({ 'toString': function() { return 'abc'; } }, ['b', 0]), false); +assert.equal(String.prototype.startsWith.apply({ 'toString': function() { return 'abc'; } }, ['b', 1]), true); +assert.equal(String.prototype.startsWith.apply({ 'toString': function() { return 'abc'; } }, ['b', 2]), false); +assert.throw(function() { String.prototype.startsWith.apply({ 'toString': function() { throw RangeError(); } }, [/./]); }, RangeError); + +delete Object.prototype[1]; diff --git a/packages/babel/test/fixtures/traceur/StringIterator.js b/packages/babel/test/fixtures/traceur/StringIterator.js new file mode 100644 index 0000000000..8b5dc5ccfa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/StringIterator.js @@ -0,0 +1,15 @@ +var s = 'abc 💩 def'; + +var expected = ['a', 'b', 'c', ' ', '💩', ' ', 'd', 'e', 'f']; +var actual = []; +for (var x of s) { + actual.push(x); +} +assert.deepEqual(actual, expected); + +var newS = new String('abc'); +var res = []; +for (var x of newS) { + res.push(x); +} +assert.deepEqual(res, ['a', 'b', 'c']); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/Error_Super.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/Error_Super.js new file mode 100644 index 0000000000..e92759c500 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/Error_Super.js @@ -0,0 +1,10 @@ +// Error: :8:17: Unexpected token ; + +var p = {}; + +var o = { + __proto__: p, + method() { + return super; + } +}; diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperChaining.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperChaining.js new file mode 100644 index 0000000000..9254653816 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperChaining.js @@ -0,0 +1,30 @@ +var a = { + foo() { + return 'A'; + } +}; + +var b = { + __proto__: a, + foo() { + return super.foo() + ' B'; + } +}; + +var c = { + __proto__: b, + foo() { + return super.foo() + ' C'; + } +}; + +var d = { + __proto__: c, + foo() { + return super.foo() + ' D'; + } +}; + +// ---------------------------------------------------------------------------- + +assert.equal('A B C D', d.foo()); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperChangeProto.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperChangeProto.js new file mode 100644 index 0000000000..592c2078d1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperChangeProto.js @@ -0,0 +1,22 @@ +var log = ''; + +var base = { + p() { log += '[base]'; } +}; + +var otherBase = { + p() { log += '[otherBase]'; } +}; + +var derived = { + __proto__: base, + p() { + log += '[derived]'; + super.p(); + derived.__proto__ = otherBase; + super.p(); + } +}; + +derived.p(); +assert.equal(log, '[derived][base][otherBase]'); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperInArrow.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperInArrow.js new file mode 100644 index 0000000000..ba826c8ea8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperInArrow.js @@ -0,0 +1,20 @@ +var x; + +var p = { + m(v) { + x = v; + } +}; + +var o = { + __proto__: p, + n(x) { + var f = (x) => { + super.m(x); + }; + f(x); + } +}; + +o.n(42); +assert.equal(x, 42); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperNestedObject.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperNestedObject.js new file mode 100644 index 0000000000..6f719cc10b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperNestedObject.js @@ -0,0 +1,37 @@ +var p = { + m() { + this.name = 'p'; + }, + n() { + return 'name'; + } +}; + +var p2 = { + m() { + this.name = 'p2'; + } +}; + +var o = { + __proto__: p, + name: 'o', + m() { + this.inner = { + __proto__: p2, + [super.n()]: 'inner', + m() { + super.m(); + } + }; + super.m(); + } +}; + +o.m(); +assert.equal(o.name, 'p'); +assert.equal(o.inner.name, 'inner'); + +o.inner.m(); +assert.equal(o.name, 'p'); +assert.equal(o.inner.name, 'p2'); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperPostfix.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperPostfix.js new file mode 100644 index 0000000000..36b11cd8aa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperPostfix.js @@ -0,0 +1,22 @@ +var p = { + _x: 0, + get x() { + return this._x; + }, + set x(x) { + this._x = x; + } +}; + +var o = { + __proto__: p, + m() { + assert.equal(this.x, 0); + assert.equal(super.x++, 0); + assert.equal(this.x, 1); + assert.equal(super.x--, 1); + assert.equal(this.x, 0); + } +}; + +o.m(); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperSet.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperSet.js new file mode 100644 index 0000000000..2be6e336bf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperSet.js @@ -0,0 +1,51 @@ +var p = { + _y: {v: 321}, + _z: 1, + + set x(value) { + this._x = value; + }, + get x() { + return this._y; + }, + getX() { + return this._x; + }, + getV() { + return this._y.v; + }, + set z(v) { + this._z = v; + }, + get z() { + return this._z; + }, +}; + +var o = { + __proto__: p, + set x(value) { + assert.equal(super.x = value, value); + }, + set v(value) { + return super.x.v = value; + }, + inc(val) { + assert.equal(super.z += val, 4); + }, + incLookup(val) { + assert.equal(super['z'] += val, 9); + } +}; + +o.x = 42; +assert.equal(42, o.getX()); + +o.v = 123; +assert.equal(123, o.getV()); + +o.inc(3); +assert.equal(4, o.z); + +o.incLookup(5); +assert.equal(9, o.z); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperUnary.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperUnary.js new file mode 100644 index 0000000000..54a6bc7405 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperUnary.js @@ -0,0 +1,25 @@ +var p = { + _x: 0, + get x() { + return this._x; + }, + set x(x) { + this._x = x; + }, +}; + +var o = { + __proto__: p, + m() { + assert.equal(this.x, 0); + assert.equal(++super.x, 1); + assert.equal(this.x, 1); + assert.equal(--super.x, 0); + assert.equal(this.x, 0); + + // Don't use assert.typeOf since we are testing typeof. + assert.equal(typeof super.x, 'number'); + } +}; + +o.m(); diff --git a/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperWithoutProto.js b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperWithoutProto.js new file mode 100644 index 0000000000..416d9f62d5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/SuperObjectLiteral/SuperWithoutProto.js @@ -0,0 +1,8 @@ +var o = { + x: true, + m() { + return super.hasOwnProperty('x'); + } +}; + +assert.isTrue(o.m()); diff --git a/packages/babel/test/fixtures/traceur/Symbol/GetOwnPropertySymbols.js b/packages/babel/test/fixtures/traceur/Symbol/GetOwnPropertySymbols.js new file mode 100644 index 0000000000..75946b17d4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Symbol/GetOwnPropertySymbols.js @@ -0,0 +1,7 @@ +var s1 = Symbol(); +var s2 = Symbol(); +var object = {a: 'a'}; +object[s1] = 's1'; +object.b = 'b'; +object[s2] = 's2'; +assertArrayEquals([s1, s2], Object.getOwnPropertySymbols(object)); diff --git a/packages/babel/test/fixtures/traceur/Symbol/Inherited.js b/packages/babel/test/fixtures/traceur/Symbol/Inherited.js new file mode 100644 index 0000000000..dd31d0e177 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Symbol/Inherited.js @@ -0,0 +1,27 @@ +'use strict'; + +var s = Symbol(); +var p = {}; +Object.defineProperty(p, s, { + get: function() { + return 42; + }, + configurable: true +}); + +var o = Object.create(p); +assert.equal(42, o[s]); +assert.throws(function() { + o[s] = 1; +}, TypeError); + +var val; +Object.defineProperty(p, s, { + set: function(v) { + val = v; + }, + configurable: true +}); + +o[s] = 33; +assert.equal(33, val); diff --git a/packages/babel/test/fixtures/traceur/Symbol/Object.js b/packages/babel/test/fixtures/traceur/Symbol/Object.js new file mode 100644 index 0000000000..6d00300ab4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Symbol/Object.js @@ -0,0 +1,29 @@ +var s = Symbol(); +var object = {}; +object[s] = 42; +assert.equal(42, object[s]); +// Native Symbol throws for ToString. +// assert.isUndefined(object[s + '']); +assertArrayEquals([], Object.getOwnPropertyNames(object)); +assert.isTrue(object.hasOwnProperty(s)); + +assert.equal(32, object[s] -= 10); +assert.equal(16, object[s] /= 2); +assert.equal(16, object[s]); + +var n = Symbol(); +assert.equal(object[n] = 1, 1); +assert.equal(object[n] += 2, 3); + +assert.isTrue(Object.getOwnPropertyDescriptor(object, n).enumerable); + +assert.isTrue(n in object); +assert.isTrue(delete object[n]); +assert.isFalse(n in object); + +var keys = []; +for (var k in object) { + keys.push(k); +} +assert.equal(0, keys.length, keys + ''); +assert.equal(0, Object.keys(object).length); diff --git a/packages/babel/test/fixtures/traceur/Symbol/ObjectModel.js b/packages/babel/test/fixtures/traceur/Symbol/ObjectModel.js new file mode 100644 index 0000000000..a80c496a63 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Symbol/ObjectModel.js @@ -0,0 +1,13 @@ +var s = Symbol('s'); +assert.equal(typeof s, 'symbol'); +assert.equal(s.constructor, Symbol); +assert.isFalse(s instanceof Symbol); + +assert.throws(() => { + new Symbol; +}); + +// TODO(jjb): Our impl not to spec so generators can use Symbols without +// requiring transcoding +// assert.equal(s.toString(), 'Symbol(s)'); +assert.equal(s.valueOf(), s); diff --git a/packages/babel/test/fixtures/traceur/Symbol/TransformationOff.js b/packages/babel/test/fixtures/traceur/Symbol/TransformationOff.js new file mode 100644 index 0000000000..1b0ee783b5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Symbol/TransformationOff.js @@ -0,0 +1,8 @@ +var s = Symbol(); +var s2 = Symbol(); +var object = {}; +object[s] = 1; +object[s2] = 2; + +assert.equal(object[s], 1); +assert.equal(object[s2], 2); diff --git a/packages/babel/test/fixtures/traceur/Syntax/ArrayWithHoles.js b/packages/babel/test/fixtures/traceur/Syntax/ArrayWithHoles.js new file mode 100644 index 0000000000..47477ebe94 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/ArrayWithHoles.js @@ -0,0 +1,10 @@ +var arr = [,1, ,3,]; +assert.equal(4, arr.length); + +var arr2 = [,1, ,...[3],]; +assert.equal(4, arr.length); + +var x, y; +[x, , y] = [0, 1, 2]; +assert.equal(0, x); +assert.equal(2, y); diff --git a/packages/babel/test/fixtures/traceur/Syntax/CaseClauseShouldBeStatementListItem.js b/packages/babel/test/fixtures/traceur/Syntax/CaseClauseShouldBeStatementListItem.js new file mode 100644 index 0000000000..cff0d8269a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/CaseClauseShouldBeStatementListItem.js @@ -0,0 +1,14 @@ +switch (1) { + case 2: + let x; + break; + case 3: + const y = 4; + break; + case 5: + function f() {} + break; + default: + class C {} + break; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Empty.js b/packages/babel/test/fixtures/traceur/Syntax/Empty.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_Arguments.js b/packages/babel/test/fixtures/traceur/Syntax/Error_Arguments.js new file mode 100644 index 0000000000..bb2d410758 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_Arguments.js @@ -0,0 +1,6 @@ +// Error: :6:6: Unexpected token ) + +function f(x) { +} + +f(x, ); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileClass.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileClass.js new file mode 100644 index 0000000000..5ea5fedfde --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileClass.js @@ -0,0 +1,4 @@ +// Options: --block-binding +// Error: :4:4: Unexpected reserved word class + +do class C {} while (false); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileConst.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileConst.js new file mode 100644 index 0000000000..1b509a5550 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileConst.js @@ -0,0 +1,4 @@ +// Options: --block-binding +// Error: :4:4: Unexpected reserved word const + +do const y = 1; while (false); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileFunction.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileFunction.js new file mode 100644 index 0000000000..330b4be080 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileFunction.js @@ -0,0 +1,4 @@ +// Options: --block-binding +// Error: :4:4: Unexpected reserved word function + +do function f() {} while (false); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileLet.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileLet.js new file mode 100644 index 0000000000..be2fd327d4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileLet.js @@ -0,0 +1,4 @@ +// Options: --block-binding +// Error: :4:4: Unexpected reserved word let + +do let x; while (false); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileLetOpenSquare.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileLetOpenSquare.js new file mode 100644 index 0000000000..4f1c7766e9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInDoWhileLetOpenSquare.js @@ -0,0 +1,4 @@ +// Options: --block-binding +// Error: :4:4: A statement cannot start with 'let [' + +do let[0] = 1; while (false); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInElse.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInElse.js new file mode 100644 index 0000000000..cf7db93de4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInElse.js @@ -0,0 +1,22 @@ +// Options: --block-binding +// Error: :9:3: Unexpected reserved word let +// Error: :12:3: Unexpected reserved word const +// Error: :15:3: Unexpected reserved word function +// Error: :18:3: Unexpected reserved word class +// Error: :21:3: A statement cannot start with 'let [' + +if (true) {} else + let x; + +if (true) {} else + const y = 1; + +if (true) {} else + function f() {} + +if (true) {} else + class C {} + +if (true) {} else + let[0] = 1; + diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInFor.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInFor.js new file mode 100644 index 0000000000..3f23c1a5c7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInFor.js @@ -0,0 +1,21 @@ +// Options: --block-binding +// Error: :9:3: Unexpected reserved word let +// Error: :12:3: Unexpected reserved word const +// Error: :15:3: Unexpected reserved word function +// Error: :18:3: Unexpected reserved word class +// Error: :21:3: A statement cannot start with 'let [' + +for (;;) + let x; + +for (;;) + const y = 1; + +for (;;) + function f() {} + +for (;;) + class C {} + +for (;;) + let[0] = 1; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInForIn.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInForIn.js new file mode 100644 index 0000000000..a037d53501 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInForIn.js @@ -0,0 +1,21 @@ +// Options: --block-binding +// Error: :9:3: Unexpected reserved word let +// Error: :12:3: Unexpected reserved word const +// Error: :15:3: Unexpected reserved word function +// Error: :18:3: Unexpected reserved word class +// Error: :21:3: A statement cannot start with 'let [' + +for (var key in {}) + let x; + +for (var key in {}) + const y = 1; + +for (var key in {}) + function f() {} + +for (var key in {}) + class C {} + +for (var key in {}) + let[0] = 1; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInForOf.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInForOf.js new file mode 100644 index 0000000000..6114e7897c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInForOf.js @@ -0,0 +1,21 @@ +// Options: --block-binding +// Error: :9:3: Unexpected reserved word let +// Error: :12:3: Unexpected reserved word const +// Error: :15:3: Unexpected reserved word function +// Error: :18:3: Unexpected reserved word class +// Error: :21:3: A statement cannot start with 'let [' + +for (var item of []) + let x; + +for (var item of []) + const y = 1; + +for (var item of []) + function f() {} + +for (var item of []) + class C {} + +for (var item of []) + let[0] = 1; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInIf.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInIf.js new file mode 100644 index 0000000000..84ffdc7df8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInIf.js @@ -0,0 +1,21 @@ +// Options: --block-binding +// Error: :9:3: Unexpected reserved word let +// Error: :12:3: Unexpected reserved word const +// Error: :15:3: Unexpected reserved word function +// Error: :18:3: Unexpected reserved word class +// Error: :21:3: A statement cannot start with 'let [' + +if (true) + let x; + +if (true) + const y = 1; + +if (true) + function f() {} + +if (true) + class C {} + +if (true) + let[0] = 1; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInWhile.js b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInWhile.js new file mode 100644 index 0000000000..049626f80c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_DeclarationInWhile.js @@ -0,0 +1,21 @@ +// Options: --block-binding +// Error: :9:3: Unexpected reserved word let +// Error: :12:3: Unexpected reserved word const +// Error: :15:3: Unexpected reserved word function +// Error: :18:3: Unexpected reserved word class +// Error: :21:3: A statement cannot start with 'let [' + +while (false) + let x; + +while (false) + const y = 1; + +while (false) + function f() {} + +while (false) + class C {} + +while (false) + let[0] = 1; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_ForInLoopTooManyVariableDeclarations.js b/packages/babel/test/fixtures/traceur/Syntax/Error_ForInLoopTooManyVariableDeclarations.js new file mode 100644 index 0000000000..39072eeec4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_ForInLoopTooManyVariableDeclarations.js @@ -0,0 +1,3 @@ +// Error: :3:15: Unexpected token in + +for (var i, j in {}) {} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_ForOfLoopTooManyVariableDeclarations.js b/packages/babel/test/fixtures/traceur/Syntax/Error_ForOfLoopTooManyVariableDeclarations.js new file mode 100644 index 0000000000..47300cbe20 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_ForOfLoopTooManyVariableDeclarations.js @@ -0,0 +1,3 @@ +// Error: :3:15: Unexpected token of + +for (var i, j of []) {} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_FunctionParam.js b/packages/babel/test/fixtures/traceur/Syntax/Error_FunctionParam.js new file mode 100644 index 0000000000..4f7b7741e5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_FunctionParam.js @@ -0,0 +1,5 @@ +// Error: :3:14: Unexpected token ) + +function f(x,) { + return x; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_IllegalReturn.js b/packages/babel/test/fixtures/traceur/Syntax/Error_IllegalReturn.js new file mode 100644 index 0000000000..fd775a56aa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_IllegalReturn.js @@ -0,0 +1,3 @@ +// Error: :3:1: Illegal return statement + +return 42; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_IllegalReturn.module.js b/packages/babel/test/fixtures/traceur/Syntax/Error_IllegalReturn.module.js new file mode 100644 index 0000000000..fd775a56aa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_IllegalReturn.module.js @@ -0,0 +1,3 @@ +// Error: :3:1: Illegal return statement + +return 42; \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_IsValidSimpleAssignmentTarget.js b/packages/babel/test/fixtures/traceur/Syntax/Error_IsValidSimpleAssignmentTarget.js new file mode 100644 index 0000000000..a978e81cb7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_IsValidSimpleAssignmentTarget.js @@ -0,0 +1,41 @@ +// Options: --async-functions --async-generators --for-on +// Error: :16:1: Invalid left-hand side expression in assignment +// Error: :17:1: Invalid left-hand side expression in assignment +// Error: :18:3: Invalid left-hand side expression in prefix operation +// Error: :19:3: Invalid left-hand side expression in prefix operation +// Error: :20:1: Invalid left-hand side expression in postfix operation +// Error: :21:1: Invalid left-hand side expression in postfix operation +// Error: :25:3: Invalid left-hand side expression in assignment +// Error: :26:3: Invalid left-hand side expression in assignment +// Error: :30:5: Invalid left-hand side expression in assignment +// Error: :33:12: Invalid left-hand side expression in assignment +// Error: :35:6: Invalid left-hand side expression in assignment +// Error: :37:6: Invalid left-hand side expression in assignment +// Error: :40:7: Invalid left-hand side expression in assignment + +this = 1; +42 = 1; +++42 +--42 +42++ +42-- + +function f() { + 'use strict'; + arguments = 1; + eval = 1; +} + +var x; +[x, 42] = [1, 2]; + +var y; +({y, prop: 42} = {y: 2, prop: 3}); + +for (42 in {}) {} + +for (42 of []) {} + +async function* ag() { + for (42 on {}) {} +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_MultipleDefault.js b/packages/babel/test/fixtures/traceur/Syntax/Error_MultipleDefault.js new file mode 100644 index 0000000000..a103f5fe88 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_MultipleDefault.js @@ -0,0 +1,12 @@ +// Error: :9:5: Switch statements may have at most one 'default' clause + +(function() { + switch (42) { + case 1: + return; + default: + return; + default: + return; + } +}); diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_NoLineTerminatorPostfix.js b/packages/babel/test/fixtures/traceur/Syntax/Error_NoLineTerminatorPostfix.js new file mode 100644 index 0000000000..da9ad46a47 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_NoLineTerminatorPostfix.js @@ -0,0 +1,7 @@ +// Error: 6:7: Unexpected token ; + +function f(x) { + var x = 0; + x + ++; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_ParamDuplicateCheck.js b/packages/babel/test/fixtures/traceur/Syntax/Error_ParamDuplicateCheck.js new file mode 100644 index 0000000000..ce6aaf9204 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_ParamDuplicateCheck.js @@ -0,0 +1,27 @@ +// Error: :10:18: Duplicate parameter name x +// Error: :10:24: Duplicate parameter name x +// Error: :14:17: Duplicate parameter name x +// Error: :14:23: Duplicate parameter name x +// Error: :20:20: Duplicate parameter name a +// Error: :20:23: Duplicate parameter name a +// Error: :24:19: Duplicate parameter name a +// Error: :24:22: Duplicate parameter name a + +function f(x, y, x, z, x) { + 'use strict'; +} + +var f2 = (x, y, x, z, x) => { + 'use strict'; +}; + +function g() { + 'use strict'; + function h(a, b, a, a) { + + } + + var g2 = (a, b, a, a) => { + + }; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_ParamDuplicateCheckNonSimple.js b/packages/babel/test/fixtures/traceur/Syntax/Error_ParamDuplicateCheckNonSimple.js new file mode 100644 index 0000000000..6377946c13 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_ParamDuplicateCheckNonSimple.js @@ -0,0 +1,64 @@ +// Error: :24:18: Duplicate parameter name x +// Error: :24:24: Duplicate parameter name x +// Error: :27:19: Duplicate parameter name a +// Error: :27:23: Duplicate parameter name a +// Error: :30:22: Duplicate parameter name c +// Error: :30:25: Duplicate parameter name c +// Error: :33:20: Duplicate parameter name e +// Error: :33:23: Duplicate parameter name e +// Error: :36:15: Duplicate parameter name g +// Error: :39:15: Duplicate parameter name i +// Error: :42:15: Duplicate parameter name k +// Error: :45:17: Duplicate parameter name x +// Error: :45:23: Duplicate parameter name x +// Error: :48:18: Duplicate parameter name a +// Error: :48:22: Duplicate parameter name a +// Error: :51:21: Duplicate parameter name c +// Error: :51:24: Duplicate parameter name c +// Error: :54:19: Duplicate parameter name e +// Error: :54:22: Duplicate parameter name e +// Error: :57:14: Duplicate parameter name g +// Error: :60:14: Duplicate parameter name i +// Error: :63:14: Duplicate parameter name k + +function f(x, y, x, ...x) { +} + +function g([a, b, a], a) { +} + +function h(c = 1, d, c, c) { +} + +function i({e, f}, e, e) { +} + +function j(g, g, [h]) { +} + +function h(i, i, j = 1) { +} + +function i(k, k, ...l) { +} + +var f2 = (x, y, x, ...x) => { +}; + +var g2 = ([a, b, a], a) => { +}; + +var h2 = (c = 1, d, c, c) => { +}; + +var i2 = ({e, f}, e, e) => { +}; + +var j2 = (g, g, [h]) => { +}; + +var h2 = (i, i, j = 1) => { +}; + +var i2 = (k, k, ...l) => { +}; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_RegExpNotClosed.js b/packages/babel/test/fixtures/traceur/Syntax/Error_RegExpNotClosed.js new file mode 100644 index 0000000000..5cd0381dd7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_RegExpNotClosed.js @@ -0,0 +1,3 @@ +// Error: :3:1: Expected '/' in regular expression literal + +/ \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInArguments.js b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInArguments.js new file mode 100644 index 0000000000..2ab9b50a90 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInArguments.js @@ -0,0 +1,14 @@ +// Error: :8:25: implements is a reserved identifier +// Error :8:25: implements is a reserved identifier +// Error :10:1: implements is a reserved identifier +// Error :11:2: implements is a reserved identifier +// Error :12:3: implements is a reserved identifier +// Error :13:6: implements is a reserved identifier + +function testImplements(implements) { 'use strict'; } + +implements => { 'use strict'; }; +(implements) => { 'use strict'; }; +([implements]) => { 'use strict'; }; +([...implements]) => { 'use strict'; }; +({implements}) => { 'use strict'; }; diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInArgumentsPattern.js b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInArgumentsPattern.js new file mode 100644 index 0000000000..944f89d8f9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInArgumentsPattern.js @@ -0,0 +1,6 @@ +// Error: :3:26: implements is a reserved identifier + +function testImplements({implements}) { + 'use strict'; + return 42; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInPropertyDefinitionIdentifierReference.js b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInPropertyDefinitionIdentifierReference.js new file mode 100644 index 0000000000..fc8a0fefde --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInPropertyDefinitionIdentifierReference.js @@ -0,0 +1,6 @@ +// Error: :5:11: yield is a reserved identifier + +function testStrictKeywordsInPropertyDefinitionIdentifierReference() { + 'use strict'; + return {yield}; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInStrict.js b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInStrict.js new file mode 100644 index 0000000000..cb73fa3a3e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_StrictKeywordsInStrict.js @@ -0,0 +1,6 @@ +// Error: :4:26: implements is a reserved identifier + +'use strict'; +function testImplements({implements}) { + return 42; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_UnicodeEscapeSequenceInName.js b/packages/babel/test/fixtures/traceur/Syntax/Error_UnicodeEscapeSequenceInName.js new file mode 100644 index 0000000000..3e35a4d5cc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_UnicodeEscapeSequenceInName.js @@ -0,0 +1,3 @@ +// Error: :3:5: Character code '48' is not a valid identifier start char + +var \u0030ab = 42; // 0ab diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_WithInClass.js b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInClass.js new file mode 100644 index 0000000000..3015ee964f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInClass.js @@ -0,0 +1,7 @@ +// Error: :5:5: Strict mode code may not include a with statement + +class C { + method() { + with ({}) {} + } +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_WithInModule.module.js b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInModule.module.js new file mode 100644 index 0000000000..31172a46bc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInModule.module.js @@ -0,0 +1,3 @@ +// Error: :3:1: Strict mode code may not include a with statement + +with ({}) {} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_WithInStrictFunction.js b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInStrictFunction.js new file mode 100644 index 0000000000..7510f92ed9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInStrictFunction.js @@ -0,0 +1,7 @@ +// Error: :6:3: Strict mode code may not include a with statement + +function testWithInStrict() { + 'use foo'; + 'use strict'; + with ({}) {} +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_WithInStrictProgram.js b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInStrictProgram.js new file mode 100644 index 0000000000..e9bf1f2440 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_WithInStrictProgram.js @@ -0,0 +1,5 @@ +// Error: :5:1: Strict mode code may not include a with statement + +'use foo'; +'use strict'; +with ({}) {} diff --git a/packages/babel/test/fixtures/traceur/Syntax/Error_YieldStarNewLine.js b/packages/babel/test/fixtures/traceur/Syntax/Error_YieldStarNewLine.js new file mode 100644 index 0000000000..9c7ddee6f1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/Error_YieldStarNewLine.js @@ -0,0 +1,6 @@ +// Error: :5:7: Unexpected token * + +function* yieldStarNewLine() { + yield + *42; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/ExpressionValidation.js b/packages/babel/test/fixtures/traceur/Syntax/ExpressionValidation.js new file mode 100644 index 0000000000..a217ea9eed --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/ExpressionValidation.js @@ -0,0 +1,29 @@ +'use strict'; + +(function() { + +// test MemberLookupExpression +function f(a) { + var b = [42]; + return (a||b)[0]; +} + +assert.equal(42, f(null)); +assert.equal(43, f([43])); + +// test NewExpression +var a, b = function() { this.ans = 42; }; +assert.equal(new (a||b)().ans, 42); + +a = function() { this.ans = 43; }; +assert.equal(new (a||b)().ans, 43); + +// test CallExpression +a = undefined; +b = function() { return 42; } +assert.equal((a||b)(), 42); + +a = function() { return 43; } +assert.equal((a||b)(), 43); + +})(); diff --git a/packages/babel/test/fixtures/traceur/Syntax/ImplicitSemiColon.js b/packages/babel/test/fixtures/traceur/Syntax/ImplicitSemiColon.js new file mode 100644 index 0000000000..af00da62c4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/ImplicitSemiColon.js @@ -0,0 +1,6 @@ +function f() { + return + 42; +} + +assert.isUndefined(f()); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Syntax/ImportFromTypo.module.js b/packages/babel/test/fixtures/traceur/Syntax/ImportFromTypo.module.js new file mode 100644 index 0000000000..4ae054a80e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/ImportFromTypo.module.js @@ -0,0 +1,3 @@ +// Error: :3:11: Unexpected token FROM + +import {} FROM 'abc'; diff --git a/packages/babel/test/fixtures/traceur/Syntax/InInBinding.js b/packages/babel/test/fixtures/traceur/Syntax/InInBinding.js new file mode 100644 index 0000000000..2d5bd70b44 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/InInBinding.js @@ -0,0 +1,2 @@ +var [x = 'a' in {a: 1}] = []; +assert.equal(true, x); diff --git a/packages/babel/test/fixtures/traceur/Syntax/IsValidSimpleAssignmentTarget.js b/packages/babel/test/fixtures/traceur/Syntax/IsValidSimpleAssignmentTarget.js new file mode 100644 index 0000000000..27181066e0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/IsValidSimpleAssignmentTarget.js @@ -0,0 +1,38 @@ +(function() { + var eval = 1; + eval++; + ++eval; + eval--; + --eval; + [eval] = [eval]; + ({eval} = {eval}); + eval += 1; + eval /= 2; + assert.equal(1, eval); +})(); + +(function() { + var arguments = 1; + arguments++; + ++arguments; + arguments--; + --arguments; + [arguments] = [arguments]; + ({arguments} = {arguments}); + arguments += 1; + arguments /= 2; + assert.equal(1, arguments); +})(); + +(function() { + var yield = 1; + yield++; + ++yield; + yield--; + --yield; + [yield] = [yield]; + ({yield} = {yield}); + yield += 1; + yield /= 2; + assert.equal(1, yield); +})(); diff --git a/packages/babel/test/fixtures/traceur/Syntax/MultlineCommentIsNewLine.js b/packages/babel/test/fixtures/traceur/Syntax/MultlineCommentIsNewLine.js new file mode 100644 index 0000000000..6de511896e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/MultlineCommentIsNewLine.js @@ -0,0 +1,28 @@ +function f() { + return /* + */ 1; +} +assert.equal(undefined, f()); + +function g() { + return /* */ 1; +} +assert.equal(1, g()); + +function h() { + return /* */ /* + */ 1; +} +assert.equal(undefined, h()); + +function i() { + return /* */ // + 1; +} +assert.equal(undefined, i()); + +function j() { + return // + 1; +} +assert.equal(undefined, j()); diff --git a/packages/babel/test/fixtures/traceur/Syntax/NoNewLineHereEndOfFile.js b/packages/babel/test/fixtures/traceur/Syntax/NoNewLineHereEndOfFile.js new file mode 100644 index 0000000000..c5e9e23bba --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/NoNewLineHereEndOfFile.js @@ -0,0 +1,3 @@ +// Comment not closed. +var f = (x) /* + => {} diff --git a/packages/babel/test/fixtures/traceur/Syntax/NumberLiteralMemberExpression.js b/packages/babel/test/fixtures/traceur/Syntax/NumberLiteralMemberExpression.js new file mode 100644 index 0000000000..43b6ab7fdf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/NumberLiteralMemberExpression.js @@ -0,0 +1,4 @@ +assert.equal(1 .toString(), '1'); +assert.equal(1.1.toString(), '1.1'); +assert.equal(1e1.toString(), '10'); +assert.equal(1E1.toString(), '10'); diff --git a/packages/babel/test/fixtures/traceur/Syntax/ParamDuplicateCheckNonSimpleOk.js b/packages/babel/test/fixtures/traceur/Syntax/ParamDuplicateCheckNonSimpleOk.js new file mode 100644 index 0000000000..e3f5b85e08 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/ParamDuplicateCheckNonSimpleOk.js @@ -0,0 +1,15 @@ +function f(a, b, {c = function(a) {}}) { + +} + +var f2 = (a, b, {c = function(a) {}}) => { + +}; + +function g(d, e, [f = function(d) {}]) { + +} + +var g2 = (d, e, [f = function(d) {}]) => { + +}; diff --git a/packages/babel/test/fixtures/traceur/Syntax/ParamDuplicateCheckOk.js b/packages/babel/test/fixtures/traceur/Syntax/ParamDuplicateCheckOk.js new file mode 100644 index 0000000000..ac6df64fcf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/ParamDuplicateCheckOk.js @@ -0,0 +1,18 @@ +function f(x, y = function(x) {}) { + 'use strict'; +} + +var f2 = (x, y = function(x) {}) => { + 'use strict'; +}; + +function g() { + 'use strict'; + function h(x, y = function(x) {}) { + + } + + var h2 = (x, y = function(x) {}) => { + + }; +} diff --git a/packages/babel/test/fixtures/traceur/Syntax/RegularExpression.js b/packages/babel/test/fixtures/traceur/Syntax/RegularExpression.js new file mode 100644 index 0000000000..cc313822a2 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/RegularExpression.js @@ -0,0 +1,10 @@ +var re1 = /a*b/; +var re2 = /=a+/; +var re3 = /\//; +var re4 = /=/; +var re5 = /=*/; +var re6 = /a*b/g; +var re7 = /=a+/g; +var re8 = /\//g; +var re9 = /=/g; +var re10 = /=*/g; diff --git a/packages/babel/test/fixtures/traceur/Syntax/StrictKeywords.js b/packages/babel/test/fixtures/traceur/Syntax/StrictKeywords.js new file mode 100644 index 0000000000..47fdad0db4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/StrictKeywords.js @@ -0,0 +1,47 @@ +function testImplementsVar() { + var implements = 1; + return implements; +} +assert.equal(testImplementsVar(), 1); + +function testInterfaceVar() { + var interface = 1; + return interface; +} +assert.equal(testInterfaceVar(), 1); + +function testPackageVar() { + var package = 1; + return package; +} +assert.equal(testPackageVar(), 1); + +function testPrivateVar() { + var private = 1; + return private; +} +assert.equal(testPrivateVar(), 1); + +function testProtectedVar() { + var protected = 1; + return protected; +} +assert.equal(testProtectedVar(), 1); + +function testPublicVar() { + var public = 1; + return public; +} +assert.equal(testPublicVar(), 1); + +function testStaticVar() { + var static = 1; + return static; +} +assert.equal(testStaticVar(), 1); + +function testYieldVar() { + var yield = 1; + return yield; +} +assert.equal(testYieldVar(), 1); diff --git a/packages/babel/test/fixtures/traceur/Syntax/StrictKeywordsInPattern.js b/packages/babel/test/fixtures/traceur/Syntax/StrictKeywordsInPattern.js new file mode 100644 index 0000000000..16d407c7f6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/StrictKeywordsInPattern.js @@ -0,0 +1,39 @@ +function testImplementsInPattern({implements}) { + return implements; +} +assert.equal(testImplementsInPattern({implements: 1}), 1); + +function testInterfaceInPattern({interface}) { + return interface; +} +assert.equal(testInterfaceInPattern({interface: 1}), 1); + +function testPackageInPattern({package}) { + return package; +} +assert.equal(testPackageInPattern({package: 1}), 1); + +function testPrivateInPattern({private}) { + return private; +} +assert.equal(testPrivateInPattern({private: 1}), 1); + +function testProtectedInPattern({protected}) { + return protected; +} +assert.equal(testProtectedInPattern({protected: 1}), 1); + +function testPublicInPattern({public}) { + return public; +} +assert.equal(testPublicInPattern({public: 1}), 1); + +function testStaticInPattern({static}) { + return static; +} +assert.equal(testStaticInPattern({static: 1}), 1); + +function testYieldInPattern({yield}) { + return yield; +} +assert.equal(testYieldInPattern({yield: 1}), 1); diff --git a/packages/babel/test/fixtures/traceur/Syntax/StringEscapes.js b/packages/babel/test/fixtures/traceur/Syntax/StringEscapes.js new file mode 100644 index 0000000000..335c142dbe --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/StringEscapes.js @@ -0,0 +1,13 @@ +var o1 = { + '\\\'': 42, + '\0\b\f\n\r\t\v\x42\u1234': 1234 +}; +var o2 = { + '\\\'\ +': 42, + '\0\b\f\n\r\t\v\x42\u1234': 1234 +}; + +assertArrayEquals(Object.keys(o1), Object.keys(o2)); +assert.equal(42, o1['\\\'']); +assert.equal(42, o2['\\\'']); diff --git a/packages/babel/test/fixtures/traceur/Syntax/UnicodeEscapeSequenceInName.js b/packages/babel/test/fixtures/traceur/Syntax/UnicodeEscapeSequenceInName.js new file mode 100644 index 0000000000..9f2dd2d23a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/UnicodeEscapeSequenceInName.js @@ -0,0 +1,5 @@ +var a\u0062c = 1; +assert.equal(1, abc); + +var λ = 2; +assert.equal(2, \u03bb); diff --git a/packages/babel/test/fixtures/traceur/Syntax/UseStrictEscapeSequence.js b/packages/babel/test/fixtures/traceur/Syntax/UseStrictEscapeSequence.js new file mode 100644 index 0000000000..9ad36444d4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/UseStrictEscapeSequence.js @@ -0,0 +1,7 @@ +function testUseStrictEscapeSequence() { + 'use str\x69ct'; + return this; +} + +assert.notEqual(testUseStrictEscapeSequence(), undefined); + diff --git a/packages/babel/test/fixtures/traceur/Syntax/UseStrictLineContinuation.js b/packages/babel/test/fixtures/traceur/Syntax/UseStrictLineContinuation.js new file mode 100644 index 0000000000..c312bca40a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/UseStrictLineContinuation.js @@ -0,0 +1,7 @@ +function testUseStrictLineContinuation() { + 'use \ +strict'; + return this; +} + +assert.notEqual(testUseStrictLineContinuation(), undefined); diff --git a/packages/babel/test/fixtures/traceur/Syntax/null.js b/packages/babel/test/fixtures/traceur/Syntax/null.js new file mode 100644 index 0000000000..ec747fa47d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Syntax/null.js @@ -0,0 +1 @@ +null \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/CallExpression.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/CallExpression.js new file mode 100644 index 0000000000..69ab401dba --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/CallExpression.js @@ -0,0 +1,18 @@ +// Options: --block-binding + +{ + let i = 0, called = 0; + function f() { + called++; + return function() { + return ++i; + }; + } + + assert.equal(1, f() `whatevs`); + assert.equal(1, called); + assert.equal(2, f `abc` `def`); + assert.equal(2, called); + assert.equal(3, f `ghi` ()); + assert.equal(3, called); +} diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/CommaExpression.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/CommaExpression.js new file mode 100644 index 0000000000..c6749db6db --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/CommaExpression.js @@ -0,0 +1,10 @@ +assert.equal('24', `${ 1, 2 }${ 3, 4 }`); +assert.equal('6', `${ 5, 6 }`); + +function templateLiteralCommaTest(callsite, x, y) { + assert.equal(2, x); + assert.equal(4, y); + return x + y; +} + +assert.equal(6, templateLiteralCommaTest`${ 1, 2 }${ 3, 4 }`); diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Default.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Default.js new file mode 100644 index 0000000000..7b9326f29e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Default.js @@ -0,0 +1,95 @@ +// Options: --block-binding + +assert.equal('', ``); +assert.equal('a', `a`); +assert.equal('"', `"`); +assert.equal("'", `'`); +assert.equal("`", `\``); +assert.equal('"', `\"`); + +assert.equal('\\"', `\\"`); +assert.equal('"\\', `"\\`); + +assert.equal('\n', `\n`); +assert.equal('\r', `\r`); +assert.equal('\r\n', `\r\n`); +assert.equal('\t', `\t`); +assert.equal('\u2028', `\u2028`); +assert.equal('\u2029', `\u2029`); + +assert.equal('$', `$`); +assert.equal('$ a', `$ a`); +assert.equal('$ {a}', `$ {a}`); + +assert.equal('undefined', `${ undefined }`); +assert.equal('null', `${ null }`); + +{ + let $ = 'DOLLAR'; + let $$ = 'DD' + assert.equal('$$', `$$`); + assert.equal('DOLLAR', `${$}`); + assert.equal('$$$', `$$$`); + assert.equal('DOLLARDOLLAR', `${$}${$}`); + assert.equal('DOLLAR$$', `${$}$$`); + assert.equal('$$DOLLAR', `$$${$}`); + assert.equal('$$$', `\$$$`); + + let a = 'A'; + let b = 'B'; + assert.equal('aAbB', `a${a}b${b}`); + assert.equal('aAb$b', `a${a}b$b`); + assert.equal('$a.$b', `$a.$b`); + + let x = 3; + let y = 5; + + assert.equal('3 + 5 = 8', `${x} + ${y} = ${ x + y}`); + + // nested + assert.equal('3 + 5 = 8', `${x} + ${ `${y} = ${ `${x + y}` }` }`); + + assert.equal('3', `${x}`); + assert.equal(' 3', ` ${x}`); + assert.equal('3 ', `${x} `); + assert.equal('35', `${x}${y}`); + assert.equal(' 35', ` ${x}${y}`); + assert.equal('3 5', `${x} ${y}`); + assert.equal('35 ', `${x}${y} `); + assert.equal(' 3 5 ', ` ${x} ${y} `); + + // def s(x): + // return ' ' if x else '' + // for i in range(16): + // v = (s(i&8), s(i&4), s(i&2), s(i&1)) + // print "assert.equal('%s3%s5%s8%s', `%s${x}%s${y}%s${x+y}%s`);" % (v+v) + assert.equal('358', `${x}${y}${x+y}`); + assert.equal('358 ', `${x}${y}${x+y} `); + assert.equal('35 8', `${x}${y} ${x+y}`); + assert.equal('35 8 ', `${x}${y} ${x+y} `); + assert.equal('3 58', `${x} ${y}${x+y}`); + assert.equal('3 58 ', `${x} ${y}${x+y} `); + assert.equal('3 5 8', `${x} ${y} ${x+y}`); + assert.equal('3 5 8 ', `${x} ${y} ${x+y} `); + assert.equal(' 358', ` ${x}${y}${x+y}`); + assert.equal(' 358 ', ` ${x}${y}${x+y} `); + assert.equal(' 35 8', ` ${x}${y} ${x+y}`); + assert.equal(' 35 8 ', ` ${x}${y} ${x+y} `); + assert.equal(' 3 58', ` ${x} ${y}${x+y}`); + assert.equal(' 3 58 ', ` ${x} ${y}${x+y} `); + assert.equal(' 3 5 8', ` ${x} ${y} ${x+y}`); + assert.equal(' 3 5 8 ', ` ${x} ${y} ${x+y} `); +} + +// Line continuations +assert.equal('ab', `a\ +b`); +assert.equal('ab', `a\ +\ +b`); + +assert.equal('\n', ` +`); +assert.equal('\n\n', ` + +`); diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_Disabled.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_Disabled.js new file mode 100644 index 0000000000..8d857e11fe --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_Disabled.js @@ -0,0 +1,9 @@ +// Options: --template-literals=false +// Error: :5:1: Unexpected token ` +// Error: :9:5: Unexpected token ` + +`abc`; + +function tag() {} + +tag `def`; diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_InvalidSubstitution.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_InvalidSubstitution.js new file mode 100644 index 0000000000..781d8d0298 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_InvalidSubstitution.js @@ -0,0 +1,5 @@ +// Error: :6:1: Unterminated template literal + +function f() {} + +f`a${ ` diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_InvalidSubstitution2.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_InvalidSubstitution2.js new file mode 100644 index 0000000000..89df2eb6d3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_InvalidSubstitution2.js @@ -0,0 +1,5 @@ +// Error: :5:7: Unexpected token } + +function f() {} + +f`a${ }` diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_NotClosed.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_NotClosed.js new file mode 100644 index 0000000000..00acb1154a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Error_NotClosed.js @@ -0,0 +1,5 @@ +// Error: :6:1: Unterminated template literal + +function f() {} + +f`not closed \` diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/InBlock.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/InBlock.js new file mode 100644 index 0000000000..61e8073ac3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/InBlock.js @@ -0,0 +1,9 @@ +// This just tests that we do not get any compile errors. + +{ + `abc` +} + +(function() { + `def` +}); \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/InModule.module.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/InModule.module.js new file mode 100644 index 0000000000..73f9339215 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/InModule.module.js @@ -0,0 +1,2 @@ +import * as m from './resources/m.js'; +import * as n from './resources/n.js'; diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/MemberExpression.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/MemberExpression.js new file mode 100644 index 0000000000..dfa14f4661 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/MemberExpression.js @@ -0,0 +1,25 @@ +// Options: --block-binding + +{ + let a = [function() { + return 1; + }]; + + assert.equal(1, a[0] `whatevs`); + + function f() { + return [function() { + return 2; + }]; + } + + assert.equal(2, f `abc` [0] `def`); + + let o = { + g: function() { + return 3; + } + }; + + assert.equal(3, o.g `ghi`); +} diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/NewExpression.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/NewExpression.js new file mode 100644 index 0000000000..0f863428fa --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/NewExpression.js @@ -0,0 +1,44 @@ +// Options: --block-binding + +{ + let i = 0, log = []; + this.logger = function(...e) { + log.push(e.join(' ')); + } + + // https://crbug.com/450942 + assert.equal(typeof new Function`logger('a')`, 'object'); + assert.deepEqual(log, ['a']); + + log.length = 0; + function tag(...e) { + var text = e[0] && String.raw(...e); + if (this instanceof tag) { + log.push('new;' + text); + } else { + log.push('tag;' + text); + return tag; + } + } + + assert.equal(typeof new tag`a``b``c`, 'object'); + assert.deepEqual(log, [ + 'tag;a', + 'tag;b', + 'tag;c', + 'new;undefined' + ]); + + log.length = 0; + function C(cs) { + log.push(cs[0]); + if (this instanceof C) { + this.name = cs; + } else { + return C; + } + } + + assert.deepEqual(new C`a``b``c`('test'), { name: 'test' }); + assert.deepEqual(log, ['a', 'b', 'c', 't']); +} diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Strict.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Strict.js new file mode 100644 index 0000000000..6efd163ea7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Strict.js @@ -0,0 +1,7 @@ +'use strict'; + +function f(...args) { + return this; +} + +assert.equal(undefined, f `a`); diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/StringRaw.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/StringRaw.js new file mode 100644 index 0000000000..29a55675df --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/StringRaw.js @@ -0,0 +1,10 @@ +assert.equal('', String.raw ``); +assert.equal('\n', String.raw ` +`); +assert.equal('\\n', String.raw `\n`); +assert.equal('\\n42\\t', String.raw `\n${ 40 + 2 }\t`); +assert.equal('\n42\t', String.raw ` +${42} `); +assert.equal('\\\n42\\\n', String.raw `\ +${42}\ +`); diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/Tag.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/Tag.js new file mode 100644 index 0000000000..727b8a8977 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/Tag.js @@ -0,0 +1,87 @@ +// Options: --block-binding + +{ + function expose(callSite, var_args) { + assert.isTrue(Array.isArray(callSite)); + assert.isTrue(Object.isFrozen(callSite)); + var rawDescr = Object.getOwnPropertyDescriptor(callSite, 'raw'); + assert.isTrue(rawDescr !== undefined); + assert.isTrue('value' in rawDescr); + assert.isFalse(rawDescr.enumerable); + assert.isFalse(rawDescr.writable); + assert.isFalse(rawDescr.configurable); + assert.isTrue(Object.isFrozen(callSite.raw)); + assert.isTrue(Array.isArray(callSite.raw)); + assert.isTrue(Object.isFrozen(callSite.raw)); + assert.equal(callSite.raw.length, callSite.length); + + // The number of the literal portions is always same or one greater than the + // number of substitutions + var literalPortionCount = callSite.raw.length; + var substitutionCount = arguments.length - 1; + assert.isTrue(literalPortionCount == substitutionCount || + literalPortionCount == substitutionCount + 1); + + return arguments; + } + + let x = 3; + let y = 5; + + assert.equal(1, expose``.length); + assert.equal(1, expose`a`.length); + assert.equal(2, expose`a${x}`.length); + assert.equal(2, expose`a${x} b`.length); + assert.equal(3, expose`a${x} ${y}`.length); + assert.equal(3, expose`${x}${y}`.length); + assert.equal(2, expose`${x}a`.length); + + assert.equal(1, expose``[0].length); + assert.equal(1, expose``[0].raw.length); + + assertArrayEquals(['a'], expose`a`[0].raw); + assertArrayEquals(['a'], expose`a`[0]); + + assertArrayEquals(['\\n'], expose`\n`[0].raw); + assertArrayEquals(['\n'], expose`\n`[0]); + + assertArrayEquals(['\\r'], expose`\r`[0].raw); + assertArrayEquals(['\r'], expose`\r`[0]); + + assertArrayEquals(['\\f'], expose`\f`[0].raw); + assertArrayEquals(['\f'], expose`\f`[0]); + + assertArrayEquals(['\\b'], expose`\b`[0].raw); + assertArrayEquals(['\b'], expose`\b`[0]); + + assertArrayEquals(['\\u2028'], expose`\u2028`[0].raw); + assertArrayEquals(['\u2028'], expose`\u2028`[0]); + + assertArrayEquals(['\\u2029'], expose`\u2029`[0].raw); + assertArrayEquals(['\u2029'], expose`\u2029`[0]); + + assertArrayEquals(['a', 'b'], expose`a${x}b`[0].raw); + assertArrayEquals(['a', 'b'], expose`a${x}b`[0]); + + // These have tab characters in them. + assertArrayEquals(['\t', '\\t'], expose` ${x}\t`[0].raw); + assertArrayEquals(['\t', '\t'], expose` ${x}\t`[0]); + + assertArrayEquals(['\n', '\\n'], expose` +${x}\n`[0].raw); + assertArrayEquals(['\n', '\n'], expose` +${x}\n`[0]); + + // These contains the ES new line chars \u2028 and \u2029 + assertArrayEquals(['\u2028', '\\u2028'], expose`
${x}\u2028`[0].raw); + assertArrayEquals(['\u2028', '\u2028'], expose`
${x}\u2028`[0]); + + assertArrayEquals(['\u2029', '\\u2029'], expose`
${x}\u2029`[0].raw); + assertArrayEquals(['\u2029', '\u2029'], expose`
${x}\u2029`[0]); + + assertArrayEquals(['a/*b*/c'], expose`a/*b*/c`[0].raw); + assertArrayEquals(['a/*b*/c'], expose`a/*b*/c`[0]); + + assertArrayEquals(['a'], expose/* comment */`a`[0].raw); + assertArrayEquals(['a'], expose/* comment */`a`[0]); +} diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/TemplateObjectCaching.module.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/TemplateObjectCaching.module.js new file mode 100644 index 0000000000..e0d3b27225 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/TemplateObjectCaching.module.js @@ -0,0 +1,17 @@ +import {cooked, raw} from './resources/template-objects.js'; + +function assertCooked(obj) { + assert.equal(obj, cooked); + assert.notEqual(obj, raw); +} + +function assertRaw(obj) { + assert.equal(obj, raw); + assert.notEqual(obj, cooked); +} + +assertCooked `a${1}b`; +assertCooked `a${2}b`; + +assertRaw `c${3}d\n`; +assertRaw `c${4}d\n`; diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/f.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/f.js new file mode 100644 index 0000000000..f78d33206e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/f.js @@ -0,0 +1,3 @@ +export function f(...args) { + return args; +} diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/m.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/m.js new file mode 100644 index 0000000000..364751373a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/m.js @@ -0,0 +1,3 @@ +import {f} from './f.js'; + +assert.equal('a', (f `a`)[0][0]); diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/n.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/n.js new file mode 100644 index 0000000000..108fed14bf --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/n.js @@ -0,0 +1,3 @@ +import {f} from './f.js'; + +assert.equal('b', (f `b`)[0][0]); diff --git a/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/template-objects.js b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/template-objects.js new file mode 100644 index 0000000000..f7caefa37c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/TemplateLiterals/resources/template-objects.js @@ -0,0 +1,13 @@ +export let cooked; +export let raw; + +function setCooked(obj) { + cooked = obj; +} + +function setRaw(obj) { + raw = obj; +} + +setCooked `a${1}b`; +setRaw `c${3}d\n`; diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_CodePointTooHigh.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_CodePointTooHigh.js new file mode 100644 index 0000000000..cd46882d85 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_CodePointTooHigh.js @@ -0,0 +1,4 @@ +// Options: --unicode-escape-sequences +// Error: :4:5: The code point in a Unicode escape sequence cannot exceed 10FFFF + +"\u{1000000}"; diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_Disabled.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_Disabled.js new file mode 100644 index 0000000000..1a36396b2a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_Disabled.js @@ -0,0 +1,4 @@ +// Options: --unicode-escape-sequences=false +// Error: :4:4: Hex digit expected + +"\u{0}"; diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected.js new file mode 100644 index 0000000000..ccffc71d37 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected.js @@ -0,0 +1,4 @@ +// Options: --unicode-escape-sequences +// Error: :4:5: Hex digit expected + +"\u{"; diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected2.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected2.js new file mode 100644 index 0000000000..9ebfa1245c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected2.js @@ -0,0 +1,4 @@ +// Options: --unicode-escape-sequences +// Error: :4:5: Hex digit expected + +"\u{1"; diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected3.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected3.js new file mode 100644 index 0000000000..29efadfc29 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected3.js @@ -0,0 +1,4 @@ +// Options: --unicode-escape-sequences +// Error: :4:5: Hex digit expected + +"\u{ diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected4.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected4.js new file mode 100644 index 0000000000..1ac1390cf4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Error_HexDigitExpected4.js @@ -0,0 +1,4 @@ +// Options: --unicode-escape-sequences +// Error: :4:5: Hex digit expected + +"\u{}"; diff --git a/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Simple.js b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Simple.js new file mode 100644 index 0000000000..fbc1c788a7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/UnicodeEscapeSequence/Simple.js @@ -0,0 +1,15 @@ +// Options: --unicode-escape-sequences + +(function() { + assert.equal("\u{0}", "\u0000"); + assert.equal("\u{000000001}", "\u0001"); + assert.equal("\u{FFFF}", "\uFFFF"); + + assert.equal("\u{10000}", "\uD800\uDC00"); + assert.equal("\u{10FFFF}", "\uDBFF\uDFFF"); + + assert.equal("\\u{1}", "\\u{1}"); + assert.equal("\\\u{1}", "\\\u0001"); + + assert.equal("\U{1}", "\U{1}"); +})(); diff --git a/packages/babel/test/fixtures/traceur/Yield/Arguments.js b/packages/babel/test/fixtures/traceur/Yield/Arguments.js new file mode 100644 index 0000000000..6e02361a44 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Arguments.js @@ -0,0 +1,8 @@ +function* f() { + yield [arguments[0], arguments[1]]; +} + +for (var arr of f(1, 2)) { + assert.equal(1, arr[0]); + assert.equal(2, arr[1]); +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Yield/BadIterable.js b/packages/babel/test/fixtures/traceur/Yield/BadIterable.js new file mode 100644 index 0000000000..625aaf9b4a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/BadIterable.js @@ -0,0 +1,44 @@ +function* wrap(generator) { + return yield *generator; +} + +class BadIterable { + constructor() { + this.closed = false; + } + + [Symbol.iterator]() { + return { + iterable: this, + next(v) { + return {value: 42, done: false}; + }, + // throw method missing + return(v) { + this.iterable.closed = true; + return {value: undefined, done: true}; + } + }; + } +} + +var i1 = new BadIterable(); +var g1 = wrap(i1); +assert.deepEqual(g1.next(), {value: 42, done: false}); +assert.throws(() => g1.throw('ex1'), TypeError); +assert.isTrue(i1.closed); + +function* f2() { + try { + yield 1; + } finally { + f2.closed = true; + } +} +f2.closed = false; + +var g2 = wrap(f2()); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.throws(() => g2.throw('ex2'), 'ex2'); +assert.isTrue(f2.closed); + diff --git a/packages/babel/test/fixtures/traceur/Yield/BinaryOperator.js b/packages/babel/test/fixtures/traceur/Yield/BinaryOperator.js new file mode 100644 index 0000000000..49a63ff271 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/BinaryOperator.js @@ -0,0 +1,9 @@ +function* f(x) { + var a = (yield x) + (yield x + 1); + return a; +} + +var g = f(1); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(1), {value: 2, done: false}); +assert.deepEqual(g.next(2), {value: 3, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/Break.js b/packages/babel/test/fixtures/traceur/Yield/Break.js new file mode 100644 index 0000000000..1fd1b2c46d --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Break.js @@ -0,0 +1,48 @@ +var x = ':'; + +function* f() { + label1: { + x += 'a'; + yield 1; + x += 'b' + while (true && true) { + break label1; + } + x += 'c'; + } + x += 'd' +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assert.equal(x, ':abd'); + + +x = ':'; + +function* f2() { + label1: { + x += 'a'; + while(true) { + x += 'b'; + label2: { + x += 'c'; + yield 3; + x += 'd'; + while (true) { + break label1; + } + x += 'e'; + } + x += 'f'; + } + x += 'g'; + } + x += 'h'; +} + +g = f2(); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assert.equal(x, ':abcdh'); diff --git a/packages/babel/test/fixtures/traceur/Yield/BreakForOf.js b/packages/babel/test/fixtures/traceur/Yield/BreakForOf.js new file mode 100644 index 0000000000..98ecf6c99e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/BreakForOf.js @@ -0,0 +1,54 @@ +var g, x; + +function* f() { + try { + yield 1; + yield 2; + } finally { + x = 42; + } +} + +g = f(); +x = 0; + +for (let i of g) { + break; +} + +assert.equal(x, 42); + +g = f(); +x = 10; + +(function () { + for (let i of g) { + return; + } +}()); + +assert.equal(x, 42); + +g = f(); +x = 20; + +label1: +for (let i of g) { + if (i == 1) { + continue label1; + } + assert.equal(x, 20); +} + +g = f(); +x = 30; + +label2: +label3: +for (let i of g) { + if (i == 1) { + continue label2; + } + assert.equal(x, 30); +} + diff --git a/packages/babel/test/fixtures/traceur/Yield/CommaOperator.js b/packages/babel/test/fixtures/traceur/Yield/CommaOperator.js new file mode 100644 index 0000000000..1747a62dff --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/CommaOperator.js @@ -0,0 +1,9 @@ +function* f(x, y) { + yield x, yield y; + return x + y; +} + +var g = f(1, 2); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(1), {value: 2, done: false}); +assert.deepEqual(g.next(2), {value: 3, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/Continue.js b/packages/babel/test/fixtures/traceur/Yield/Continue.js new file mode 100644 index 0000000000..61d392e093 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Continue.js @@ -0,0 +1,18 @@ +var x = ':'; + +function* f() { + yield 1; + var j = 0; + label1: for (var i = 0; i < 3; i++) { + x += 'i:' + i; + x += 'j:' + j; + if (j++ > 4) return; + continue label1; + x += 'x'; + } +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assert.equal(x, ':i:0j:0i:1j:1i:2j:2'); diff --git a/packages/babel/test/fixtures/traceur/Yield/DefaultArguments.js b/packages/babel/test/fixtures/traceur/Yield/DefaultArguments.js new file mode 100644 index 0000000000..9a009aa806 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/DefaultArguments.js @@ -0,0 +1,7 @@ +function* f(x = 1) { + yield x; +} + +for (var x of f(42)) { + assert.equal(42, x); +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Yield/DoGenerator.js b/packages/babel/test/fixtures/traceur/Yield/DoGenerator.js new file mode 100644 index 0000000000..42f901fc00 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/DoGenerator.js @@ -0,0 +1,19 @@ +function* doGenerator() { + var i = 0; + do { + if (++i % 2 == 0) continue; + yield i; + } while (i < 6); +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('135', accumulate(doGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/DoWhileStatementWithYield.js b/packages/babel/test/fixtures/traceur/Yield/DoWhileStatementWithYield.js new file mode 100644 index 0000000000..967aba4264 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/DoWhileStatementWithYield.js @@ -0,0 +1,33 @@ +function* f() { + var x = 0; + do { + yield x++; + } while (yield 'test'); +} + +var g = f(); +assert.deepEqual(g.next(), {value: 0, done: false}); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(true), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(true), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(false), {value: undefined, done: true}); + +function* f2() { + var x = 0; + do { + yield x++; + } while ((yield 'a') || (yield 'b')); +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 0, done: false}); +assert.deepEqual(g2.next(), {value: 'a', done: false}); +assert.deepEqual(g2.next(true), {value: 1, done: false}); +assert.deepEqual(g2.next(), {value: 'a', done: false}); +assert.deepEqual(g2.next(false), {value: 'b', done: false}); +assert.deepEqual(g2.next(true), {value: 2, done: false}); +assert.deepEqual(g2.next(false), {value: 'a', done: false}); +assert.deepEqual(g2.next(false), {value: 'b', done: false}); +assert.deepEqual(g2.next(), {value: undefined, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/EmptyGenerator.js b/packages/babel/test/fixtures/traceur/Yield/EmptyGenerator.js new file mode 100644 index 0000000000..0fd11a4e7a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/EmptyGenerator.js @@ -0,0 +1,5 @@ +function* f() { +} + +var g = f(); +assert.deepEqual(g.next(), {done: true, value: undefined}); diff --git a/packages/babel/test/fixtures/traceur/Yield/Error_Disabled.js b/packages/babel/test/fixtures/traceur/Yield/Error_Disabled.js new file mode 100644 index 0000000000..6add24ed19 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Error_Disabled.js @@ -0,0 +1,8 @@ +// Options: --generators=false +// Error: :4:9: Unexpected token * + +function* range(start, end) { + for (var i = start; i < end; i++) { + yield i; + } +} diff --git a/packages/babel/test/fixtures/traceur/Yield/Error_Disabled2.js b/packages/babel/test/fixtures/traceur/Yield/Error_Disabled2.js new file mode 100644 index 0000000000..303c0eb057 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Error_Disabled2.js @@ -0,0 +1,7 @@ +// Options: --forOf=false +// Error: :5:12: Unexpected token of + +var s = []; +for (var i of yieldFor()) { + s.push(i); +} diff --git a/packages/babel/test/fixtures/traceur/Yield/Error_MissingStar.js b/packages/babel/test/fixtures/traceur/Yield/Error_MissingStar.js new file mode 100644 index 0000000000..4023645a9e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Error_MissingStar.js @@ -0,0 +1,5 @@ +// Error: :4:9: Semi-colon expected + +function simpleGenerator() { + yield 1; +} diff --git a/packages/babel/test/fixtures/traceur/Yield/Finally.js b/packages/babel/test/fixtures/traceur/Yield/Finally.js new file mode 100644 index 0000000000..e4519b74f4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Finally.js @@ -0,0 +1,22 @@ +var finallyVisited = false; + +function* test() { + try { + yield 42; + } finally { + finallyVisited = true; + } +} + +var it = test(); +assert.deepEqual({value: 42, done: false}, it.next()); +assert.isFalse(finallyVisited); + +assert.deepEqual({value: undefined, done: true}, it.next()); +assert.isTrue(finallyVisited); + +finallyVisited = false; +for (var i of test()) { + assert.equal(42, i); +} +assert.isTrue(finallyVisited); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForEmptyGenerator.js b/packages/babel/test/fixtures/traceur/Yield/ForEmptyGenerator.js new file mode 100644 index 0000000000..760f40ad6a --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForEmptyGenerator.js @@ -0,0 +1,15 @@ +function* forEmptyGenerator() { + yield* []; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('', accumulate(forEmptyGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForGenerator.js b/packages/babel/test/fixtures/traceur/Yield/ForGenerator.js new file mode 100644 index 0000000000..526e9e5e06 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForGenerator.js @@ -0,0 +1,25 @@ +function* forGenerator() { + var a = 1, b = 1; + for (var i = 0; i < 4; i++) { + // TODO(jmesserly): this was changed until we get destructing + //[a, b] = [b, a + b]; + var t0 = b; + var t1 = a + b; + a = t0; + b = t1; + + yield a; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('1235', accumulate(forGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForInGenerator.js b/packages/babel/test/fixtures/traceur/Yield/ForInGenerator.js new file mode 100644 index 0000000000..09b6a0f9c7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForInGenerator.js @@ -0,0 +1,27 @@ +function* forInGenerator() { + var object = { + a: 0, + b: 1, + c: 2 + }; + for (var key in object) { + if (key == 'a') { + delete object.b; + object.d = 3; + } + yield key; + yield object[key]; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('a0c2',accumulate(forInGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForInGenerator2.js b/packages/babel/test/fixtures/traceur/Yield/ForInGenerator2.js new file mode 100644 index 0000000000..47c3f9bcfd --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForInGenerator2.js @@ -0,0 +1,28 @@ +function* forInGenerator2() { + var object = { + a: 0, + b: 1, + c: 2 + }; + var key; + for (key in object) { + if (key == 'a') { + delete object.b; + object.d = 3; + } + yield key; + yield object[key]; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('a0c2',accumulate(forInGenerator2())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForInGenerator3.js b/packages/babel/test/fixtures/traceur/Yield/ForInGenerator3.js new file mode 100644 index 0000000000..093158bc11 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForInGenerator3.js @@ -0,0 +1,27 @@ +function* forInGenerator3() { + var object = { + a: 0, + b: { + c: 1, + }, + d: 2 + }; + for (var key in object) { + yield key; + for (var key2 in object[key]) { + yield key2; + } + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('abcd',accumulate(forInGenerator3())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForLexicallyNestedGenerator.js b/packages/babel/test/fixtures/traceur/Yield/ForLexicallyNestedGenerator.js new file mode 100644 index 0000000000..ec389c977c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForLexicallyNestedGenerator.js @@ -0,0 +1,15 @@ +function* forLexicallyNestedGenerator() { + yield* (function*() { yield [1,2,3]; yield* [4,5,6]; })(); +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('1,2,3456', accumulate(forLexicallyNestedGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForMissingParts.js b/packages/babel/test/fixtures/traceur/Yield/ForMissingParts.js new file mode 100644 index 0000000000..6ea2941738 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForMissingParts.js @@ -0,0 +1,95 @@ +function* f0() { + var x = 0; + for (;;) { + yield x++; + } +} + +function* f1() { + var x = 0; + for (; ; 1) { + yield x++; + } +} + +function* f2() { + var x = 0; + for (; 1; ) { + yield x++; + } +} + +function* f3() { + var x = 0; + for (; 1; 1) { + yield x++; + } +} + +function* f4() { + var x = 0; + for (1; ; ) { + yield x++; + } +} + +function* f5() { + var x = 0; + for (1; ; 1) { + yield x++; + } +} + +function* f6() { + var x = 0; + for (1; 1; ) { + yield x++; + } +} + +function* f7() { + var x = 0; + for (1; 1; 1) { + yield x++; + } +} + +var g0 = f0(); +assert.deepEqual(g0.next(), {value: 0, done: false}); +assert.deepEqual(g0.next(), {value: 1, done: false}); +assert.deepEqual(g0.next(), {value: 2, done: false}); + +var g1 = f1(); +assert.deepEqual(g1.next(), {value: 0, done: false}); +assert.deepEqual(g1.next(), {value: 1, done: false}); +assert.deepEqual(g1.next(), {value: 2, done: false}); + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 0, done: false}); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.next(), {value: 2, done: false}); + +var g3 = f3(); +assert.deepEqual(g3.next(), {value: 0, done: false}); +assert.deepEqual(g3.next(), {value: 1, done: false}); +assert.deepEqual(g3.next(), {value: 2, done: false}); + +var g4 = f4(); +assert.deepEqual(g4.next(), {value: 0, done: false}); +assert.deepEqual(g4.next(), {value: 1, done: false}); +assert.deepEqual(g4.next(), {value: 2, done: false}); + +var g5 = f5(); +assert.deepEqual(g5.next(), {value: 0, done: false}); +assert.deepEqual(g5.next(), {value: 1, done: false}); +assert.deepEqual(g5.next(), {value: 2, done: false}); + +var g6 = f6(); +assert.deepEqual(g6.next(), {value: 0, done: false}); +assert.deepEqual(g6.next(), {value: 1, done: false}); +assert.deepEqual(g6.next(), {value: 2, done: false}); + +var g7 = f7(); +assert.deepEqual(g7.next(), {value: 0, done: false}); +assert.deepEqual(g7.next(), {value: 1, done: false}); +assert.deepEqual(g7.next(), {value: 2, done: false}); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForOfGenerator.js b/packages/babel/test/fixtures/traceur/Yield/ForOfGenerator.js new file mode 100644 index 0000000000..94def9e357 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForOfGenerator.js @@ -0,0 +1,49 @@ +function* forEachGenerator() { + yield* forInGenerator3(); + yield* forInGenerator2(); +} + +function* forInGenerator3() { + var object = { + a: 0, + b: { + c: 1, + }, + d: 2 + }; + for (var key in object) { + yield key; + for (var key2 in object[key]) { + yield key2; + } + } +} + +function* forInGenerator2() { + var object = { + a: 0, + b: 1, + c: 2 + }; + var key; + for (key in object) { + if (key == 'a') { + delete object.b; + object.d = 3; + } + yield key; + yield object[key]; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('abcda0c2', accumulate(forEachGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForOfIteratorException.js b/packages/babel/test/fixtures/traceur/Yield/ForOfIteratorException.js new file mode 100644 index 0000000000..9d6c815e8f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForOfIteratorException.js @@ -0,0 +1,27 @@ +class Iterable { + constructor() { + this.returnCalled = false; + } + [Symbol.iterator]() { + return { + iterable: this, + next(v) { + throw "ex"; + }, + throw(e) { + throw e; + }, + return(v) { + this.iterable.returnCalled = true; + } + } + } +} + +var iterable = new Iterable(); +var i; +assert.throws(() => { + for (i of iterable) { + } +}, "ex"); +assert.isFalse(iterable.returnCalled); diff --git a/packages/babel/test/fixtures/traceur/Yield/ForStatement.js b/packages/babel/test/fixtures/traceur/Yield/ForStatement.js new file mode 100644 index 0000000000..08e2b1dbf5 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ForStatement.js @@ -0,0 +1,46 @@ +function* f() { + var x = 0; + for (yield 'init'; x < 3; x++) { + yield x; + } +} + +var g = f(); +assert.deepEqual(g.next(), {value: 'init', done: false}); +assert.deepEqual(g.next(), {value: 0, done: false}); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); + +function* f2() { + for (var x = 0; yield 'test'; x++) { + yield x; + } +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 'test', done: false}); +assert.deepEqual(g2.next(true), {value: 0, done: false}); +assert.deepEqual(g2.next(), {value: 'test', done: false}); +assert.deepEqual(g2.next(true), {value: 1, done: false}); +assert.deepEqual(g2.next(), {value: 'test', done: false}); +assert.deepEqual(g2.next(true), {value: 2, done: false}); +assert.deepEqual(g2.next(), {value: 'test', done: false}); +assert.deepEqual(g2.next(false), {value: undefined, done: true}); + +function* f3() { + for (var x = 0; x < 5; x = yield 'inc') { + yield x; + } +} + +var g3 = f3(); +assert.deepEqual(g3.next(), {value: 0, done: false}); +assert.deepEqual(g3.next(), {value: 'inc', done: false}); +assert.deepEqual(g3.next(2), {value: 2, done: false}); +assert.deepEqual(g3.next(), {value: 'inc', done: false}); +assert.deepEqual(g3.next(4), {value: 4, done: false}); +assert.deepEqual(g3.next(), {value: 'inc', done: false}); +assert.deepEqual(g3.next(1), {value: 1, done: false}); +assert.deepEqual(g3.next(), {value: 'inc', done: false}); +assert.deepEqual(g3.next(5), {value: undefined, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/FunctionDeclaration.js b/packages/babel/test/fixtures/traceur/Yield/FunctionDeclaration.js new file mode 100644 index 0000000000..2d0893d277 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/FunctionDeclaration.js @@ -0,0 +1,12 @@ +(function() { + + function* f() { + function g() { + return 42; + } + yield g; + } + + assert.equal(42, f().next().value()); + +})(); diff --git a/packages/babel/test/fixtures/traceur/Yield/GeneratorReturn.js b/packages/babel/test/fixtures/traceur/Yield/GeneratorReturn.js new file mode 100644 index 0000000000..b26d35f08e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/GeneratorReturn.js @@ -0,0 +1,86 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +//----------------------------------------------------------------------------- + +var g; + +function* G1() { + return 42; +} + +function* G2() { + return; +} + +function* G3() { + return undefined; +} + +function* G4() { + return 42; + yield 1000; +} + +function* G5() { + yield 1000; + return 42; +} + +function* G6() { + try { + yield 1000; + return 42; + yield 2000; + } catch(e) { + return 43; + } finally { + // TODO: Is 'return' allowed inside 'finally'? + // return 44; + } +} + +//---- + +function id(G) { + return G; +} + +function wrap(G) { + return function*() { + var r = yield* G(); + return r; + }; +} + +//---- + +var tests = [ + [G1, [], 42], + [G2, [], undefined], + [G3, [], undefined], + [G4, [], 42], + [G5, [1000], 42], + [G6, [1000], 42] +]; + +//----------------------------------------------------------------------------- + +[id, wrap].forEach((W) => { + + tests.forEach(([G, y, r]) => { + var g = W(G)(); + y.forEach((x) => assert.deepEqual({value: x, done: false}, g.next())); + + assert.deepEqual({value: r, done: true}, g.next()); + assertClosed(g); + }); + + //---- + + g = W(G6)(); + assert.deepEqual({value: 1000, done: false}, g.next()); + assert.deepEqual({value: 43, done: true}, g.throw()); + +}); diff --git a/packages/babel/test/fixtures/traceur/Yield/GeneratorSend.js b/packages/babel/test/fixtures/traceur/Yield/GeneratorSend.js new file mode 100644 index 0000000000..0c1dc743d7 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/GeneratorSend.js @@ -0,0 +1,232 @@ +function assertThrownEquals(x, func) { + var actualError; + try { + func(); + } catch (err) { + actualError = err; + } + assert.equal(x, actualError); +} + +//----------------------------------------------------------------------------- + +function id(G) { + return G; +} + +function wrap(G) { + return function* () { + yield* G(); + }; +} + +[id, wrap].forEach((W) => { // wrap_forEach + +//----------------------------------------------------------------------------- +// +// http://wiki.ecmascript.org/doku.php?id=harmony:generators +// +// G.[[Send]] +// +//     Let State = G.[[State]] +//     If State = “executing” Throw Error +//     If State = “closed” Throw Error +//     Let X be the first argument +//     If State = “newborn” +//         If X != undefined Throw TypeError +//         Let K = a new execution context as for a function call +//         K.currentGenerator := G +//         K.scopeChain := G.[[Scope]] +//         Push K onto the stack +//         Return Execute(G.[[Code]]) +//     G.[[State]] := “executing” +//     Let Result = Resume(G.[[ExecutionContext]], normal, X) +//     Return Result + +var g; + +//----------------------------------------------------------------------------- +// +//     If State = “executing” Throw Error + +function* G1() { + yield g.next(); +} + +g = W(G1)(); +// To be nitpicky, ionmonkey throws TypeError, and not Error. I'm not checking +// things quite that closely at this point in time. +assert.throw(() => g.next(), '"next" on executing generator'); + +//----------------------------------------------------------------------------- +// +//     If State = “closed” Throw Error + +// Note: ionmonkey continues to throw StopIteration for every 'next' on a +// closed generator, while harmony:generators seems to favor throwing it once +// only, at the point of generator exit, and throwing Error for all the +// following 'next' calls. + +function* G2() { + yield 1; +} + +var closeMethods = [ + (g) => assertThrownEquals(42, () => g.throw(42)), + (g) => { + assert.deepEqual({value: 1, done: false}, g.next()); + assert.deepEqual({value: undefined, done: true}, g.next()); + } +]; + +closeMethods.forEach((closeMethod) => { + g = W(G2)(); + closeMethod(g); + for (var i = 0; i < 8; i++) { + assert.deepEqual({value: undefined, done: true}, g.next()); + } +}); + +//----------------------------------------------------------------------------- +// +//     If State = “newborn” +//         If X != undefined Throw TypeError + +g = W(G2)(); +for (var i = 0; i < 8; i++) { + assert.throw(() => g.next(42), 'Sent value to newborn generator'); +} + +assert.deepEqual({value: 1, done: false}, g.next(undefined)); + + +//----------------------------------------------------------------------------- +// +//         Let K = a new execution context as for a function call +//         K.currentGenerator := G +//         K.scopeChain := G.[[Scope]] +//         Push K onto the stack +//         Return Execute(G.[[Code]]) + +// (see below) + +//----------------------------------------------------------------------------- +// +//     G.[[State]] := “executing” +//     Let Result = Resume(G.[[ExecutionContext]], normal, X) +//     Return Result + +// (see below) + +//----------------------------------------------------------------------------- + +// Example adapted from: +// https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Iterators_and_Generators +function* fib() { + var fn1 = 1; + var fn2 = 1; + var reset; + while (1) { + var current = fn2; + fn2 = fn1; + fn1 = fn1 + current; + reset = yield current; + if (reset) { + fn1 = 1; + fn2 = 1; + } + } +} + +// var +function* fibVar() { + var fn1 = 1; + var fn2 = 1; + while (1) { + var current = fn2; + fn2 = fn1; + fn1 = fn1 + current; + var reset = yield current; + if (reset) { + fn1 = 1; + fn2 = 1; + } + } +} + +// destructuring +function* fibD() { + var fn1 = 1; + var fn2 = 1; + var reset; + var tmp; + while (1) { + var current = fn2; + fn2 = fn1; + fn1 = fn1 + current; + [reset, tmp] = yield current; + assert.equal(reset, tmp); + if (reset) { + fn1 = 1; + fn2 = 1; + } + } +} + +// destructuring with var +function* fibVarD() { + var fn1 = 1; + var fn2 = 1; + var tmp; + while (1) { + var current = fn2; + fn2 = fn1; + fn1 = fn1 + current; + var [reset, tmp] = yield current; + assert.equal(reset, tmp); + if (reset) { + fn1 = 1; + fn2 = 1; + } + } +} + +function next(g) { + return g.next(); +} + +function send(g, v) { + return g.next(v); +} + +function nextD(g) { + return g.next([]); +} + +function sendD(g, v) { + return g.next([v, v]); +} + +function testfib(fibonacci, next, send) { + var sequence = fibonacci(); + assert.deepEqual({value: 1, done: false}, sequence.next()); + assert.deepEqual({value: 1, done: false}, next(sequence)); + assert.deepEqual({value: 2, done: false}, next(sequence)); + assert.deepEqual({value: 3, done: false}, next(sequence)); + assert.deepEqual({value: 5, done: false}, next(sequence)); + assert.deepEqual({value: 8, done: false}, next(sequence)); + assert.deepEqual({value: 13, done: false}, next(sequence)); + assert.deepEqual({value: 1, done: false}, send(sequence, true)); + assert.deepEqual({value: 1, done: false}, next(sequence)); + assert.deepEqual({value: 2, done: false}, next(sequence)); + assert.deepEqual({value: 3, done: false}, next(sequence)); +} + +//---- + +testfib(W(fib), next, send); +testfib(W(fibVar), next, send); +testfib(W(fibD), nextD, sendD); +testfib(W(fibVarD), nextD, sendD); + +}); // end wrap_forEach diff --git a/packages/babel/test/fixtures/traceur/Yield/GeneratorThrow.js b/packages/babel/test/fixtures/traceur/Yield/GeneratorThrow.js new file mode 100644 index 0000000000..e84edf95cc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/GeneratorThrow.js @@ -0,0 +1,153 @@ +function assertThrownEquals(x, func) { + var actualError; + try { + func(); + } catch (err) { + actualError = err; + } + assert.equal(x, actualError); +} + +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +//----------------------------------------------------------------------------- + +function id(G) { + return G; +} + +function wrap(G) { + return function* () { + yield* G(); + }; +} + +[id, wrap].forEach((W) => { // wrap_forEach + +//----------------------------------------------------------------------------- +// +// http://wiki.ecmascript.org/doku.php?id=harmony:generators +// +// G.[[Throw]] +// +//     Let State = G.[[State]] +//     If State = “executing” Throw Error +//     If State = “closed” Throw Error +//     Let X be the first argument +//     If State = “newborn” +//         G.[[State]] := “closed” +//         G.[[Code]] := null +//         Return (throw, X, null) +//     G.[[State]] := “executing” +//     Let Result = Resume(G.[[ExecutionContext]], throw, X) +//     Return Result + +var g; + +//----------------------------------------------------------------------------- +// +//     If State = “executing” Throw Error + +function* G1() { + yield g.throw(); +} +g = W(G1)(); +assert.throw(() => g.next(), '"throw" on executing generator'); + +//----------------------------------------------------------------------------- +// +//     If State = “closed” Throw Error + +function* G2() { + try { + yield 1; + yield 2; + } catch(e) { + yield '(' + e + ')'; + } + yield 3; +} + +// - calling throw() on a closed generator should throw an Error. +// - calling throw() on an ended generator should throw an Error. +// (this is the same as closed, really) + +var closeMethods = [ + (g) => { + assert.deepEqual({value: 1, done: false}, g.next()); + assert.deepEqual({value: '(22)', done: false}, g.throw(22)); + assert.deepEqual({value: 3, done: false}, g.next()); + assertThrownEquals(42, () => g.throw(42)); + }, + (g) => { + assert.deepEqual({value: 1, done: false}, g.next()); + assert.deepEqual({value: 2, done: false}, g.next()); + assert.deepEqual({value: 3, done: false}, g.next()); + assert.deepEqual({value: undefined, done: true}, g.next()); + } +]; + +closeMethods.forEach((closeMethod) => { + g = W(G2)(); + closeMethod(g); + for (var i = 0; i < 8; i++) { + assertThrownEquals(44, () => g.throw(44)); + } +}); + +//----------------------------------------------------------------------------- +// +//     Let X be the first argument +//     If State = “newborn” +//         G.[[State]] := “closed” +//         G.[[Code]] := null +//         Return (throw, X, null) + +g = W(G2)(); + +// calling throw(x) on a newborn generator should close the generator, and +// throw x back to the caller. +assertThrownEquals(44, () => g.throw(44)); +assertClosed(g); + +//----------------------------------------------------------------------------- +// +//     G.[[State]] := “executing” +//     Let Result = Resume(G.[[ExecutionContext]], throw, X) +//     Return Result + +g = W(G2)(); + +// calling throw(x) on a started generator should be the same as hot-replacing +// the last 'yield' with a 'throw x' and calling next() on that generator. So +// it could either throw an exception, or return a value, depending on the +// flow of control. +assert.deepEqual({value: 1, done: false}, g.next()); +assert.deepEqual({value: '(22)', done: false}, g.throw(22)); +assert.deepEqual({value: 3, done: false}, g.next()); + +assertThrownEquals(44, () => g.throw(44)); +assertClosed(g); + +//---- + +function* G3() { + try{ + yield 1; + yield 2; + yield 3; + } catch(e) {} +} + +g = W(G3)(); + +// Note: this behavior differs from ionmonkey, which throws 'undefined', and +// not StopIteration, but the StopIteration behavior better matches what I'd +// expect, given the description from the previous test. +assert.deepEqual({value: 1, done: false}, g.next()); +assert.deepEqual({value: undefined, done: true}, g.throw(44)); +assertClosed(g); + +}); // end wrap_forEach diff --git a/packages/babel/test/fixtures/traceur/Yield/GeneratorWithoutYieldOrReturn.js b/packages/babel/test/fixtures/traceur/Yield/GeneratorWithoutYieldOrReturn.js new file mode 100644 index 0000000000..ebfaf68da9 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/GeneratorWithoutYieldOrReturn.js @@ -0,0 +1,10 @@ +var x = 0; + +function* f() { + x++; +} + +var g = f(); +assert.equal(x, 0); +assert.deepEqual(g.next(), {done: true, value: undefined}); +assert.equal(x, 1); diff --git a/packages/babel/test/fixtures/traceur/Yield/Hoisting.js b/packages/babel/test/fixtures/traceur/Yield/Hoisting.js new file mode 100644 index 0000000000..5ccad05058 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Hoisting.js @@ -0,0 +1,13 @@ +// f is declared at the end to test hoisting. + +var g = f(); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); + +function* f() { + yield 1; +} + +function* f() { + yield 2; +} \ No newline at end of file diff --git a/packages/babel/test/fixtures/traceur/Yield/HoistingBlockbinding.js b/packages/babel/test/fixtures/traceur/Yield/HoistingBlockbinding.js new file mode 100644 index 0000000000..ffe0ac320c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/HoistingBlockbinding.js @@ -0,0 +1,21 @@ +// Options: --block-binding + +{ + function* f() { + yield 1; + } + + let g = f(); + assert.deepEqual(g.next(), {value: 1, done: false}); + assert.deepEqual(g.next(), {value: undefined, done: true}); +} + +{ + function* f() { + yield 1; + } + + let g = f(); + assert.deepEqual(g.next(), {value: 1, done: false}); + assert.deepEqual(g.next(), {value: undefined, done: true}); +} diff --git a/packages/babel/test/fixtures/traceur/Yield/IfGenerator.js b/packages/babel/test/fixtures/traceur/Yield/IfGenerator.js new file mode 100644 index 0000000000..43758965b3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/IfGenerator.js @@ -0,0 +1,26 @@ +function* ifGenerator(condition) { + if (condition) { + yield 1; + } + if (!condition) { + yield 2; + } + if (condition) { + yield 3; + } else { + yield 4; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('13', accumulate(ifGenerator(true))); +assert.equal('24', accumulate(ifGenerator(false))); diff --git a/packages/babel/test/fixtures/traceur/Yield/IfStatementWithYield.js b/packages/babel/test/fixtures/traceur/Yield/IfStatementWithYield.js new file mode 100644 index 0000000000..f5b5a8a192 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/IfStatementWithYield.js @@ -0,0 +1,14 @@ +function* f(x) { + if (yield x) { + return 2; + } + return 3; +} + +var g = f(1); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(true), {value: 2, done: true}); + +g = f(4); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(false), {value: 3, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/LabelledBlockGenerator.js b/packages/babel/test/fixtures/traceur/Yield/LabelledBlockGenerator.js new file mode 100644 index 0000000000..c79897f816 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/LabelledBlockGenerator.js @@ -0,0 +1,20 @@ +var i = 0; +var s = ''; + +function* f() { + s += 'a'; + while(i++ < 3) { + s += 'b'; + label1: { + s += 'c'; + break label1; + s += 'd'; + } + s += 'e'; + } + s += 'f'; +} + +var g = f(); +g.next(); +assert.equal(s, 'abcebcebcef'); diff --git a/packages/babel/test/fixtures/traceur/Yield/LabelledBreakGenerator.js b/packages/babel/test/fixtures/traceur/Yield/LabelledBreakGenerator.js new file mode 100644 index 0000000000..c656461fb4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/LabelledBreakGenerator.js @@ -0,0 +1,34 @@ +function* labelledBreakGenerator() { + var x = 1; + var y = 2; +label: + while (true) { + x++; + while (true) { + yield x * y; + y++; + if (y == 3) { + continue label; + } + yield x * y * 5; + if (y == 4) { + break label; + } + yield x * y * 13; + } + yield x * y * 11; + } + yield x * y * 7; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result += String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('496084', accumulate(labelledBreakGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/MapFilterGenerator.js b/packages/babel/test/fixtures/traceur/Yield/MapFilterGenerator.js new file mode 100644 index 0000000000..5ae3d9bb52 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/MapFilterGenerator.js @@ -0,0 +1,31 @@ +function mapFilterGenerator() { + function* map(list, fun) { + for (var item of list) { + yield fun(item); + } + } + function* filter(list, fun) { + for (var item of list) { + if (fun(item)) { + yield item; + } + } + } + // squares even numbers. no intermediate array is created. + var numbers = [1,2,3,4,5,6,7,8,9,10]; + return map( + filter(numbers, function(x) { return x % 2 == 0; }), + function(x) { return (x * x) + ','; }); +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('4,16,36,64,100,', accumulate(mapFilterGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/ObjectModel.js b/packages/babel/test/fixtures/traceur/Yield/ObjectModel.js new file mode 100644 index 0000000000..60638f6bf4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ObjectModel.js @@ -0,0 +1,41 @@ +// f is declared at the end to test hoisting. + +var GeneratorFunctionPrototype = f.__proto__; +var GeneratorFunction = GeneratorFunctionPrototype.constructor; + +assert.equal(GeneratorFunction.name, 'GeneratorFunction'); +assert.equal(GeneratorFunction.prototype, GeneratorFunctionPrototype); +assert.equal(GeneratorFunctionPrototype.prototype.constructor, + GeneratorFunctionPrototype); +assert.equal(GeneratorFunctionPrototype.prototype, f.prototype.__proto__); +assert.equal(GeneratorFunctionPrototype.__proto__, Function.prototype); + +var g = f(); +assert.instanceOf(g, f); + +assert.equal(g.__proto__, f.prototype); + +assert.deepEqual([], Object.getOwnPropertyNames(f.prototype)); +assert.deepEqual([], Object.getOwnPropertyNames(g)); + +f.prototype.x = 42; + +var g2 = f(); +assert.equal(g2.x, 42); + +var g3 = new f(); +assert.equal(g3.x, 42); + +function* f2() { + yield 1; +} + +assert.equal(f.__proto__, f2.__proto__); + +assert.isFalse(f.hasOwnProperty('constructor')); +assert.equal(f.__proto__.constructor.name, 'GeneratorFunction'); + +// Intentionally at the end to test hoisting. +function* f() { + yield this; +} diff --git a/packages/babel/test/fixtures/traceur/Yield/OverrideGenerator.js b/packages/babel/test/fixtures/traceur/Yield/OverrideGenerator.js new file mode 100644 index 0000000000..a897f02322 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/OverrideGenerator.js @@ -0,0 +1,14 @@ +function* f() { + yield 1; +} + +var f2 = f; + +f = 42; + +var g = f2(); + +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); + +assert.instanceOf(g, f2); diff --git a/packages/babel/test/fixtures/traceur/Yield/ReturnCatch.js b/packages/babel/test/fixtures/traceur/Yield/ReturnCatch.js new file mode 100644 index 0000000000..163fa4c2cc --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ReturnCatch.js @@ -0,0 +1,16 @@ +function* f () { + try { + yield 1; + } catch (e) { + f.x = 2; + } finally { + f.y = 3; + } +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.return(3), {value: 3, done: true}); +assert.equal(f.x, undefined); +assert.equal(f.y, 3); + diff --git a/packages/babel/test/fixtures/traceur/Yield/ReturnGenerator.js b/packages/babel/test/fixtures/traceur/Yield/ReturnGenerator.js new file mode 100644 index 0000000000..7c7d676868 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ReturnGenerator.js @@ -0,0 +1,227 @@ +function* f1() { + yield 1; + yield 2; +} + +var g1 = f1(); +assert.deepEqual(g1.next(), {value: 1, done: false}); +assert.deepEqual(g1.return(42), {value: 42, done: true}); +assert.deepEqual(g1.next(), {value: undefined, done: true}); + +function* f2() { + yield 1; + try { + yield 2; + } catch (e) { + return 3; + } +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.return(42), {value: 42, done: true}); +assert.deepEqual(g2.next(), {value: undefined, done: true}); + +function* f3() { + try { + yield 1; + } finally { + yield 2; + } +} + +var g3 = f3(); +assert.deepEqual(g3.next(), {value: 1, done: false}); +assert.deepEqual(g3.return(42), {value: 2, done: false}); +assert.deepEqual(g3.next(), {value: 42, done: true}); +assert.deepEqual(g3.next(), {value: undefined, done: true}); + +function* f4() { + var x = 9; + function *g() { + try { + yield 1; + yield 2; + } finally { + x = 10; + } + } + try { + yield* g(); + } finally { + yield x; + } +} + +var g4 = f4(); +assert.deepEqual(g4.next(), {value: 1, done: false}); +assert.deepEqual(g4.return(42), {value: 10, done: false}); +assert.deepEqual(g4.next(), {value: 42, done: true}); +assert.deepEqual(g4.next(), {value: undefined, done: true}); + +function* f5() { + try { + yield 1; + } finally { + return 2; + } +} + +var g5 = f5(); +assert.deepEqual(g5.next(), {value: 1, done: false}); +assert.deepEqual(g5.return(42), {value: 2, done: true}); +assert.deepEqual(g5.next(), {value: undefined, done: true}); + +function* f6() { + yield 1; +} + +var g6 = f6(); +assert.deepEqual(g6.return(42), {value: 42, done: true}); +assert.deepEqual(g6.next(), {value: undefined, done: true}); + +function* f7() { + return 1; +} + +var g7 = f7(); +assert.deepEqual(g7.next(), {value: 1, done: true}); +assert.deepEqual(g7.next(), {value: undefined, done: true}); +assert.deepEqual(g7.return(42), {value: 42, done: true}); +assert.deepEqual(g7.next(), {value: undefined, done: true}); + +function* f8() { + function* g() { + try { + yield 1; + yield 2; + } finally { + return 10; + } + } + yield* g(); +} + +var g8 = f8(); +assert.deepEqual(g8.next(), {value: 1, done: false}); +assert.deepEqual(g8.return(42), {value: 10, done: true}); +assert.deepEqual(g8.next(), {value: undefined, done: true}); + +function* f9() { + function* g() { + try { + yield 1; + yield 2; + } finally { + yield 3; + } + } + yield* g(); +} + +var g9 = f9(); +assert.deepEqual(g9.next(), {value: 1, done: false}); +assert.deepEqual(g9.return(142), {value: 3, done: false}); +assert.deepEqual(g9.next(), {value: undefined, done: true}); + +function* f10() { + try { + try { + yield 1; + } + finally { + try { + throw 2; + } catch (e) { + } + } + return 3; + } finally { + return 4; + } +} + +var g10 = f10(); +assert.deepEqual(g10.next(), {value: 1, done: false}); +assert.deepEqual(g10.return(42), {value: 4, done: true}); +assert.deepEqual(g10.next(), {value: undefined, done: true}); + +function* f11() { + function* g() { + try { + yield 1; + yield 2; + } finally { + yield 3333; + f11.x = 10; + yield 4; + } + } + yield* g(); + yield 5; +} + +var g11 = f11(); +assert.deepEqual(g11.next(), {value: 1, done: false}); +assert.deepEqual(g11.return(42), {value: 3333, done: false}); +assert.deepEqual(g11.next(), {value: 4, done: false}); +assert.deepEqual(g11.next(), {value: 5, done: false}); +assert.deepEqual(g11.next(), {value: undefined, done: true}); +assert.equal(f11.x, 10); + + +function* f12() { + try { + return 'apple'; + } finally { + yield 'orange'; + } +} +var g12 = f12(); +assert.deepEqual(g12.next(), {value: 'orange', done: false}); +assert.deepEqual(g12.next(), {value: 'apple', done: true}); + +function* f13() { + function* f() { + try { + yield 'pear'; + } finally { + yield 'strawberry'; + } + } + try { + return 'cherry'; + } finally { + f13.x = yield* f(); + yield 'banana'; + } +} +var g13 = f13(); +assert.deepEqual(g13.next(), {value: 'pear', done: false}); +assert.deepEqual(g13.return('peach'), {value: 'strawberry', done: false}); +assert.deepEqual(g13.next(), {value: 'banana', done: false}); +assert.deepEqual(g13.next(), {value: 'cherry', done: true}); +assert.equal(f13.x, 'peach'); + +function* f14() { + function* g() { + try { + yield 11; + yield 22; + } finally { + yield 33; + f14.x = 44; + yield 55; + } + } + return yield* g(); +} + +var g14 = f14(); +assert.deepEqual(g14.next(), {value: 11, done: false}); +assert.deepEqual(g14.return(43), {value: 33, done: false}); +assert.deepEqual(g14.next(), {value: 55, done: false}); +assert.equal(f14.x, 44); +assert.deepEqual(g14.next(), {value: 43, done: true}); +assert.deepEqual(g14.next(), {value: undefined, done: true}); + diff --git a/packages/babel/test/fixtures/traceur/Yield/ReturnInFinally.js b/packages/babel/test/fixtures/traceur/Yield/ReturnInFinally.js new file mode 100644 index 0000000000..fac9cb49db --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ReturnInFinally.js @@ -0,0 +1,33 @@ +function* f() { + try { + yield 1; + } finally { + return 2; + } + yield 3; + return 4; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: true}); + +function* f2() { + try { + yield 1 + } catch (ex) { + yield ex; + } finally { + return 2; + } + yield 3; +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.next(), {value: 2, done: true}); + +g2 = f2(); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.throw(42), {value: 42, done: false}); +assert.deepEqual(g2.next(), {value: 2, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/ReturnYield.js b/packages/babel/test/fixtures/traceur/Yield/ReturnYield.js new file mode 100644 index 0000000000..a349833743 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ReturnYield.js @@ -0,0 +1,55 @@ +function* f() { + return yield 1; +} + +var g = f(); + +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(2), {value: 2, done: true}); +function* f2() { + return (yield 3) + (yield 4); +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 3, done: false}); +assert.deepEqual(g2.next(5), {value: 4, done: false}); +assert.deepEqual(g2.next(6), {value: 11, done: true}); + + +function* f3() { + return (yield 7) || (yield 8); +} + +var g3 = f3(); +assert.deepEqual(g3.next(), {value: 7, done: false}); +assert.deepEqual(g3.next(9), {value: 9, done: true}); + +g3 = f3(); +assert.deepEqual(g3.next(), {value: 7, done: false}); +assert.deepEqual(g3.next(0), {value: 8, done: false}); +assert.deepEqual(g3.next(10), {value: 10, done: true}); + +function* f4() { + return (yield 11) && (yield 12); +} + +var g4 = f4(); +assert.deepEqual(g4.next(), {value: 11, done: false}); +assert.deepEqual(g4.next(0), {value: 0, done: true}); +g4 = f4(); +assert.deepEqual(g4.next(), {value: 11, done: false}); +assert.deepEqual(g4.next(13), {value: 12, done: false}); +assert.deepEqual(g4.next(14), {value: 14, done: true}); + +function* f5() { + return (yield 15) ? (yield 16) : (yield 17); +} + +var g5 = f5(); +assert.deepEqual(g5.next(), {value: 15, done: false}); +assert.deepEqual(g5.next(true), {value: 16, done: false}); +assert.deepEqual(g5.next(18), {value: 18, done: true}); +g5 = f5(); +assert.deepEqual(g5.next(), {value: 15, done: false}); +assert.deepEqual(g5.next(false), {value: 17, done: false}); +assert.deepEqual(g5.next(19), {value: 19, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/ReturnYieldFor.js b/packages/babel/test/fixtures/traceur/Yield/ReturnYieldFor.js new file mode 100644 index 0000000000..1448be3e23 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ReturnYieldFor.js @@ -0,0 +1,15 @@ +function* f() { + return yield* h(); +} + +function* h() { + yield 111; + yield 222; + return 333; +} + +var g = f(); + +assert.deepEqual({value: 111, done: false}, g.next()); +assert.deepEqual({value: 222, done: false}, g.next()); +assert.deepEqual({value: 333, done: true}, g.next()); diff --git a/packages/babel/test/fixtures/traceur/Yield/SequenceGenerator.js b/packages/babel/test/fixtures/traceur/Yield/SequenceGenerator.js new file mode 100644 index 0000000000..d895985767 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/SequenceGenerator.js @@ -0,0 +1,23 @@ +function* sequenceGenerator() { + var i = 1; + yield i; + i = 3; + yield i + 1; + { + var x = 3; + yield i + x; + yield x; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('1463', accumulate(sequenceGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/SimpleGenerator.js b/packages/babel/test/fixtures/traceur/Yield/SimpleGenerator.js new file mode 100644 index 0000000000..b865e12f0c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/SimpleGenerator.js @@ -0,0 +1,15 @@ +function* simpleGenerator() { + yield 1; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('1', accumulate(simpleGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/StatementTestGenerator.js b/packages/babel/test/fixtures/traceur/Yield/StatementTestGenerator.js new file mode 100644 index 0000000000..74105b412c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/StatementTestGenerator.js @@ -0,0 +1,37 @@ +// Options: --block-binding + +function* statementTestGenerator() { + // all of these statement constructs should be allowed + // provided that they contain no yield statements + switch (1) { + case 2: break; + default: break; + } + try { + } catch (e) {} + try { + } finally {} + do {} while (false); + for (;false;) {} + + //TODO(jmesserly): this had to be changed to "var" until we get BlockBindingTransformer + //for (let x in {}) {} + //for (let x of simpleGenerator()) {} + for (var x in {}) {} + for (var x of simpleGenerator()) {} + + if (false) {} else {} + //TODO(jmesserly): this had to be changed to "var" until we get BlockBindingTransformer + //{ let x = 1; } + { var x = 1; } + { const y = 2; } + + yield 1; +} + + +function* simpleGenerator() { + yield 1; +} + +// ---------------------------------------------------------------------------- diff --git a/packages/babel/test/fixtures/traceur/Yield/SwitchGenerator.js b/packages/babel/test/fixtures/traceur/Yield/SwitchGenerator.js new file mode 100644 index 0000000000..c516ec0131 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/SwitchGenerator.js @@ -0,0 +1,37 @@ +function* switchGenerator(val) { + switch (val) { + case 1: + yield val; + case 2: + yield val * 2; + break; + case 3: + break; + default: + yield val * 10; + } + + // switch without a default + switch (val) { + case 1000: + yield val; + break; + } + yield val * 5; +} + + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('125', accumulate(switchGenerator(1))); +assert.equal('410', accumulate(switchGenerator(2))); +assert.equal('15', accumulate(switchGenerator(3))); +assert.equal('4020', accumulate(switchGenerator(4))); diff --git a/packages/babel/test/fixtures/traceur/Yield/SwitchStatementWithYield.js b/packages/babel/test/fixtures/traceur/Yield/SwitchStatementWithYield.js new file mode 100644 index 0000000000..12affe930e --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/SwitchStatementWithYield.js @@ -0,0 +1,23 @@ +function* f(x) { + switch (yield x) { + case 1: + return 1; + case 2: + return 2; + default: + return 3; + } + throw new Error('Unreachable'); +} + +var g = f(1); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(2), {value: 2, done: true}); + +g = f(3); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(1), {value: 1, done: true}); + +var g = f(4); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(55), {value: 3, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/This.js b/packages/babel/test/fixtures/traceur/Yield/This.js new file mode 100644 index 0000000000..b17bea2b69 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/This.js @@ -0,0 +1,8 @@ +function* f() { + yield this; +} + +var o = {}; +for (var x of f.call(o)) { + assert.equal(o, x); +} diff --git a/packages/babel/test/fixtures/traceur/Yield/ThrowInCatch.js b/packages/babel/test/fixtures/traceur/Yield/ThrowInCatch.js new file mode 100644 index 0000000000..db2b1773b1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ThrowInCatch.js @@ -0,0 +1,15 @@ +function* f() { + try { + yield 1; + throw 'caught'; + } catch (e) { + throw 'ex'; + } finally { + f.x = 2; + } +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.next(), 'ex'); +assert.equal(f.x, 2); diff --git a/packages/babel/test/fixtures/traceur/Yield/ThrowInIterator.js b/packages/babel/test/fixtures/traceur/Yield/ThrowInIterator.js new file mode 100644 index 0000000000..618fcebba4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/ThrowInIterator.js @@ -0,0 +1,34 @@ +function* f() { + yield 1; + yield 2; + yield 3; +} + +function* f1() { + try { + yield* [4, 5, 6]; + } catch (ex) { + if (ex instanceof TypeError) { + yield 10; + } + } +} + +var g1 = f1(); +assert.deepEqual(g1.next(), {value: 4, done: false}); +assert.deepEqual(g1.throw(42), {value: 10, done: false}); +assert.deepEqual(g1.next(), {value: undefined, done: true}); + +function* f2() { + try { + yield* f(); + } catch (ex) { + yield ex; + } +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.throw(42), {value: 42, done: false}); +assert.deepEqual(g2.next(), {value: undefined, done: true}); + diff --git a/packages/babel/test/fixtures/traceur/Yield/Tree.js b/packages/babel/test/fixtures/traceur/Yield/Tree.js new file mode 100644 index 0000000000..6866802364 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Tree.js @@ -0,0 +1,73 @@ +// A binary tree class. +class Tree { + constructor(label, left, right) { + this.label = label; + this.left = left; + this.right = right; + } + *[Symbol.iterator]() { + if (this.left) { + yield* this.left; + } + yield this.label; + if (this.right) { + yield* this.right; + } + } +} + +// Create a Tree from a list. +function tree(list) { + var n = list.length; + if (n == 0) { + return null; + } + var i = Math.floor(n / 2); + return new Tree(list[i], tree(list.slice(0, i)), tree(list.slice(i + 1))); +} + +// A recursive generator that generates Tree labels in in-order. +function* inorder1(t) { + if (t) { + for (var x of inorder1(t.left)) { + yield x; + } + yield t.label; + for (var x of inorder1(t.right)) { + yield x; + } + } +} + +// A non-recursive generator. +function* inorder2(node) { + var stack = []; + while (node) { + while (node.left) { + stack.push(node); + node = node.left; + } + yield node.label; + while (!node.right && stack.length) { + node = stack.pop(); + yield node.label; + } + node = node.right; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +var alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'; +var root = tree(alphabet); +assert.equal(alphabet, accumulate(inorder1(root))); +assert.equal(alphabet, accumulate(inorder2(root))); +assert.equal(alphabet, accumulate(root)); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try.js b/packages/babel/test/fixtures/traceur/Yield/Try.js new file mode 100644 index 0000000000..bad1941f1f --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try.js @@ -0,0 +1,52 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +function* f() { + yield 1; + try { + yield 2; + yield 3; + } catch (ex) { + yield ex; + } + yield 4; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: 'ex', done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: 'ex', done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try10.js b/packages/babel/test/fixtures/traceur/Yield/Try10.js new file mode 100644 index 0000000000..d289a199d4 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try10.js @@ -0,0 +1,90 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x; + +function* f() { + x = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } catch (ex) { + yield 4 + ex; + } + yield 5; + } catch (ex) { + yield 6 + ex; + } finally { + x = 7 + } + yield x; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.throw('b'), {value: '6b', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 7); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try11.js b/packages/babel/test/fixtures/traceur/Yield/Try11.js new file mode 100644 index 0000000000..3b131f46b6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try11.js @@ -0,0 +1,106 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x, y; + +function* f() { + x = 0; + y = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } finally { + x = 4; + } + yield x; + } catch (ex) { + yield 5 + ex; + } finally { + y = 6 + } + yield y; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 6); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try12.js b/packages/babel/test/fixtures/traceur/Yield/Try12.js new file mode 100644 index 0000000000..edcb5e3506 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try12.js @@ -0,0 +1,111 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x, y; + +function* f() { + x = 0; + y = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } catch (ex) { + yield 4 + ex; + } finally { + x = 5; + } + yield x; + } catch (ex) { + yield 6 + ex; + } finally { + y = 7 + } + yield y; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.throw('b'), {value: '6b', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 7); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 7); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try2.js b/packages/babel/test/fixtures/traceur/Yield/Try2.js new file mode 100644 index 0000000000..f6ec973710 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try2.js @@ -0,0 +1,57 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x; + +function* f() { + x = 0; + yield 1; + try { + yield 2; + yield 3; + } finally { + x = 4; + } + yield x; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try3.js b/packages/babel/test/fixtures/traceur/Yield/Try3.js new file mode 100644 index 0000000000..ead1617dfd --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try3.js @@ -0,0 +1,56 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x; + +function* f() { + x = 0; + yield 1; + try { + yield 2; + yield 3; + } catch (ex) { + yield ex; + } finally { + x = 4; + } + yield x; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: 'ex', done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: 'ex', done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try4.js b/packages/babel/test/fixtures/traceur/Yield/Try4.js new file mode 100644 index 0000000000..72692a4f9c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try4.js @@ -0,0 +1,80 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +function* f() { + yield 1; + try { + yield 2; + try { + yield 3; + } catch (ex) { + yield 4 + ex; + } + yield 5; + } catch (ex) { + yield 6 + ex; + } + yield 7; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.throw('b'), {value: '6b', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try5.js b/packages/babel/test/fixtures/traceur/Yield/Try5.js new file mode 100644 index 0000000000..31ba02b0b8 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try5.js @@ -0,0 +1,95 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x; + +function* f() { + x = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } finally { + x = 4 + } + yield x; + } catch (ex) { + yield 5 + ex; + } + yield 6; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.throw('ex'), {value: '5ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 4); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try6.js b/packages/babel/test/fixtures/traceur/Yield/Try6.js new file mode 100644 index 0000000000..b5fa2e2b7c --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try6.js @@ -0,0 +1,74 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x; + +function* f() { + x = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } catch (ex) { + yield 4 + ex + } + yield 5; + } finally { + x = 6; + } + yield x; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 6); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try7.js b/packages/babel/test/fixtures/traceur/Yield/Try7.js new file mode 100644 index 0000000000..43bc6db414 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try7.js @@ -0,0 +1,78 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x, y; + +function* f() { + x = 0; + y = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } finally { + x = 4; + } + yield x; + } finally { + y = 5; + } + yield y; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assert.equal(x, 0); +assert.equal(y, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 4, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 4); +assert.equal(y, 5); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try8.js b/packages/babel/test/fixtures/traceur/Yield/Try8.js new file mode 100644 index 0000000000..19f9e621e3 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try8.js @@ -0,0 +1,83 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x, y; + +function* f() { + x = 0; + y = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } catch (ex) { + yield 4 + ex; + } finally { + x = 5; + } + yield x; + } finally { + y = 6; + } + yield y; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 6, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 6); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 5); +assert.equal(y, 6); diff --git a/packages/babel/test/fixtures/traceur/Yield/Try9.js b/packages/babel/test/fixtures/traceur/Yield/Try9.js new file mode 100644 index 0000000000..90677decc6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/Try9.js @@ -0,0 +1,90 @@ +function assertClosed(g) { + assert.deepEqual({value: undefined, done: true}, g.next()); +} + +var x; + +function* f() { + x = 0; + yield 1; + try { + yield 2; + try { + yield 3; + } catch (ex) { + yield 4 + ex; + } finally { + x = 5; + } + yield x; + } catch (ex) { + yield 6 + ex; + } + yield 7; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.throws(() => g.throw('ex')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.throws(() => g.throw('b')); +assertClosed(g); +assert.equal(x, 0); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.throw('ex'), {value: '4ex', done: false}); +assert.deepEqual(g.throw('b'), {value: '6b', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 5, done: false}); +assert.deepEqual(g.throw('ex'), {value: '6ex', done: false}); +assert.deepEqual(g.next(), {value: 7, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); +assertClosed(g); +assert.equal(x, 5); diff --git a/packages/babel/test/fixtures/traceur/Yield/TryCatchGenerator.js b/packages/babel/test/fixtures/traceur/Yield/TryCatchGenerator.js new file mode 100644 index 0000000000..2efd6c7076 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/TryCatchGenerator.js @@ -0,0 +1,153 @@ +function* tryCatchGenerator() { + var x; + try { + yield 1; + throw 2; + yield 3; + } catch (e) { + x = e; + } + yield x; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result += value; + } + return result; +} + +//----------------------------------------------------------------------------- + +function id(G) { + return G; +} + +function wrap(G) { + return function* () { + yield* G(); + }; +} + + +[id, wrap].forEach((W) => { // wrap_forEach + +// ---------------------------------------------------------------------------- + +assert.equal('12', accumulate(tryCatchGenerator())); + +// ---------------------------------------------------------------------------- + +function* throwGenerator() { + yield 1; + throw 2; + yield 3; +} + +function* throwFromCatchGenerator() { + try { + throw 1; + } catch(e) { + yield e; + throw 2; + yield 3; + } +} + +function* throwFromFinallyGenerator() { + try { + yield 1; + } finally { + throw 2; + } + yield 3; +} + +function accumulateCatch(iterator) { + var result = ''; + var i; + for (i = 0; i < 4; i++) { + try { + for (var value of iterator) { + result += value; + } + } catch(e) { + result += ' [' + e + ']'; + } + } + return result; +} + +function repeat(s, n) { + return Array(n + 1).join(s); +} + +// ---------------------------------------------------------------------------- + +assert.equal('1 [2]', accumulateCatch(W(throwGenerator)())); +assert.equal('1 [2]', accumulateCatch(W(throwFromCatchGenerator)())); +assert.equal('1 [2]', accumulateCatch(W(throwFromFinallyGenerator)())); + +// ---------------------------------------------------------------------------- + +// out-of-band info +var oob; + +function* throwOOBGen() { + try { + yield 1; + throw 2; + oob += 3; + } finally { + oob += 4; + } + oob += 5; + yield 6; +} + +function* throwOOB2xGen() { + try { + try { + yield 1; + throw 2; + oob += 3; + } finally { + oob += 4; + } + oob += 5; + yield 6; + } catch(e) { + yield 7 + '(' + e + ')'; + throw 8; + } finally { + oob += 9; + } +} + +function accumulateCatchOOB(iterator) { + var result = ''; + var i; + + for (i = 0; i < 4; i++) { + oob = ''; + try { + for (var value of iterator) { + result += value; + } + } catch(e) { + result += ' [' + e + ']'; + } finally { + result += ' <' + oob + '>'; + } + } + return result; +} + +// ---------------------------------------------------------------------------- + +var emptyResult = repeat(' <>', 3); +assert.equal('1 [2] <4>' + emptyResult, accumulateCatchOOB(W(throwOOBGen)())); +assert.equal('17(2) [8] <49>' + emptyResult, accumulateCatchOOB(W(throwOOB2xGen)())); + +}); // end wrap_forEach diff --git a/packages/babel/test/fixtures/traceur/Yield/TryCatchYieldGenerator.js b/packages/babel/test/fixtures/traceur/Yield/TryCatchYieldGenerator.js new file mode 100644 index 0000000000..ce631b33ca --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/TryCatchYieldGenerator.js @@ -0,0 +1,21 @@ +// yield form within a catch block +function* tryCatchYieldGenerator() { + var x = 3; + try { + throw 5; + } catch (e) { + yield e * x; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('15', accumulate(tryCatchYieldGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/TryFinallyGenerator.js b/packages/babel/test/fixtures/traceur/Yield/TryFinallyGenerator.js new file mode 100644 index 0000000000..b21b9bdacb --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/TryFinallyGenerator.js @@ -0,0 +1,39 @@ +function* tryFinallyGenerator() { + var x = 1; + var y; + + // finally inside a catch + try { + try { + yield x; + throw 7; + x = 2; + } finally { + x = 3; + } + } catch (e) { + y = e; + } + yield x * y; + + // finally with no enclosing try + try { + y = 11; + yield y; + } finally { + y = 3; + } + yield y; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('121113', accumulate(tryFinallyGenerator())); diff --git a/packages/babel/test/fixtures/traceur/Yield/WhileGenerator.js b/packages/babel/test/fixtures/traceur/Yield/WhileGenerator.js new file mode 100644 index 0000000000..c35e852381 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/WhileGenerator.js @@ -0,0 +1,25 @@ +function* whileGenerator(max, continueValue, breakValue) { + var i = 0; + while (i < max) { + i++; + if (i == continueValue) { + continue; + } + if (i == breakValue) { + break; + } + yield i; + } +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('13', accumulate(whileGenerator(10, 2, 4))); diff --git a/packages/babel/test/fixtures/traceur/Yield/WhileStatementWithYield.js b/packages/babel/test/fixtures/traceur/Yield/WhileStatementWithYield.js new file mode 100644 index 0000000000..a79c3127f0 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/WhileStatementWithYield.js @@ -0,0 +1,33 @@ +function* f() { + var x = 0; + while (yield 'test') { + yield x++; + } +} + +var g = f(); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(true), {value: 0, done: false}); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(true), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(true), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: 'test', done: false}); +assert.deepEqual(g.next(false), {value: undefined, done: true}); + +function* f2() { + var x = 0; + while ((yield 'a') || (yield 'b')) { + yield x++; + } +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 'a', done: false}); +assert.deepEqual(g2.next(true), {value: 0, done: false}); +assert.deepEqual(g2.next(), {value: 'a', done: false}); +assert.deepEqual(g2.next(false), {value: 'b', done: false}); +assert.deepEqual(g2.next(true), {value: 1, done: false}); +assert.deepEqual(g2.next(), {value: 'a', done: false}); +assert.deepEqual(g2.next(false), {value: 'b', done: false}); +assert.deepEqual(g2.next(false), {value: undefined, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/YieldAssignThrow.js b/packages/babel/test/fixtures/traceur/Yield/YieldAssignThrow.js new file mode 100644 index 0000000000..c9247d7619 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/YieldAssignThrow.js @@ -0,0 +1,18 @@ +function* f() { + var x; + try { + x = yield 1; + } catch (ex) { + yield ex; + } + return 2; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: true}); + +g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.throw(3), {value: 3, done: false}); +assert.deepEqual(g.next(), {value: 2, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/YieldIdentifier.js b/packages/babel/test/fixtures/traceur/Yield/YieldIdentifier.js new file mode 100644 index 0000000000..51143e7b71 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/YieldIdentifier.js @@ -0,0 +1,29 @@ +(function() { + + // ensure non strict mode. + function f() { return this; } + assert(f.call(undefined) !== undefined); + + var yield = 1; + assert.equal(yield, 1); + + function g(yield) { + return yield; + } + assert.equal(g(2), 2); + + var o = { + yield: yield + }; + assert.equal(o.yield, 1); + + var o2 = { + yield + }; + assert.equal(o.yield, 1); + + function h(yield) { + return yield * yield; + } + assert.equal(h(3), 9); +})(); diff --git a/packages/babel/test/fixtures/traceur/Yield/YieldInFinally.js b/packages/babel/test/fixtures/traceur/Yield/YieldInFinally.js new file mode 100644 index 0000000000..772a1fc630 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/YieldInFinally.js @@ -0,0 +1,41 @@ +var x; + +function* f() { + x = 0; + try { + x++; + } finally { + yield x++; + } + yield x++; +} + +var g = f(); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(), {value: 2, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: true}); + +function* f2() { + try { + yield 1 + } catch (ex) { + yield ex; + } finally { + yield 2; + } + yield 3; +} + +var g2 = f2(); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.next(), {value: 2, done: false}); +assert.deepEqual(g2.next(), {value: 3, done: false}); +assert.deepEqual(g2.next(), {value: undefined, done: true}); + +g2 = f2(); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.throw(42), {value: 42, done: false}); +assert.deepEqual(g2.next(), {value: 2, done: false}); +assert.deepEqual(g2.next(), {value: 3, done: false}); +assert.deepEqual(g2.next(), {value: undefined, done: true}); + diff --git a/packages/babel/test/fixtures/traceur/Yield/YieldNoExpression.js b/packages/babel/test/fixtures/traceur/Yield/YieldNoExpression.js new file mode 100644 index 0000000000..e5104b89c1 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/YieldNoExpression.js @@ -0,0 +1,19 @@ +function sum(x, y) { + return x + y; +} + +function* f() { + yield; + yield sum(yield, yield); + return yield; +} + +var g = f(42); + +assert.deepEqual(g.next(), {value: undefined, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: false}); +assert.deepEqual(g.next(3), {value: undefined, done: false}); +assert.deepEqual(g.next(39), {value: 42, done: false}); +assert.deepEqual(g.next(), {value: undefined, done: false}); +assert.deepEqual(g.next('abc'), {value: 'abc', done: true}); +assert.deepEqual(g.next(), {value: undefined, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/YieldUndefinedGenerator.js b/packages/babel/test/fixtures/traceur/Yield/YieldUndefinedGenerator.js new file mode 100644 index 0000000000..ce398ce020 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/YieldUndefinedGenerator.js @@ -0,0 +1,24 @@ +function* yieldUndefinedGenerator1() { + yield 1; + yield; + yield 2; +} + +function* yieldUndefinedGenerator2() { + yield 1; + yield undefined; + yield 2; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('1undefined2', accumulate(yieldUndefinedGenerator1())); +assert.equal('1undefined2', accumulate(yieldUndefinedGenerator2())); diff --git a/packages/babel/test/fixtures/traceur/Yield/YieldYield.js b/packages/babel/test/fixtures/traceur/Yield/YieldYield.js new file mode 100644 index 0000000000..1bddfe81a6 --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/YieldYield.js @@ -0,0 +1,19 @@ +function* f(x) { + yield (yield x); +} + +var g = f(1); +assert.deepEqual(g.next(), {value: 1, done: false}); +assert.deepEqual(g.next(2), {value: 2, done: false}); +assert.deepEqual(g.next(3), {value: undefined, done: true}); + +function* f2(x) { + yield* (yield x); +} + +g = f(1); +var g2 = f2(1); +assert.deepEqual(g2.next(), {value: 1, done: false}); +assert.deepEqual(g2.next(g), {value: 1, done: false}); +assert.deepEqual(g2.next(2), {value: 2, done: false}); +assert.deepEqual(g2.next(3), {value: undefined, done: true}); diff --git a/packages/babel/test/fixtures/traceur/Yield/tryFinallyFinallyGenerator.js b/packages/babel/test/fixtures/traceur/Yield/tryFinallyFinallyGenerator.js new file mode 100644 index 0000000000..d9dc2d096b --- /dev/null +++ b/packages/babel/test/fixtures/traceur/Yield/tryFinallyFinallyGenerator.js @@ -0,0 +1,29 @@ +// finally inside a try finally +function* tryFinallyFinallyGenerator() { + var y; + + try { + y = 13; + try { + yield y; + } finally { + y = 17; + } + yield y; + } finally { + y = 23; + } + yield y; +} + +function accumulate(iterator) { + var result = ''; + for (var value of iterator) { + result = result + String(value); + } + return result; +} + +// ---------------------------------------------------------------------------- + +assert.equal('131723', accumulate(tryFinallyFinallyGenerator())); diff --git a/packages/babel/test/traceur.js b/packages/babel/test/traceur.js index 740629fb1b..5a517b9187 100644 --- a/packages/babel/test/traceur.js +++ b/packages/babel/test/traceur.js @@ -6,29 +6,11 @@ require("./_transformation-helper").run("traceur", { // weird environmental issue make these hard to test "Modules", - // not supported - "ProperTailCalls", - // uses the old async generator proposal "AsyncGenerators", - - // these are all internal traceur tests or non-standard features - "ObjectMixin", - "Annotations", - "TestRunner", - "Tools", - "TempVarTransformer", - "AtScript", - "FreeVariableChecker", - "TypeAssertions", - "MemberVariables", - "Types" ], ignoreTasks: [ - // non-standard - "ObjectMixin", - // Node 0.10 doesn't like these "Symbol/Object", "Symbol/ObjectModel", @@ -52,9 +34,6 @@ require("./_transformation-helper").run("traceur", { // this tests pollutes Object.prototype which messes things up "StringExtras/StartsWith", - // TODO - "Syntax/IsValidSimpleAssignmentTarget", - // babel has no way to check these :( TODO: add to caveats "TemplateLiterals/TemplateObjectCaching.module", @@ -68,7 +47,6 @@ require("./_transformation-helper").run("traceur", { // these are the responsibility of core-js "Spread/Type", - "Symbol/Inherited", "Spread/NoIterator", "Destructuring/Rest", "Destructuring/Empty", @@ -90,10 +68,8 @@ require("./_transformation-helper").run("traceur", { "ArrayComprehension/Simple", "GeneratorComprehension/Simple", - // yield has been added as a keyword in ES6 + // TODO "Syntax/StrictKeywordsInPattern", - "Yield/YieldIdentifier", - "Syntax/StrictKeywords" ] }, { optional: ["es6.spec.symbols", "es6.spec.templateLiterals"], diff --git a/scripts/bootstrap.js b/scripts/bootstrap.js index b90eff3339..92aee9806f 100755 --- a/scripts/bootstrap.js +++ b/scripts/bootstrap.js @@ -42,5 +42,4 @@ packages.forEach(function (root) { cd("../.."); }); -exec("git submodule update --init"); exec("make build"); diff --git a/vendor/.babelrc b/vendor/.babelrc deleted file mode 100644 index 3a8f8eb911..0000000000 --- a/vendor/.babelrc +++ /dev/null @@ -1,3 +0,0 @@ -{ - "breakConfig": true -} diff --git a/vendor/traceur b/vendor/traceur deleted file mode 160000 index 554afd9fab..0000000000 --- a/vendor/traceur +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 554afd9fab75a149a2234ff6732f130e232f2ba0