add traceur test suite

test/_helper.js

@@ -3,7 +3,7 @@ var fs   = require("fs");
 var _    = require("lodash");
 
 var humanise = function (val) {
-  return val.replace(/-/g, " ");
+  return path.basename(val, path.extname(val)).replace(/-/g, " ");
 };
 
 var readFile = exports.readFile = function (filename) {
@@ -36,8 +36,18 @@ exports.get = function (entryName) {
     var suiteOptsLoc = suite.filename + "/options.json";
     if (fs.existsSync(suiteOptsLoc)) suite.options = require(suiteOptsLoc);
 
-    _.each(fs.readdirSync(suite.filename), function (taskName) {
-      var taskDir = suite.filename + "/" + taskName;
+    if (fs.statSync(suite.filename).isFile()) {
+      push(suiteName, suite.filename);
+    } else {
+      _.each(fs.readdirSync(suite.filename), function (taskName) {
+        var taskDir = suite.filename + "/" + taskName;
+        push(taskName, taskDir);
+      });
+    }
+
+    function push(taskName, taskDir) {
+      // tracuer error tests
+      if (taskName.indexOf("Error_") === 0) return;
 
       var actualLocAlias = suiteName + "/" + taskName + "/actual.js";
       var expectLocAlias = suiteName + "/" + taskName + "/expected.js";
@@ -49,7 +59,7 @@ exports.get = function (entryName) {
 
       if (fs.statSync(taskDir).isFile()) {
         var ext = path.extname(taskDir);
-        if (ext !== ".js") return;
+        if (ext !== ".js" && ext !== ".module.js") return;
 
         execLoc = taskDir;
       }
@@ -84,6 +94,18 @@ exports.get = function (entryName) {
         }
       };
 
+      // traceur checks
+
+      var shouldSkip = function (code) {
+        return code.indexOf("// Error:") === 0 || code.indexOf("// Skip.") === 0;
+      };
+
+      if (shouldSkip(test.actual.code) || shouldSkip(test.exec.code)) {
+        return;
+      } else if (test.exec.code.indexOf("// Async.")) {
+        //test.options.asyncExec = true;
+      }
+
       suite.tests.push(test);
 
       var sourceMappingsLoc = taskDir + "/source-mappings.json";
@@ -97,7 +119,7 @@ exports.get = function (entryName) {
         test.options.sourceMap = true;
         test.sourceMap = require(sourceMap);
       }
-    });
+    }
   });
 
   return exports.cache[entryName] = suites;

test/_transformation-helper.js

@@ -0,0 +1,123 @@
+var genHelpers = require("./_generator-helpers");
+var transform  = require("../lib/6to5/transformation/transform");
+var sourceMap  = require("source-map");
+var Module     = require("module");
+var helper     = require("./_helper");
+var assert     = require("assert");
+var chai       = require("chai");
+var path       = require("path");
+var util       = require("../lib/6to5/util");
+var _          = require("lodash");
+
+require("../lib/6to5/polyfill");
+
+global.assertNoOwnProperties = function (obj) {
+  assert.equal(Object.getOwnPropertyNames(obj).length, 0);
+};
+
+global.assertArrayEquals = assert.deepEqual;
+global.assert = chai.assert;
+global.chai = chai;
+global.genHelpers = genHelpers;
+
+var run = function (task, done) {
+  var actual = task.actual;
+  var expect = task.expect;
+  var exec   = task.exec;
+  var opts   = task.options;
+
+  var getOpts = function (self) {
+    return _.merge({
+      filename: self.loc
+    }, opts);
+  };
+
+  var execCode = exec.code;
+  var result;
+
+  if (execCode) {
+    result = transform(execCode, getOpts(exec));
+    execCode = result.code;
+
+    try {
+      var requireRelative;
+      if (opts.emulateNodeModule) {
+        var mod = new Module(exec.loc);
+        requireRelative = function (loc) {
+          return mod.require(loc);
+        };
+      }
+
+      var fn = new Function("require", "done", execCode);
+      fn(requireRelative, chai.assert, done);
+    } catch (err) {
+      err.message = exec.loc + ": " + err.message;
+      err.message += util.codeFrame(execCode);
+      throw err;
+    }
+  }
+
+  var actualCode = actual.code;
+  var expectCode = expect.code;
+  if (!execCode || actualCode) {
+    result     = transform(actualCode, getOpts(actual));
+    actualCode = result.code;
+
+    chai.expect(actualCode).to.be.equal(expectCode, actual.loc + " !== " + expect.loc);
+  }
+
+  if (task.sourceMap) {
+    chai.expect(result.map).to.deep.equal(task.sourceMap);
+  }
+
+  if (task.sourceMappings) {
+    var consumer = new sourceMap.SourceMapConsumer(result.map);
+
+    _.each(task.sourceMappings, function (mapping, i) {
+      var expect = mapping.original;
+
+      var actual = consumer.originalPositionFor(mapping.generated);
+      chai.expect({ line: actual.line, column: actual.column }).to.deep.equal(expect);
+    });
+  }
+};
+
+module.exports = function (name, opts) {
+  _.each(helper.get(name), function (testSuite) {
+    suite(name + "/" + testSuite.title, function () {
+      _.each(testSuite.tests, function (task) {
+        var runTest = function (done) {
+          var runTask = function () {
+            run(task, done);
+          };
+
+          _.defaults(task.options, opts);
+
+          var throwMsg = task.options.throws;
+          if (throwMsg) {
+            // internal api doesn't have this option but it's best not to pollute
+            // the options object with useless options
+            delete task.options.throws;
+
+            assert.throws(runTask, function (err) {
+              return err.message.indexOf(throwMsg) >= 0;
+            });
+          } else {
+            runTask();
+          }
+        };
+
+        var callback;
+        if (task.options.asyncExec) {
+          callback = runTest;
+        } else {
+          callback = function () {
+            return runTest();
+          };
+        }
+
+        test(task.title, !task.disabled && callback);
+      });
+    });
+  });
+};

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);

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]());

test/fixtures/traceur/ArrayComprehension/Error_Disabled.js

@@ -0,0 +1,4 @@
+// Options: --array-comprehension=false
+// Error: :4:14: Unexpected token for
+
+var array = [for (x of [0, 1, 2, 3, 4]) x];

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;

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);

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);

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);

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);

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);

test/fixtures/traceur/ArrayExtras/From.js

@@ -0,0 +1,155 @@
+// 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) {
+    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) {
+    constructorCounter++;
+    assert.equal(v, 2);
+  }
+};
+MyArray2.prototype[Symbol.iterator] = undefined;
+
+class MyArray3 extends Array {
+  constructor(v) {
+    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, 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);

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);

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']]);

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);

test/fixtures/traceur/ArrowFunctions/Arguments.js

@@ -0,0 +1,6 @@
+function f() {
+  var args = (() => arguments)();
+  assert.equal(args, arguments);
+}
+
+f();

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);

test/fixtures/traceur/ArrowFunctions/CoverInitializer.js

@@ -0,0 +1,5 @@
+// https://github.com/google/traceur-compiler/issues/478
+
+function f() {
+  (1 ? ({a=0}) => {} : 1);
+}

test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer.js

@@ -0,0 +1,5 @@
+// Error: :4:16: Unexpected token =
+
+function f() {
+  ({a = (0, {a = 0})} = {})
+}

test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer2.js

@@ -0,0 +1,3 @@
+// Error: :3:5: Unexpected token =
+
+({a = 0});

test/fixtures/traceur/ArrowFunctions/Error_CoverInitializer3.js

@@ -0,0 +1,3 @@
+// Error: :3:18: Unexpected token =
+
+var f = ({x = {y = 1}) => 2;

test/fixtures/traceur/ArrowFunctions/Error_Disabled.js

@@ -0,0 +1,4 @@
+// Options: --arrow-functions=false
+// Error: :4:21: Unexpected token >
+
+var identity = (x) => x;

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;

test/fixtures/traceur/ArrowFunctions/Error_InvalidFormalParameters.js

@@ -0,0 +1,3 @@
+// Error: :3:15: Unexpected token +
+
+var f = (a, b + 5) => a + b;

test/fixtures/traceur/ArrowFunctions/Error_Precedence.js

@@ -0,0 +1,3 @@
+// Error: :3:26: Semi-colon expected
+
+var identity = (x) => {x}.bind({});

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;

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;

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;
+}

test/fixtures/traceur/ArrowFunctions/Error_SpreadOutsideFormals.js

@@ -0,0 +1,3 @@
+// Error: :3:13: Unexpected token ...
+
+var f = (x, ...xs);

test/fixtures/traceur/ArrowFunctions/FreeVariableChecker.js

@@ -0,0 +1,2 @@
+var identity = (identityParam) => identityParam;
+assert.equal(1234, identity(1234));

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);

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) -> {...};

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);

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);
+

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);

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);

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);

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);

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();

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();

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);

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();
+})();

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();
+})();

test/fixtures/traceur/AsyncFunctions/Empty.js

@@ -0,0 +1,10 @@
+// Options: --async-functions
+// Async.
+
+async function empty() {
+}
+
+empty().then((v) => {
+  assert.isUndefined(v);
+  done();
+});

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;

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;

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);
+})();

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();
+})();

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);

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();

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();

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);

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();
+});

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();
+})();

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();
+})();

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();
+})();

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();
+})();

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();
+})();

test/fixtures/traceur/AsyncFunctions/resources/async-function.js

@@ -0,0 +1,7 @@
+export async function asyncFunction() {
+  return 1;
+}
+
+export default async function() {
+  return 2;
+};

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);

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);

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);
+}

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);

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);

test/fixtures/traceur/Classes/ConstructorMember.js

@@ -0,0 +1,25 @@
+class ConstructorMember {
+  constructor() {}
+}
+
+class DerivedConstructorMember extends ConstructorMember {
+  constructor() {}
+}
+
+// ----------------------------------------------------------------------------
+
+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);
+}

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);

test/fixtures/traceur/Classes/DeriveFromObject.js

@@ -0,0 +1,6 @@
+class DerivedFromObject extends Object {
+}
+
+// ----------------------------------------------------------------------------
+
+// TODO(rnystrom): No tests for this?

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);

test/fixtures/traceur/Classes/Error_Disabled.js

@@ -0,0 +1,4 @@
+// Options: --classes=false
+// Error: :4:1: Unexpected reserved word
+
+class C {}

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 {}

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;
+  }
+}
+

test/fixtures/traceur/Classes/Error_SuperAsTemplateTag.js

@@ -0,0 +1,10 @@
+// Error: :7:18: Unexpected token no substitution template
+
+class A {}
+
+class ImproperSuper extends A {
+  method() {
+    return super ``;
+  }
+}
+

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');

test/fixtures/traceur/Classes/ExtendObject.js

@@ -0,0 +1,4 @@
+// Can no longer extend objects.
+assert.throw(function() {
+  class C extends {} {}
+}, TypeError);

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);

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'));

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);
+}

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());

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);

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);

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);

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');

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());

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());

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.isTrue(keys.indexOf('answer') !== -1);
+assert.isTrue(keys.indexOf('constructor') === -1);
+
+for (var key in Universe) {
+  fail('Universe contains static member : ' + key);
+}

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');

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());

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));

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);

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; }
+    }
+    this.a = new Koala(n + ' II');
+
+    super(n);
+    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);

test/fixtures/traceur/Classes/NestedFunctionSuper.js

@@ -0,0 +1,76 @@
+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 (function() {
+      return super.m();
+    })();
+  }
+  superX() {
+    return (function() {
+      return super.x;
+    })();
+  }
+  superX2() {
+    return (function() {
+      return (function() {
+        return super.x;
+      })();
+    })();
+  }
+  superX2F() {
+    return function() {
+      return (function() {
+        return super.x;
+      })();
+    };
+  }
+  get superXprop() {
+    return (function() {
+      return super.x;
+    })();
+  }
+  set superXprop(v) {
+    return (function() {
+      super.x = v;
+    })();
+  }
+  constructor() {
+    this.x = 10;
+    this.derC = 3;
+    (function() { super(); })();
+  }
+}
+
+// ----------------------------------------------------------------------------
+
+var obj = new SuperDerived();
+assert.equal(41, obj.m());
+assert.equal(40, obj.superM());
+
+assert.equal(4, obj.baseX);
+assert.equal(4, obj.x);
+assert.equal(4, obj.superX());
+assert.equal(4, obj.superX2());
+assert.equal(4, obj.superX2F()());
+assert.equal(4, obj.superXprop);
+
+obj.superXprop = 5;
+assert.equal(5, obj.baseX);
+assert.equal(5, obj.x);
+assert.equal(5, obj.superX());
+assert.equal(5, obj.superX2());
+assert.equal(5, obj.superX2F()());
+assert.equal(5, obj.superXprop);
+
+assert.equal(2, obj.baseC);
+assert.equal(3, obj.derC);

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');

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);

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);

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);

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));
+

test/fixtures/traceur/Classes/SemiColon.js

@@ -0,0 +1,3 @@
+class SemiColon {
+  ;
+}

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() {
+    this.x = 10;
+    this.derC = 3;
+    super();
+  }
+}
+
+// ----------------------------------------------------------------------------
+
+var obj = new SuperDerived();
+assert.equal(41, obj.m());
+assert.equal(40, obj.superM());
+assert.equal(4, obj.baseX);
+assert.equal(4, obj.x);
+assert.equal(4, obj.superX());
+assert.equal(2, obj.baseC);
+assert.equal(3, obj.derC);

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.

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);