Expose SIMD.Float32x4 type to Javascript.

test/mjsunit/harmony/reflect-apply.js

 // Copyright 2014 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-reflect
+// Flags: --harmony-reflect --harmony-simd
 
 
 (function testReflectApplyArity() {
   assertEquals(3, Reflect.apply.length);
 })();
 
 
 (function testReflectApplyNonConstructor() {
   assertThrows(function() {
     new Reflect.apply(function(){}, null, []);
@@ skipping 13 matching lines @@
   // Wrap JS values
   assertSame(String.prototype,
              Object.getPrototypeOf(Reflect.apply(returnThis, "str", [])));
   assertSame(Number.prototype,
              Object.getPrototypeOf(Reflect.apply(returnThis, 123, [])));
   assertSame(Boolean.prototype,
              Object.getPrototypeOf(Reflect.apply(returnThis, true, [])));
   assertSame(Symbol.prototype,
              Object.getPrototypeOf(
                 Reflect.apply(returnThis, Symbol("test"), [])));
+  assertSame(SIMD.float32x4.prototype,
+             Object.getPrototypeOf(
+                Reflect.apply(returnThis, SIMD.float32x4(1, 2, 3, 4), [])));
 })();
 
 
 (function testAppliedReceiverStrict() {
   function returnThis() { 'use strict'; return this; }
   var receiver = {};
 
   assertSame(void 0, Reflect.apply(returnThis, void 0, []));
   assertSame(this, Reflect.apply(returnThis, this, []));
   assertSame(receiver, Reflect.apply(returnThis, receiver, []));
 
   // Don't wrap value types
   var regexp = /123/;
   var symbol = Symbol("test");
+  var float32x4 = SIMD.float32x4(1, 2, 3, 4);
   assertSame("str", Reflect.apply(returnThis, "str", []));
   assertSame(123, Reflect.apply(returnThis, 123, []));
   assertSame(true, Reflect.apply(returnThis, true, []));
   assertSame(regexp, Reflect.apply(returnThis, regexp, []));
   assertSame(symbol, Reflect.apply(returnThis, symbol, []));
+  assertSame(float32x4, Reflect.apply(returnThis, float32x4, []));
 })();
 
 
 (function testAppliedArgumentsLength() {
   function returnLengthStrict() { 'use strict'; return arguments.length; }
   function returnLengthSloppy() { return arguments.length; }
 
   assertEquals(0, Reflect.apply(returnLengthStrict, this, []));
   assertEquals(0, Reflect.apply(returnLengthSloppy, this, []));
   assertEquals(0, Reflect.apply(returnLengthStrict, this, {}));
@@ skipping 48 matching lines @@
 })();
 
 
 (function testAppliedNonFunctionStrict() {
   'use strict';
   assertThrows(function() { Reflect.apply(void 0); }, TypeError);
   assertThrows(function() { Reflect.apply(null); }, TypeError);
   assertThrows(function() { Reflect.apply(123); }, TypeError);
   assertThrows(function() { Reflect.apply("str"); }, TypeError);
   assertThrows(function() { Reflect.apply(Symbol("x")); }, TypeError);
+  assertThrows(
+      function() { Reflect.apply(SIMD.float32x4(1, 2, 3, 4)); }, TypeError);
   assertThrows(function() { Reflect.apply(/123/); }, TypeError);
   assertThrows(function() { Reflect.apply(NaN); }, TypeError);
   assertThrows(function() { Reflect.apply({}); }, TypeError);
   assertThrows(function() { Reflect.apply([]); }, TypeError);
 })();
 
 
 (function testAppliedNonFunctionSloppy() {
   assertThrows(function() { Reflect.apply(void 0); }, TypeError);
   assertThrows(function() { Reflect.apply(null); }, TypeError);
   assertThrows(function() { Reflect.apply(123); }, TypeError);
   assertThrows(function() { Reflect.apply("str"); }, TypeError);
   assertThrows(function() { Reflect.apply(Symbol("x")); }, TypeError);
+  assertThrows(
+      function() { Reflect.apply(SIMD.float32x4(1, 2, 3, 4)); }, TypeError);
   assertThrows(function() { Reflect.apply(/123/); }, TypeError);
   assertThrows(function() { Reflect.apply(NaN); }, TypeError);
   assertThrows(function() { Reflect.apply({}); }, TypeError);
   assertThrows(function() { Reflect.apply([]); }, TypeError);
 })();
 
 
 (function testAppliedArgumentsNonList() {
   function noopStrict() { 'use strict'; }
   function noopSloppy() {}
   var R = void 0;
   assertThrows(function() { Reflect.apply(noopStrict, R, null); }, TypeError);
   assertThrows(function() { Reflect.apply(noopSloppy, R, null); }, TypeError);
   assertThrows(function() { Reflect.apply(noopStrict, R, 1); }, TypeError);
   assertThrows(function() { Reflect.apply(noopSloppy, R, 1); }, TypeError);
   assertThrows(function() { Reflect.apply(noopStrict, R, "BAD"); }, TypeError);
   assertThrows(function() { Reflect.apply(noopSloppy, R, "BAD"); }, TypeError);
   assertThrows(function() { Reflect.apply(noopStrict, R, true); }, TypeError);
   assertThrows(function() { Reflect.apply(noopSloppy, R, true); }, TypeError);
   var sym = Symbol("x");
   assertThrows(function() { Reflect.apply(noopStrict, R, sym); }, TypeError);
   assertThrows(function() { Reflect.apply(noopSloppy, R, sym); }, TypeError);
+  var float32x4 = SIMD.float32x4(1, 2, 3, 4);
+  assertThrows(
+      function() { Reflect.apply(noopStrict, R, float32x4); }, TypeError);
+  assertThrows(
+      function() { Reflect.apply(noopSloppy, R, float32x4); }, TypeError);
 })();
 
 
 (function testAppliedArgumentValue() {
   function returnFirstStrict(a) { 'use strict'; return a; }
   function returnFirstSloppy(a) { return a; }
   function returnLastStrict(a) {
     'use strict'; return arguments[arguments.length - 1]; }
   function returnLastSloppy(a) { return arguments[arguments.length - 1]; }
   function returnSumStrict() {
@@ skipping 32 matching lines @@
                                        ["T", "E", "S", "T", "!", "!"]));
   assertEquals(10, Reflect.apply(returnSumStrict, this,
                                  { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 }));
   assertEquals("TEST", Reflect.apply(returnSumSloppy, this,
                                      ["T", "E", "S", "T"]));
   assertEquals("TEST!!", Reflect.apply(returnSumSloppy, this,
                                        ["T", "E", "S", "T", "!", "!"]));
   assertEquals(10, Reflect.apply(returnSumSloppy, this,
                                  { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 }));
 })();