[es6] implement default parameters via desugaring

test/mjsunit/harmony/optional-arguments.js

Index: test/mjsunit/harmony/optional-arguments.js
diff --git a/test/mjsunit/harmony/optional-arguments.js b/test/mjsunit/harmony/optional-arguments.js
new file mode 100644
index 0000000000000000000000000000000000000000..39580b217f4a2deba11b7e44b241b0f3f7dcc594
--- /dev/null
+++ b/test/mjsunit/harmony/optional-arguments.js
@@ -0,0 +1,72 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --harmony-optional-params
+
+function return_specified() { return "specified"; }
+
+var method_returns_specified = {
+  method() { return "specified"; }
+};
+
+
+(function testOptionalFunctions() {
+  function optional_function(handler = function() { }) {
+    assertEquals("function", typeof handler);
+
+    // TODO(caitp): infer function name correctly
+    // (https://code.google.com/p/v8/issues/detail?id=3699)
+    // assertEquals("handler", handler.name);
+
+    return handler();
+  }
+  assertEquals(undefined, optional_function());
+  assertEquals(undefined, optional_function(undefined));
+  assertEquals("specified", optional_function(return_specified));
+})();
+
+
+(function testOptionalObjects() {
+  function optional_object(object = { method() { return "method"; } }) {
+    assertEquals("object", typeof object);
+
+    assertEquals("function", typeof object.method);
+    return object.method();
+  }
+
+  assertEquals("method", optional_object());
+  assertEquals("method", optional_object(undefined));
+  assertEquals("specified", optional_object(method_returns_specified));
+})();
+
+
+// TDZ
+
+(function testReferencesUninitializedParameter(x = 1) {
+  assertThrows(function(a = b, b) {}, ReferenceError);
+})();
+
+
+(function testReferencesInitializedParameter(x = 1) {
+  assertEquals(1, (function(a = 1, b = a) { return b; })());
+})();
+
+

[rossberg, 2015/05/12 14:04:53]

More tests, e.g.:

- (function(x = this) { return x }).call(o) === o
- (function(x = () => this) { return x() }).call(o) === o
- (function f(x, y = f) { return x ? y(false) + 1 : 0 })(true) === 1
- (function(x, y = function() { return x }) { return y() })(7) === 7
- (function(x = function() { return y }, y) { return x() })(8) === 8
- (function(x, y = eval("x")) { let x; return y })(7) === 7
- (function(x = eval("y"), y = 0) {})() throws
- (function(x, y = () => eval("x")) { let x; return y() })(7) === 7
- (function(x = () => eval("y"), y = 9) { let y; return x() })() === 9
- (function(x = {a: 4}) { return x.a })() === 4
- (function(x, y = {a: x}) { return y.a })(5) === 5
- a function large enough to trigger lazy parsing

[caitp (gmail), 2015/05/12 18:35:35]

Added eval and arrow variants to a bunch of these tests --- something is very
broken with the TDZ behaviour when "eval" is used, I'm not sure if this affects
normal lexical variables or not. If it does I'll file a bug

[rossberg, 2015/05/20 07:41:47]

Please add a couple of lazy parsing tests as well (you need to write global
functions with >2K characters size; long dummy comments are good enough to
achieve that).
How do these cases fail? If it is due to a deeper bug then it should be
possible to create a JS test in desugared form that exhibits it. If not, then
s.th likely is wrong with the scope handling in this CL, and probably should be
fixed before landing.

[caitp (gmail), 2015/05/20 11:29:38]

I wasn't able to reproduce it with the regular desugaring, so it does seem to be
a scoping bug. I can't remember exactly what the failures were, but eval("param
name") returned something weird (I think it was returning the global object,
which it probably got from the receiver on the stack).

After rebasing I'll check

+// Scoping
+//
+// TODO(caitp): fix scoping --- var declarations in function body can't be
+// resolved in formal parameters
+// assertThrows(function referencesVariableBodyDeclaration(a = body_var) {
+//   var body_var = true;
+//   return a;
+// }, ReferenceError);
+
+
+// TODO(caitp): default function length does not include any parameters
+// following the first optional parameter
+// assertEquals(0, (function(a = 1) {}).length);
+// assertEquals(1, (function(a, b = 1) {}).length);
+// assertEquals(2, (function(a, b, c = 1) {}).length);
+// assertEquals(3, (function(a, b, c, d = 1) {}).length);
+// assertEquals(1, (function(a, b = 1, c, d = 1) {}).length);