Add documentation, tests and better parameter names to Float32x4.

The same should happen for `Int32x4` and `Float64x2`,
but this is a start.

The existing class was basically uncommented and you had
to guess or explore to find out what, fx, the returned
values for the relational operators means.

I've tried to discover and document the current behavior,
but I had to fall back on "it's implementation specific"
in some places where platforms behave differently.
(For example it seems VM on Mac treats `.reciprocalSqrt()`
as doing `.sqrt().reciprocal()` where the other platforms do
`.reciprocal().sqrt()`, which makes a difference for exactly
one value.)

CoreLibraryReviewExempt: Doc and parameter name changes only.
Tested: Added more tests to float32x4_test.dart.
Change-Id: I3f8804f842d8a5d95e1d378a7edb9438a2f3ed2b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/415000
Commit-Queue: Lasse Nielsen <[email protected]>
Reviewed-by: Alexander Markov <[email protected]>

Author: lrhn

sdk/lib/_internal/js_dev_runtime/patch/typed_data_patch.dart

@@ -156,14 +156,14 @@ class Float32x4 {
   @patch
   factory Float32x4(double x, double y, double z, double w) = NativeFloat32x4;
   @patch
-  factory Float32x4.splat(double v) = NativeFloat32x4.splat;
+  factory Float32x4.splat(double value) = NativeFloat32x4.splat;
   @patch
   factory Float32x4.zero() = NativeFloat32x4.zero;
   @patch
-  factory Float32x4.fromInt32x4Bits(Int32x4 x) =
+  factory Float32x4.fromInt32x4Bits(Int32x4 bits) =
       NativeFloat32x4.fromInt32x4Bits;
   @patch
-  factory Float32x4.fromFloat64x2(Float64x2 v) = NativeFloat32x4.fromFloat64x2;
+  factory Float32x4.fromFloat64x2(Float64x2 xy) = NativeFloat32x4.fromFloat64x2;
 }
 
 @patch

sdk/lib/_internal/js_dev_runtime/private/native_typed_data.dart

@@ -1219,20 +1219,20 @@ final class NativeFloat32x4 implements Float32x4 {
     if (w is! num) throw ArgumentError(w);
   }
 
-  NativeFloat32x4.splat(double v) : this(v, v, v, v);
+  NativeFloat32x4.splat(double value) : this(value, value, value, value);
   NativeFloat32x4.zero() : this._truncated(0.0, 0.0, 0.0, 0.0);
 
-  /// Returns a bit-wise copy of [i] as a Float32x4.
-  factory NativeFloat32x4.fromInt32x4Bits(Int32x4 i) {
-    _uint32view[0] = i.x;
-    _uint32view[1] = i.y;
-    _uint32view[2] = i.z;
-    _uint32view[3] = i.w;
+  /// Returns a bit-wise copy of [bits] as a Float32x4.
+  factory NativeFloat32x4.fromInt32x4Bits(Int32x4 bits) {
+    _uint32view[0] = bits.x;
+    _uint32view[1] = bits.y;
+    _uint32view[2] = bits.z;
+    _uint32view[3] = bits.w;
     return NativeFloat32x4._truncated(_list[0], _list[1], _list[2], _list[3]);
   }
 
-  NativeFloat32x4.fromFloat64x2(Float64x2 v)
-    : this._truncated(_truncate(v.x), _truncate(v.y), 0.0, 0.0);
+  NativeFloat32x4.fromFloat64x2(Float64x2 xy)
+    : this._truncated(_truncate(xy.x), _truncate(xy.y), 0.0, 0.0);
 
   /// Creates a new NativeFloat32x4.
   ///
@@ -1380,11 +1380,11 @@ final class NativeFloat32x4 implements Float32x4 {
   }
 
   /// Returns a copy of this [Float32x4] each lane being scaled by [s].
-  Float32x4 scale(double s) {
-    double _x = s * x;
-    double _y = s * y;
-    double _z = s * z;
-    double _w = s * w;
+  Float32x4 scale(double scale) {
+    double _x = scale * x;
+    double _y = scale * y;
+    double _z = scale * z;
+    double _w = scale * w;
     return NativeFloat32x4._doubles(_x, _y, _z, _w);
   }