function *hello() {
  yield 'hello';
  yield 'world';
}
var test = hello();
console.log(test.next().value)
console.log(test.next().value)

console.log(test.next().value)

function() {
  if(true) {
    var a = 1;
  }
}

function() {var a;
  if(true) {
    a = 1;
  }
}

{
  let a = 1;
}

(function() {
  let a = 1;
}).call(this);

let a = 1;

var a = 1;

const a = 1;

var a = 1;

class Test() {
  constructor(a) {
    this.a = a;
  }
  method() {
  }
  get data() {
    return this.a;
  }
}

function Test(a) {

  this.a = a;

  this.data = a;


}
Test.prototype.method = function() {
}

class Father() {
  constructor(a) {
    this.a = a;
  }
  method() {
    return this.a;
  }
}
class Child() {
  constructor(a) {
    super(a);
  }
  method() {
    return super.method();
  }
}

function Father(a) {

  this.a = a;

}
Father.prototype.method = function() {
  return this.a;
}
function Child(a) {

  Father.call(this, a);

}
Child.prototype.method = function() {
  return Father.prototype.method.call(this);
}
//这行以下为可阅读性多行写，本应附加在上面行末尾
;(function() {
  var prototype = Object.create(Father.prototype);
  prototype.constructor = Father;
  Child.prototype = prototype;
)();

function method(a, b = 1) {
}

function method(a, b) {if(typeof b == "undefined") b = 1;
}

function method(a, ...args) {
}

function method(a, args) {args = Array.prototype.slice.call(arguments, 1);
}

module {
  exports = {};
}

`template`

a(...b) -> a.apply(this, [].concat(b))

new a().b(...c)

class A {
        constructor() {
                console.log(new.target.name)
        }
}

class B extends A {}


new A // -> A
new B // -> B

new A(...this.xxx)

new (Function.prototype.bind.apply(A, [null].concat(function(){ this.xxx }()));

return {
  a,
  b
}

for(var a of fn()){}

new Cls(...args);

new (Function.prototype.bind.apply(Cls, $traceurRuntime.spread([null], args)))();

function test() {
  var fn = (a, b, c) => console.log(this, arguments, a, b, c);
  fn.call({name: "inner"}, 4, 5, 6);
}
test.call({name: "outer"}, 1, 2, 3);

// 实际应该输出
// {name: "outer"} [1, 2, 3] 4 5 6

// 你这个实现的输出
// {name: "inner"} [4, 5, 6] 4 5 6

var fn = (...arg) => console.log(arg);

class Test {
  method() {
    super()  // <- should throw syntax error here
  }
}