ES6: Classes: Early return in sub-class constructor results in returning undefined...
authorjoepeck@webkit.org <joepeck@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 25 Mar 2015 01:18:18 +0000 (01:18 +0000)
committerjoepeck@webkit.org <joepeck@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 25 Mar 2015 01:18:18 +0000 (01:18 +0000)
https://bugs.webkit.org/show_bug.cgi?id=143012

Reviewed by Ryosuke Niwa.

Source/JavaScriptCore:

* bytecompiler/BytecodeGenerator.cpp:
(JSC::BytecodeGenerator::emitReturn):
Fix handling of "undefined" when returned from a Derived class. It was
returning "undefined" when it should have returned "this".

LayoutTests:

* js/class-constructor-return-expected.txt: Added.
* js/class-constructor-return.html: Added.
* js/script-tests/class-constructor-return.js: Added.
New test covering different return values from constructors.

* js/class-syntax-super-expected.txt:
* js/script-tests/class-syntax-super.js:
Fix test. Returning undefined is the same as an implicit return
and should return `this`.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@181924 268f45cc-cd09-0410-ab3c-d52691b4dbfc

LayoutTests/ChangeLog
LayoutTests/js/class-constructor-return-expected.txt [new file with mode: 0644]
LayoutTests/js/class-constructor-return.html [new file with mode: 0644]
LayoutTests/js/class-syntax-super-expected.txt
LayoutTests/js/script-tests/class-constructor-return.js [new file with mode: 0644]
LayoutTests/js/script-tests/class-syntax-super.js
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

index 71482ddb95bfc750d13fae800f0f6b74dd404b4b..9a06b2c2cdaed28773cb620b6a989884b6ad2345 100644 (file)
@@ -1,3 +1,20 @@
+2015-03-24  Joseph Pecoraro  <pecoraro@apple.com>
+
+        ES6: Classes: Early return in sub-class constructor results in returning undefined instead of instance
+        https://bugs.webkit.org/show_bug.cgi?id=143012
+
+        Reviewed by Ryosuke Niwa.
+
+        * js/class-constructor-return-expected.txt: Added.
+        * js/class-constructor-return.html: Added.
+        * js/script-tests/class-constructor-return.js: Added.
+        New test covering different return values from constructors.
+
+        * js/class-syntax-super-expected.txt:
+        * js/script-tests/class-syntax-super.js:
+        Fix test. Returning undefined is the same as an implicit return
+        and should return `this`.
+
 2015-03-24  Chris Dumez  <cdumez@apple.com>
 
         [WK2] Responses with 204 HTTP Status Code should be cacheable by default
diff --git a/LayoutTests/js/class-constructor-return-expected.txt b/LayoutTests/js/class-constructor-return-expected.txt
new file mode 100644 (file)
index 0000000..b892acc
--- /dev/null
@@ -0,0 +1,95 @@
+Tests for ES6 class constructor return values
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+Base class
+PASS (new BaseNoReturn) instanceof BaseNoReturn is true
+PASS (new BaseReturnImplicit) instanceof BaseReturnImplicit is true
+PASS (new BaseReturnImplicit) !== undefined is true
+PASS (new BaseReturnUndefined) instanceof BaseReturnUndefined is true
+PASS (new BaseReturnUndefined) !== undefined is true
+PASS (new BaseReturnThis) instanceof BaseReturnThis is true
+PASS (new BaseReturnObject) instanceof BaseReturnObject is false
+PASS typeof (new BaseReturnObject) === "object" is true
+PASS (new BaseReturnObject2) instanceof BaseReturnObject is false
+PASS (new BaseReturnObject2) === globalVariable is true
+PASS (new BaseReturnString) instanceof BaseReturnString is true
+PASS typeof (new BaseReturnString) !== "string" is true
+PASS (new BaseReturnNumber) instanceof BaseReturnNumber is true
+PASS typeof (new BaseReturnNumber) !== "number" is true
+PASS (new BaseReturnNull) instanceof BaseReturnNull is true
+PASS (new BaseReturnNull) !== null is true
+PASS (new BaseReturnSymbol) instanceof BaseReturnSymbol is true
+PASS (new BaseReturnSymbol) !== globalSymbol is true
+PASS (new BaseThrow) threw exception Thrown Exception String.
+
+Function constructor (non-class)
+PASS (new FunctionNoReturn) instanceof FunctionNoReturn is true
+PASS (new FunctionReturnImplicit) instanceof FunctionReturnImplicit is true
+PASS (new FunctionReturnImplicit) !== undefined is true
+PASS (new FunctionReturnUndefined) instanceof FunctionReturnUndefined is true
+PASS (new FunctionReturnUndefined) !== undefined is true
+PASS (new FunctionReturnThis) instanceof FunctionReturnThis is true
+PASS (new FunctionReturnObject) instanceof FunctionReturnObject is false
+PASS typeof (new FunctionReturnObject) === "object" is true
+PASS (new FunctionReturnObject2) instanceof FunctionReturnObject is false
+PASS (new FunctionReturnObject2) === globalVariable is true
+PASS (new FunctionReturnString) instanceof FunctionReturnString is true
+PASS typeof (new FunctionReturnString) !== "string" is true
+PASS (new FunctionReturnNumber) instanceof FunctionReturnNumber is true
+PASS typeof (new FunctionReturnNumber) !== "number" is true
+PASS (new FunctionReturnNull) instanceof FunctionReturnNull is true
+PASS (new FunctionReturnNull) !== null is true
+PASS (new FunctionReturnSymbol) instanceof FunctionReturnSymbol is true
+PASS (new FunctionReturnSymbol) !== globalSymbol is true
+PASS (new FunctionThrow) threw exception Thrown Exception String.
+
+Derived class calling super()
+PASS (new DerivedNoReturn) instanceof DerivedNoReturn is true
+PASS (new DerivedReturnImplicit) instanceof DerivedReturnImplicit is true
+PASS (new DerivedReturnImplicit) !== undefined is true
+PASS (new DerivedReturnUndefined) instanceof DerivedReturnUndefined is true
+PASS (new DerivedReturnUndefined) !== undefined is true
+PASS (new DerivedReturnThis) instanceof DerivedReturnThis is true
+PASS (new DerivedReturnObject) instanceof DerivedReturnObject is false
+PASS typeof (new DerivedReturnObject) === "object" is true
+PASS (new DerivedReturnObject2) instanceof DerivedReturnObject2 is false
+PASS (new DerivedReturnObject2) === globalVariable is true
+PASS (new DerivedReturnString) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedReturnNumber) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedReturnNull) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedReturnSymbol) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedThrow) threw exception Thrown Exception String.
+
+Derived class not calling super()
+PASS (new DerivedNoSuperNoReturn) threw exception ReferenceError: Cannot access uninitialized variable..
+PASS (new DerivedNoSuperReturnImplicit) threw exception ReferenceError: Can't find variable: DerivedNoSuperReturnImplicit.
+PASS (new DerivedNoSuperReturnUndefined) threw exception ReferenceError: Cannot access uninitialized variable..
+PASS (new DerivedNoSuperReturnThis) threw exception ReferenceError: Cannot access uninitialized variable..
+PASS (new DerivedNoSuperReturnObject) did not throw exception.
+PASS (new DerivedNoSuperReturnObject2) did not throw exception.
+PASS (new DerivedNoSuperReturnString) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedNoSuperReturnNumber) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedNoSuperReturnNull) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedNoSuperReturnSymbol) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
+PASS (new DerivedNoSuperThrow) threw exception Thrown Exception String.
+
+Derived class with default constructor and base class returning different values
+PASS (new DerivedDefaultConstructorWithBaseNoReturn) instanceof DerivedDefaultConstructorWithBaseNoReturn is true
+PASS (new DerivedDefaultConstructorWithBaseReturnImplicit) instanceof DerivedDefaultConstructorWithBaseReturnImplicit is true
+PASS (new DerivedDefaultConstructorWithBaseReturnUndefined) instanceof DerivedDefaultConstructorWithBaseReturnUndefined is true
+PASS (new DerivedDefaultConstructorWithBaseReturnObject) instanceof DerivedDefaultConstructorWithBaseReturnObject is false
+PASS typeof (new DerivedDefaultConstructorWithBaseReturnObject) === "object" is true
+PASS (new DerivedDefaultConstructorWithBaseReturnObject2) instanceof DerivedDefaultConstructorWithBaseReturnObject2 is false
+PASS (new DerivedDefaultConstructorWithBaseReturnObject2) === globalVariable is true
+PASS (new DerivedDefaultConstructorWithBaseReturnThis) instanceof DerivedDefaultConstructorWithBaseReturnThis is true
+PASS (new DerivedDefaultConstructorWithBaseReturnString) instanceof DerivedDefaultConstructorWithBaseReturnString is true
+PASS (new DerivedDefaultConstructorWithBaseReturnNumber) instanceof DerivedDefaultConstructorWithBaseReturnNumber is true
+PASS (new DerivedDefaultConstructorWithBaseReturnNull) instanceof DerivedDefaultConstructorWithBaseReturnNull is true
+PASS (new DerivedDefaultConstructorWithBaseReturnSymbol) instanceof DerivedDefaultConstructorWithBaseReturnSymbol is true
+PASS (new DerivedDefaultConstructorWithBaseThrow) threw exception Thrown Exception String.
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
diff --git a/LayoutTests/js/class-constructor-return.html b/LayoutTests/js/class-constructor-return.html
new file mode 100644 (file)
index 0000000..dab241a
--- /dev/null
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+<body>
+<script src="../resources/js-test-pre.js"></script>
+<script src="script-tests/class-constructor-return.js"></script>
+<script src="../resources/js-test-post.js"></script>
+</body>
+</html>
index 234799f21e7fd6c90150005b64f08520f6b28dfc..b2ad9347ffb08c8aa583a9326a611fe75a69cff0 100644 (file)
@@ -24,12 +24,14 @@ PASS (new x).method1() threw exception ReferenceError: Cannot delete a super pro
 PASS (new x).method2() threw exception ReferenceError: Cannot delete a super property.
 PASS new (class { constructor() { return undefined; } }) instanceof Object is true
 PASS new (class { constructor() { return 1; } }) instanceof Object is true
-PASS new (class extends Base { constructor() { return undefined } }) is undefined
+PASS new (class extends Base { constructor() { return undefined } }) threw exception ReferenceError: Cannot access uninitialized variable..
+PASS new (class extends Base { constructor() { super(); return undefined } }) instanceof Object is true
 PASS x = { }; new (class extends Base { constructor() { return x } }); is x
 PASS x instanceof Base is false
 PASS new (class extends Base { constructor() { } }) threw exception ReferenceError: Cannot access uninitialized variable..
 PASS new (class extends Base { constructor() { return 1; } }) threw exception TypeError: Cannot return a non-object type in the constructor of a derived class..
-PASS new (class extends null { constructor() { return undefined } }) is undefined
+PASS new (class extends null { constructor() { return undefined } }) threw exception ReferenceError: Cannot access uninitialized variable..
+PASS new (class extends null { constructor() { super(); return undefined } }) instanceof Object is true
 PASS x = { }; new (class extends null { constructor() { return x } }); is x
 PASS x instanceof Object is true
 PASS new (class extends null { constructor() { } }) threw exception ReferenceError: Cannot access uninitialized variable..
diff --git a/LayoutTests/js/script-tests/class-constructor-return.js b/LayoutTests/js/script-tests/class-constructor-return.js
new file mode 100644 (file)
index 0000000..f393027
--- /dev/null
@@ -0,0 +1,192 @@
+description('Tests for ES6 class constructor return values');
+
+// ES6
+// - 9.2.2 [[Construct]] (ECMAScript Function Objects)
+// - 12.3.5.1 Runtime Semantics: Evaluation (The super Keyword)
+// - 14.5.14 Runtime Semantics: ClassDefinitionEvaluation (Default Constructor)
+
+var globalVariable = {name:"globalVariable"};
+var globalSymbol = Symbol();
+
+debug('Base class');
+class BaseNoReturn { constructor() { } };
+class BaseReturnImplicit { constructor() { return; } };
+class BaseReturnUndefined { constructor() { return undefined; } };
+class BaseReturnThis { constructor() { return this; } };
+class BaseReturnObject { constructor() { return {a:1}; } };
+class BaseReturnObject2 { constructor() { return globalVariable; } };
+class BaseReturnString { constructor() { return "test"; } };
+class BaseReturnNumber { constructor() { return 1; } };
+class BaseReturnNull { constructor() { return null; } };
+class BaseReturnSymbol { constructor() { return Symbol(); } };
+class BaseThrow { constructor() { throw "Thrown Exception String"; } };
+
+// Base - Implicit => return this.
+shouldBeTrue('(new BaseNoReturn) instanceof BaseNoReturn');
+
+// Base - Early return => return this.
+shouldBeTrue('(new BaseReturnImplicit) instanceof BaseReturnImplicit');
+shouldBeTrue('(new BaseReturnImplicit) !== undefined');
+shouldBeTrue('(new BaseReturnUndefined) instanceof BaseReturnUndefined');
+shouldBeTrue('(new BaseReturnUndefined) !== undefined');
+
+// Base - return this => return this.
+shouldBeTrue('(new BaseReturnThis) instanceof BaseReturnThis');
+
+// Base - return Object => return object, not instance.
+shouldBeFalse('(new BaseReturnObject) instanceof BaseReturnObject');
+shouldBeTrue('typeof (new BaseReturnObject) === "object"');
+shouldBeFalse('(new BaseReturnObject2) instanceof BaseReturnObject');
+shouldBeTrue('(new BaseReturnObject2) === globalVariable');
+
+// Base - return non-Object => return this.
+shouldBeTrue('(new BaseReturnString) instanceof BaseReturnString');
+shouldBeTrue('typeof (new BaseReturnString) !== "string"');
+shouldBeTrue('(new BaseReturnNumber) instanceof BaseReturnNumber');
+shouldBeTrue('typeof (new BaseReturnNumber) !== "number"');
+shouldBeTrue('(new BaseReturnNull) instanceof BaseReturnNull');
+shouldBeTrue('(new BaseReturnNull) !== null');
+shouldBeTrue('(new BaseReturnSymbol) instanceof BaseReturnSymbol');
+shouldBeTrue('(new BaseReturnSymbol) !== globalSymbol');
+
+// Base - throw => throw
+shouldThrow('(new BaseThrow)');
+
+// Same behavior for Functions.
+debug(''); debug('Function constructor (non-class)');
+function FunctionNoReturn() { };
+function FunctionReturnImplicit() { return; };
+function FunctionReturnUndefined() { return undefined; };
+function FunctionReturnThis() { return this; };
+function FunctionReturnObject() { return {a:1}; };
+function FunctionReturnObject2() { return globalVariable; };
+function FunctionReturnString() { return "test"; };
+function FunctionReturnNumber() { return 1; };
+function FunctionReturnNull() { return null; };
+function FunctionReturnSymbol() { return Symbol(); };
+function FunctionThrow() { throw "Thrown Exception String"; };
+
+shouldBeTrue('(new FunctionNoReturn) instanceof FunctionNoReturn');
+shouldBeTrue('(new FunctionReturnImplicit) instanceof FunctionReturnImplicit');
+shouldBeTrue('(new FunctionReturnImplicit) !== undefined');
+shouldBeTrue('(new FunctionReturnUndefined) instanceof FunctionReturnUndefined');
+shouldBeTrue('(new FunctionReturnUndefined) !== undefined');
+shouldBeTrue('(new FunctionReturnThis) instanceof FunctionReturnThis');
+shouldBeFalse('(new FunctionReturnObject) instanceof FunctionReturnObject');
+shouldBeTrue('typeof (new FunctionReturnObject) === "object"');
+shouldBeFalse('(new FunctionReturnObject2) instanceof FunctionReturnObject');
+shouldBeTrue('(new FunctionReturnObject2) === globalVariable');
+shouldBeTrue('(new FunctionReturnString) instanceof FunctionReturnString');
+shouldBeTrue('typeof (new FunctionReturnString) !== "string"');
+shouldBeTrue('(new FunctionReturnNumber) instanceof FunctionReturnNumber');
+shouldBeTrue('typeof (new FunctionReturnNumber) !== "number"');
+shouldBeTrue('(new FunctionReturnNull) instanceof FunctionReturnNull');
+shouldBeTrue('(new FunctionReturnNull) !== null');
+shouldBeTrue('(new FunctionReturnSymbol) instanceof FunctionReturnSymbol');
+shouldBeTrue('(new FunctionReturnSymbol) !== globalSymbol');
+shouldThrow('(new FunctionThrow)');
+
+
+debug(''); debug('Derived class calling super()');
+class DerivedNoReturn extends BaseNoReturn { constructor() { super(); } };
+class DerivedReturnImplicit extends BaseNoReturn { constructor() { super(); return; } };
+class DerivedReturnUndefined extends BaseNoReturn { constructor() { super(); return undefined; } };
+class DerivedReturnThis extends BaseNoReturn { constructor() { super(); return this; } };
+class DerivedReturnObject extends BaseNoReturn { constructor() { super(); return {a:1}; } };
+class DerivedReturnObject2 extends BaseNoReturn { constructor() { super(); return globalVariable; } };
+class DerivedReturnString extends BaseNoReturn { constructor() { super(); return "test"; } };
+class DerivedReturnNumber extends BaseNoReturn { constructor() { super(); return 1; } };
+class DerivedReturnNull extends BaseNoReturn { constructor() { super(); return null; } };
+class DerivedReturnSymbol extends BaseNoReturn { constructor() { super(); return globalSymbol; } };
+class DerivedThrow extends BaseNoReturn { constructor() { super(); throw "Thrown Exception String"; } };
+
+// Derived - Implicit => return this.
+shouldBeTrue('(new DerivedNoReturn) instanceof DerivedNoReturn');
+
+// Derived - Early return => return this.
+shouldBeTrue('(new DerivedReturnImplicit) instanceof DerivedReturnImplicit');
+shouldBeTrue('(new DerivedReturnImplicit) !== undefined');
+shouldBeTrue('(new DerivedReturnUndefined) instanceof DerivedReturnUndefined');
+shouldBeTrue('(new DerivedReturnUndefined) !== undefined');
+
+// Derived - return this => return this.
+shouldBeTrue('(new DerivedReturnThis) instanceof DerivedReturnThis');
+
+// Derived - return Object => return object, not instance.
+shouldBeFalse('(new DerivedReturnObject) instanceof DerivedReturnObject');
+shouldBeTrue('typeof (new DerivedReturnObject) === "object"');
+shouldBeFalse('(new DerivedReturnObject2) instanceof DerivedReturnObject2');
+shouldBeTrue('(new DerivedReturnObject2) === globalVariable');
+
+// Derived - return non-Object => exception.
+shouldThrow('(new DerivedReturnString)');
+shouldThrow('(new DerivedReturnNumber)');
+shouldThrow('(new DerivedReturnNull)');
+shouldThrow('(new DerivedReturnSymbol)');
+shouldThrow('(new DerivedThrow)');
+
+
+debug(''); debug('Derived class not calling super()');
+class DerivedNoSuperNoReturn extends BaseNoReturn { constructor() { } };
+class DerivedNoSuperReturn extends BaseNoReturn { constructor() { return; } };
+class DerivedNoSuperReturnUndefined extends BaseNoReturn { constructor() { return undefined; } };
+class DerivedNoSuperReturnObject extends BaseNoReturn { constructor() { return {a:1}; } };
+class DerivedNoSuperReturnObject2 extends BaseNoReturn { constructor() { return globalVariable; } };
+class DerivedNoSuperReturnThis extends BaseNoReturn { constructor() { return this; } };
+class DerivedNoSuperReturnString extends BaseNoReturn { constructor() { return "test"; } };
+class DerivedNoSuperReturnNumber extends BaseNoReturn { constructor() { return 1; } };
+class DerivedNoSuperReturnNull extends BaseNoReturn { constructor() { return null; } };
+class DerivedNoSuperReturnSymbol extends BaseNoReturn { constructor() { return globalSymbol; } };
+class DerivedNoSuperThrow extends BaseNoReturn { constructor() { throw "Thrown Exception String"; } };
+
+// Derived without super() - Implicit => return this => TDZ.
+shouldThrow('(new DerivedNoSuperNoReturn)');
+
+// Derived without super() - Early return => return this => TDZ.
+shouldThrow('(new DerivedNoSuperReturnImplicit)');
+shouldThrow('(new DerivedNoSuperReturnUndefined)');
+
+// Derived without super() - return this => return this => TDZ
+shouldThrow('(new DerivedNoSuperReturnThis)');
+
+// Derived without super() - return Object => no this access => return object, not instance
+shouldNotThrow('(new DerivedNoSuperReturnObject)');
+shouldNotThrow('(new DerivedNoSuperReturnObject2)');
+
+// Derived without super() - return non-Object => exception
+shouldThrow('(new DerivedNoSuperReturnString)'); // TypeError
+shouldThrow('(new DerivedNoSuperReturnNumber)'); // TypeError
+shouldThrow('(new DerivedNoSuperReturnNull)'); // TypeError
+shouldThrow('(new DerivedNoSuperReturnSymbol)'); // TypeError
+shouldThrow('(new DerivedNoSuperThrow)'); // Thrown exception
+
+
+debug(''); debug('Derived class with default constructor and base class returning different values');
+class DerivedDefaultConstructorWithBaseNoReturn extends BaseNoReturn { };
+class DerivedDefaultConstructorWithBaseReturnImplicit extends BaseReturnImplicit { };
+class DerivedDefaultConstructorWithBaseReturnUndefined extends BaseReturnUndefined { };
+class DerivedDefaultConstructorWithBaseReturnThis extends BaseReturnThis { };
+class DerivedDefaultConstructorWithBaseReturnObject extends BaseReturnObject { };
+class DerivedDefaultConstructorWithBaseReturnObject2 extends BaseReturnObject2 { };
+class DerivedDefaultConstructorWithBaseReturnString extends BaseReturnString { };
+class DerivedDefaultConstructorWithBaseReturnNumber extends BaseReturnNumber { };
+class DerivedDefaultConstructorWithBaseReturnNull extends BaseReturnNull { };
+class DerivedDefaultConstructorWithBaseReturnSymbol extends BaseReturnSymbol { };
+class DerivedDefaultConstructorWithBaseThrow extends BaseThrow { };
+
+// Derived default constructor - implicit "super(...arguments)" return the result of the base (Object or this).
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseNoReturn) instanceof DerivedDefaultConstructorWithBaseNoReturn');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnImplicit) instanceof DerivedDefaultConstructorWithBaseReturnImplicit');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnUndefined) instanceof DerivedDefaultConstructorWithBaseReturnUndefined');
+shouldBeFalse('(new DerivedDefaultConstructorWithBaseReturnObject) instanceof DerivedDefaultConstructorWithBaseReturnObject');
+shouldBeTrue('typeof (new DerivedDefaultConstructorWithBaseReturnObject) === "object"');
+shouldBeFalse('(new DerivedDefaultConstructorWithBaseReturnObject2) instanceof DerivedDefaultConstructorWithBaseReturnObject2');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnObject2) === globalVariable');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnThis) instanceof DerivedDefaultConstructorWithBaseReturnThis');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnString) instanceof DerivedDefaultConstructorWithBaseReturnString');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnNumber) instanceof DerivedDefaultConstructorWithBaseReturnNumber');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnNull) instanceof DerivedDefaultConstructorWithBaseReturnNull');
+shouldBeTrue('(new DerivedDefaultConstructorWithBaseReturnSymbol) instanceof DerivedDefaultConstructorWithBaseReturnSymbol');
+shouldThrow('(new DerivedDefaultConstructorWithBaseThrow)');
+
+var successfullyParsed = true;
index b27adbe06700ac1615bd7477ee684e50b23c6553..855df36d31fa4cc94bdd485d9162036e88fc02f2 100644 (file)
@@ -49,12 +49,14 @@ shouldThrow('(new x).method1()', '"ReferenceError: Cannot delete a super propert
 shouldThrow('(new x).method2()', '"ReferenceError: Cannot delete a super property"');
 shouldBeTrue('new (class { constructor() { return undefined; } }) instanceof Object');
 shouldBeTrue('new (class { constructor() { return 1; } }) instanceof Object');
-shouldBe('new (class extends Base { constructor() { return undefined } })', 'undefined');
+shouldThrow('new (class extends Base { constructor() { return undefined } })');
+shouldBeTrue('new (class extends Base { constructor() { super(); return undefined } }) instanceof Object');
 shouldBe('x = { }; new (class extends Base { constructor() { return x } });', 'x');
 shouldBeFalse('x instanceof Base');
 shouldThrow('new (class extends Base { constructor() { } })', '"ReferenceError: Cannot access uninitialized variable."');
 shouldThrow('new (class extends Base { constructor() { return 1; } })', '"TypeError: Cannot return a non-object type in the constructor of a derived class."');
-shouldBe('new (class extends null { constructor() { return undefined } })', 'undefined');
+shouldThrow('new (class extends null { constructor() { return undefined } })');
+shouldBeTrue('new (class extends null { constructor() { super(); return undefined } }) instanceof Object');
 shouldBe('x = { }; new (class extends null { constructor() { return x } });', 'x');
 shouldBeTrue('x instanceof Object');
 shouldThrow('new (class extends null { constructor() { } })', '"ReferenceError: Cannot access uninitialized variable."');
index dc756c8c807b1dc76dbf88a583a2826b10a3d2d0..6dbfe0a051289d47aae665d255fd343b89dd3f7b 100644 (file)
@@ -1,3 +1,15 @@
+2015-03-24  Joseph Pecoraro  <pecoraro@apple.com>
+
+        ES6: Classes: Early return in sub-class constructor results in returning undefined instead of instance
+        https://bugs.webkit.org/show_bug.cgi?id=143012
+
+        Reviewed by Ryosuke Niwa.
+
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::emitReturn):
+        Fix handling of "undefined" when returned from a Derived class. It was
+        returning "undefined" when it should have returned "this".
+
 2015-03-24  Yusuke Suzuki  <utatane.tea@gmail.com>
 
         REGRESSION (r181458): Heap use-after-free in JSSetIterator destructor
index c26dc35bd4f73289245254f2a5616e0b61887094..e68e162587da6d313fb8fbaea48b64f0405e6ba8 100644 (file)
@@ -1930,24 +1930,28 @@ RegisterID* BytecodeGenerator::emitReturn(RegisterID* src)
         instructions().append(m_lexicalEnvironmentRegister ? m_lexicalEnvironmentRegister->index() : emitLoad(0, JSValue())->index());
     }
 
-    bool thisMightBeUninitialized = constructorKind() == ConstructorKind::Derived;
-    bool srcIsThis = src->index() == m_thisRegister.index();
-    if (isConstructor() && (!srcIsThis || thisMightBeUninitialized)) {
-        RefPtr<Label> isObjectOrUndefinedLabel = newLabel();
-
-        if (srcIsThis && thisMightBeUninitialized)
+    if (isConstructor()) {
+        bool derived = constructorKind() == ConstructorKind::Derived;
+        if (derived && src->index() == m_thisRegister.index())
             emitTDZCheck(src);
 
-        emitJumpIfTrue(emitIsObject(newTemporary(), src), isObjectOrUndefinedLabel.get());
+        RefPtr<Label> isObjectLabel = newLabel();
+        emitJumpIfTrue(emitIsObject(newTemporary(), src), isObjectLabel.get());
 
-        if (thisMightBeUninitialized) {
-            emitJumpIfTrue(emitIsUndefined(newTemporary(), src), isObjectOrUndefinedLabel.get());
+        if (derived) {
+            RefPtr<Label> isUndefinedLabel = newLabel();
+            emitJumpIfTrue(emitIsUndefined(newTemporary(), src), isUndefinedLabel.get());
             emitThrowTypeError("Cannot return a non-object type in the constructor of a derived class.");
-        } else
-            emitUnaryNoDstOp(op_ret, &m_thisRegister);
+            emitLabel(isUndefinedLabel.get());
+            if (constructorKind() == ConstructorKind::Derived)
+                emitTDZCheck(&m_thisRegister);
+        }
+
+        emitUnaryNoDstOp(op_ret, &m_thisRegister);
 
-        emitLabel(isObjectOrUndefinedLabel.get());
+        emitLabel(isObjectLabel.get());
     }
+
     return emitUnaryNoDstOp(op_ret, src);
 }