Simplify the VM's typed_data constructors.

runtime/lib/typed_data.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/bootstrap_natives.h"
 
 #include "include/dart_api.h"
 
 #include "vm/exceptions.h"
 #include "vm/native_entry.h"
@@ skipping 146 matching lines @@
   UNREACHABLE();
   return Bool::False().raw();
 }
 
 
 // We check the length parameter against a possible maximum length for the
 // array based on available physical addressable memory on the system. The
 // maximum possible length is a scaled value of kSmiMax which is set up based
 // on whether the underlying architecture is 32-bit or 64-bit.
 #define TYPED_DATA_NEW(name)                                                   \
-DEFINE_NATIVE_ENTRY(TypedData_##name##_new, 1) {                               \
-  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));        \
+DEFINE_NATIVE_ENTRY(TypedData_##name##_new, 2) {                               \
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(1));        \

[siva, 2016/03/10 08:22:53]

Can you add a comment that the first argument is the type to the factory
constructor and is ignored.

[Florian Schneider, 2016/03/10 08:37:17]

Done.

   intptr_t cid = kTypedData##name##Cid;                                        \
   intptr_t len = length.Value();                                               \
   intptr_t max = TypedData::MaxElements(cid);                                  \
   LengthCheck(len, max);                                                       \
   return TypedData::New(cid, len);                                             \
 }                                                                              \
 
 
 // We check the length parameter against a possible maximum length for the
 // array based on available physical addressable memory on the system. The
 // maximum possible length is a scaled value of kSmiMax which is set up based
 // on whether the underlying architecture is 32-bit or 64-bit.
 #define EXT_TYPED_DATA_NEW(name)                                               \
-DEFINE_NATIVE_ENTRY(ExternalTypedData_##name##_new, 1) {                       \
+DEFINE_NATIVE_ENTRY(ExternalTypedData_##name##_new, 2) {                       \
   const int kAlignment = 16;                                                   \
-  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(0));        \
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, length, arguments->NativeArgAt(1));        \
   intptr_t cid = kExternalTypedData##name##Cid;                                \
   intptr_t len = length.Value();                                               \
   intptr_t max = ExternalTypedData::MaxElements(cid);                          \
   LengthCheck(len, max);                                                       \
   intptr_t len_bytes = len * ExternalTypedData::ElementSizeInBytes(cid);       \
   uint8_t* data = OS::AllocateAlignedArray<uint8_t>(len_bytes, kAlignment);    \
   const ExternalTypedData& obj =                                               \
       ExternalTypedData::Handle(ExternalTypedData::New(cid, data, len));       \
   obj.AddFinalizer(data, PeerFinalizer);                                       \
   return obj.raw();                                                            \
@@ skipping 195 matching lines @@
     value = bit_cast<double>(
         Utils::HostToLittleEndian64(bit_cast<uint64_t>(value)));
   } else {
     value = bit_cast<double>(
         Utils::HostToBigEndian64(bit_cast<uint64_t>(value)));
   }
   return Double::New(value);
 }
 
 }  // namespace dart