Improve yield support and restrict usage of strict

- Partially reverting 91cdb93e57 and eaf3911c31 and reimplement
- Add generators support for objects and classes
- Only classes can have static methods so restrict use of it

Special thanks to @rvanvelzen and @kzc for reviewing this patch and
providing constructive feedback over and over again.

test/compress/harmony.js

@@ -213,6 +213,23 @@ concise_methods_and_mangle_props: {
     }
 }
 
+concise_generators: {
+    input: {
+        x = {
+            *foo(a, b) {
+                return x;
+            }
+        }
+        y = {
+            *foo([{a}]) {
+                yield a;
+            },
+            bar(){}
+        }
+    }
+    expect_exact: "x={*foo(a,b){return x}};y={*foo([{a}]){yield a},bar(){}};"
+}
+
 concise_methods_and_keyword_names: {
     input: {
         x = {
@@ -295,6 +312,21 @@ class_name_can_be_preserved: {
     }
 }
 
+classes_can_have_generators: {
+    input: {
+        class Foo {
+            *bar() {}
+            static *baz() {}
+        }
+    }
+    expect: {
+        class Foo {
+            *bar() {}
+            static *baz() {}
+        }
+    }
+}
+
 new_target: {
     input: {
         new.target;
@@ -444,3 +476,83 @@ generators_yield_assign: {
     }
     expect_exact: "function*fn(){var x={};x.prop=yield 5}"
 }
+
+generator_yield_undefined: {
+    input: {
+        function* fn() {
+            yield;
+        }
+    }
+    expect_exact: "function*fn(){yield}"
+}
+
+yield_optimize_expression: {
+    options = {
+    }
+    input: {
+        function* f1() { yield; }
+        function* f2() { yield undefined; }
+        function* f3() { yield null; }
+        function* f4() { yield* undefined; }
+    }
+    expect: {
+        function* f1() { yield }
+        function* f2() { yield; }
+        function* f3() { yield null; }
+        function* f4() { yield* void 0; }
+    }
+}
+
+yield_statements: {
+    input: {
+        function* fn() {
+            var a = (yield 1) + (yield 2);
+            var b = (yield 3) === (yield 4);
+            var c = (yield 5) << (yield 6);
+            var d = yield 7;
+            var e = (yield 8) ? yield 9 : yield 10;
+            var f = -(yield 11);
+        }
+    }
+    expect_exact: "function*fn(){var a=(yield 1)+(yield 2);var b=(yield 3)===(yield 4);var c=(yield 5)<<(yield 6);var d=yield 7;var e=(yield 8)?yield 9:yield 10;var f=-(yield 11)}"
+}
+
+yield_as_identifier_in_function_in_generator: {
+    input: {
+        var g = function*() {
+            function h() {
+                yield = 1;
+            }
+        };
+    }
+    expect: {
+        var g = function*() {
+            function h() {
+                yield = 1;
+            }
+        };
+    }
+}
+
+yield_before_punctuators: {
+    input: {
+        iter = (function*() {
+            assignmentResult = [ x = yield ] = value;
+        })();
+        function* g1() { (yield) }
+        function* g2() { [yield] }
+        function* g3() { return {yield} } // Added return to avoid {} drop
+        function* g4() { yield, yield; }
+        function* g5() { (yield) ? yield : yield; }
+    }
+    expect: {
+        iter = (function*() {
+            assignmentResult = [ x = yield ] = value;
+        })();
+        function* g1() { (yield) }
+        function* g2() { [yield] }
+        function* g3() { return {yield} }
+        function* g4() { yield, yield; }
+        function* g5() { (yield) ? yield : yield; }
+    }
+}

test/mocha/object.js

@@ -0,0 +1,20 @@
+var Uglify = require("../../");
+var assert = require("assert");
+
+describe("Object", function() {
+    it ("Should allow objects to have a methodDefinition as property", function() {
+        var code = "var a = {test() {return true;}}";
+        assert.equal(Uglify.minify(code, {fromString: true}).code, "var a={test(){return!0}};");
+    });
+
+    it ("Should not allow objects to use static keywords like in classes", function() {
+        var code = "{static test() {}}";
+        var parse = function() {
+            Uglify.parse(code);
+        }
+        var expect = function(e) {
+            return e instanceof Uglify.JS_Parse_Error;
+        }
+        assert.throws(parse, expect);
+    });
+});

test/mocha/yield.js

@@ -0,0 +1,55 @@
+var UglifyJS = require("../../");
+var assert = require("assert");
+
+describe("Yield", function() {
+    it("Should not delete statements after yield", function() {
+        var js = 'function *foo(bar) { yield 1; yield 2; return 3; }';
+        var result = UglifyJS.minify(js, {fromString: true});
+        assert.strictEqual(result.code, 'function*foo(e){return yield 1,yield 2,3}');
+    });
+
+    it("Should not allow yield as labelIdentifier within generators", function() {
+        var js = "function* g() {yield: 1}"
+        var test = function() {
+            UglifyJS.parse(js);
+        }
+        var expect = function(e) {
+            return e instanceof UglifyJS.JS_Parse_Error &&
+                e.message === "Yield cannot be used as label inside generators";
+        }
+        assert.throws(test, expect);
+    });
+
+    it("Should not allow yield* followed by a newline in generators", function() {
+        var js = "function* test() {yield*\n123;}";
+        var test = function() {
+            UglifyJS.parse(js);
+        }
+        var expect = function(e) {
+            return e instanceof UglifyJS.JS_Parse_Error &&
+                e.message === "Unexpected token: operator (*)";
+        }
+        assert.throws(test, expect);
+    });
+
+    it("Should be able to compress its expression", function() {
+        assert.strictEqual(
+            UglifyJS.minify("function *f() { yield 3-4; }", {fromString: true, compress: true}).code,
+            "function*f(){yield-1}"
+        );
+    });
+
+    it("Should keep undefined after yield without compression if found in ast", function() {
+        assert.strictEqual(
+            UglifyJS.minify("function *f() { yield undefined; yield; yield* undefined; yield void 0}", {fromString: true, compress: false}).code,
+            "function*f(){yield undefined;yield;yield*undefined;yield void 0}"
+        );
+    });
+
+    it("Should be able to drop undefined after yield if necessary with compression", function() {
+        assert.strictEqual(
+            UglifyJS.minify("function *f() { yield undefined; yield; yield* undefined; yield void 0}", {fromString: true, compress: true}).code,
+            "function*f(){yield,yield,yield*void 0,yield}"
+        );
+    });
+});

test/parser.js

@@ -128,7 +128,7 @@ module.exports = function () {
     });
 
     var generators_yield_def = UglifyJS.parse('function* fn() {\nyield remote();\}').body[0].body[0];
-    ok.equal(generators_yield_def.body.operator, 'yield');
+    ok.strictEqual(generators_yield_def.body.is_star, false);
 }
 
 // Run standalone