Implement eager instantiation and canonicalization of type arguments at run

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 73 matching lines @@
 // Allocation of a fixed length array of given element type.
 // This runtime entry is never called for allocating a List of a generic type,
 // because a prior run time call instantiates the element type if necessary.
 // Arg0: array length.
 // Arg1: array type arguments, i.e. vector of 1 type, the element type.
 // Return value: newly allocated array of length arg0.
 DEFINE_RUNTIME_ENTRY(AllocateArray, 2) {
   const Smi& length = Smi::CheckedHandle(arguments.ArgAt(0));
   const Array& array = Array::Handle(Array::New(length.Value()));
   arguments.SetReturn(array);
-  AbstractTypeArguments& element_type =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
+  TypeArguments& element_type =
+      TypeArguments::CheckedHandle(arguments.ArgAt(1));
   // An Array is raw or takes one type argument. However, its type argument
   // vector may be longer than 1 due to a type optimization reusing the type
   // argument vector of the instantiator.
   ASSERT(element_type.IsNull() ||
          ((element_type.Length() >= 1) && element_type.IsInstantiated()));
   array.SetTypeArguments(element_type);  // May be null.
 }
 
 
+// Helper returning the token position of the Dart caller.
+static intptr_t GetCallerLocation() {
+  DartFrameIterator iterator;
+  StackFrame* caller_frame = iterator.NextFrame();
+  ASSERT(caller_frame != NULL);
+  return caller_frame->GetTokenPos();
+}
+
+
 // Allocate a new object.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObject, 3) {
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
   if (cls.NumTypeArguments() == 0) {
     // No type arguments required for a non-parameterized type.
     ASSERT(Instance::CheckedHandle(arguments.ArgAt(1)).IsNull());
     return;
   }
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
+  TypeArguments& type_arguments =
+      TypeArguments::CheckedHandle(arguments.ArgAt(1));
   // If no instantiator is provided, set the type arguments and return.
   if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
     ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
     // Unless null (for a raw type), the type argument vector may be longer than
     // necessary due to a type optimization reusing the type argument vector of
     // the instantiator.
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.IsInstantiated() &&
             (type_arguments.Length() >= cls.NumTypeArguments())));
     instance.SetTypeArguments(type_arguments);  // May be null.
     return;
   }
   // A still uninstantiated type argument vector must have the correct length.
   ASSERT(!type_arguments.IsInstantiated() &&
          (type_arguments.Length() == cls.NumTypeArguments()));
-  const AbstractTypeArguments& instantiator =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
+  const TypeArguments& instantiator =
+      TypeArguments::CheckedHandle(arguments.ArgAt(2));
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   // Code inlined in the caller should have optimized the case where the
   // instantiator can be reused as type argument vector.
   ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
-  type_arguments = InstantiatedTypeArguments::New(type_arguments, instantiator);
-  instance.SetTypeArguments(type_arguments);
-}
-
-
-// Helper returning the token position of the Dart caller.
-static intptr_t GetCallerLocation() {
-  DartFrameIterator iterator;
-  StackFrame* caller_frame = iterator.NextFrame();
-  ASSERT(caller_frame != NULL);
-  return caller_frame->GetTokenPos();
-}
-
-
-// Allocate a new object of a generic type and check that the instantiated type
-// arguments are within the declared bounds or throw a dynamic type error.
-// Arg0: class of the object that needs to be allocated.
-// Arg1: type arguments of the object that needs to be allocated.
-// Arg2: type arguments of the instantiator or kNoInstantiator.
-// Return value: newly allocated object.
-DEFINE_RUNTIME_ENTRY(AllocateObjectWithBoundsCheck, 3) {
-  ASSERT(FLAG_enable_type_checks);
-  const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
-  const Instance& instance = Instance::Handle(Instance::New(cls));
-  arguments.SetReturn(instance);
-  ASSERT(cls.NumTypeArguments() > 0);
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
-  if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
-    ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
-           StubCode::kNoInstantiator);
-    // Unless null (for a raw type), the type argument vector may be longer than
-    // necessary due to a type optimization reusing the type argument vector of
-    // the instantiator.
-    ASSERT(type_arguments.IsNull() ||
-           (type_arguments.IsInstantiated() &&
-            (type_arguments.Length() >= cls.NumTypeArguments())));
-  } else {
-    // A still uninstantiated type argument vector must have the correct length.
-    ASSERT(!type_arguments.IsInstantiated() &&
-           (type_arguments.Length() == cls.NumTypeArguments()));
-    const AbstractTypeArguments& instantiator =
-        AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
-    ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
+  if (FLAG_enable_type_checks) {
     Error& bound_error = Error::Handle();
-    // Code inlined in the caller should have optimized the case where the
-    // instantiator can be reused as type argument vector.
-  ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
-    type_arguments = type_arguments.InstantiateFrom(instantiator, &bound_error);
+    type_arguments =
+        type_arguments.InstantiateAndCanonicalizeFrom(instantiator,
+                                                      &bound_error);
     if (!bound_error.IsNull()) {
       // Throw a dynamic type error.
       const intptr_t location = GetCallerLocation();
       String& bound_error_message =  String::Handle(
           String::New(bound_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
           location, Symbols::Empty(), Symbols::Empty(),
           Symbols::Empty(), bound_error_message);
       UNREACHABLE();
     }
+  } else {
+    type_arguments =
+        type_arguments.InstantiateAndCanonicalizeFrom(instantiator, NULL);
   }
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type.
 // Arg0: uninstantiated type.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type.
 DEFINE_RUNTIME_ENTRY(InstantiateType, 2) {
   AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(0));
-  const AbstractTypeArguments& instantiator =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
+  const TypeArguments& instantiator =
+      TypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(!type.IsNull() && !type.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   Error& bound_error = Error::Handle();
   type = type.InstantiateFrom(instantiator, &bound_error);
   if (!bound_error.IsNull()) {
     // Throw a dynamic type error.
     const intptr_t location = GetCallerLocation();
     String& bound_error_message =  String::Handle(
         String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(
         location, Symbols::Empty(), Symbols::Empty(),
         Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   if (type.IsTypeRef()) {
     type = TypeRef::Cast(type).type();
     ASSERT(!type.IsTypeRef());
     ASSERT(type.IsCanonical());
   }
   ASSERT(!type.IsNull() && type.IsInstantiated());
   arguments.SetReturn(type);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type arguments.
 DEFINE_RUNTIME_ENTRY(InstantiateTypeArguments, 2) {
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(0));
-  const AbstractTypeArguments& instantiator =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
+  TypeArguments& type_arguments =
+      TypeArguments::CheckedHandle(arguments.ArgAt(0));
+  const TypeArguments& instantiator =
+      TypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(!type_arguments.IsNull() && !type_arguments.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
   // Code inlined in the caller should have optimized the case where the
   // instantiator can be reused as type argument vector.
   ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
-  type_arguments = InstantiatedTypeArguments::New(type_arguments, instantiator);
+  type_arguments =
+      type_arguments.InstantiateAndCanonicalizeFrom(instantiator, NULL);
   ASSERT(type_arguments.IsInstantiated());
   arguments.SetReturn(type_arguments);
 }
 
 
 // Allocate a new closure.
 // The type argument vector of a closure is always the vector of type parameters
 // of its signature class, i.e. an uninstantiated identity vector. Therefore,
 // the instantiator type arguments can be used as the instantiated closure type
 // arguments and is passed here as the type arguments.
 // Arg0: local function.
 // Arg1: type arguments of the closure (i.e. instantiator).
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateClosure, 2) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(function.IsClosureFunction() && !function.IsImplicitClosureFunction());
-  const AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
+  const TypeArguments& type_arguments =
+      TypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   // The current context was saved in the Isolate structure when entering the
   // runtime.
   const Context& context = Context::Handle(isolate->top_context());
   ASSERT(!context.IsNull());
   const Instance& closure = Instance::Handle(Closure::New(function, context));
   Closure::SetTypeArguments(closure, type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new implicit instance closure.
 // Arg0: local function.
 // Arg1: receiver object.
 // Arg2: type arguments of the closure.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitInstanceClosure, 3) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(function.IsImplicitInstanceClosureFunction());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(1));
-  const AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
+  const TypeArguments& type_arguments =
+      TypeArguments::CheckedHandle(arguments.ArgAt(2));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   Context& context = Context::Handle();
   context = Context::New(1);
   context.SetAt(0, receiver);
   const Instance& closure = Instance::Handle(Closure::New(function, context));
   Closure::SetTypeArguments(closure, type_arguments);
   arguments.SetReturn(closure);
 }
 
 
@@ skipping 19 matching lines @@
   }
   arguments.SetReturn(cloned_ctx);
 }
 
 
 // Helper routine for tracing a type check.
 static void PrintTypeCheck(
     const char* message,
     const Instance& instance,
     const AbstractType& type,
-    const AbstractTypeArguments& instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     const Bool& result) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const Type& instance_type = Type::Handle(instance.GetType());
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
     OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n",
                  message,
@@ skipping 18 matching lines @@
     if (!bound_error.IsNull()) {
       OS::Print("  bound error: %s\n", bound_error.ToErrorCString());
     }
   }
   const Function& function = Function::Handle(
       caller_frame->LookupDartFunction());
   OS::PrintErr(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
 
-// Converts InstantiatedTypeArguments to TypeArguments and stores it
-// into the instance. The assembly code can handle only type arguments of
-// class TypeArguments. Because of the overhead, do it only when needed.
-// Return true if type arguments have been replaced, false otherwise.
-static bool OptimizeTypeArguments(const Instance& instance) {
-  const Class& type_class = Class::ZoneHandle(instance.clazz());
-  if (type_class.NumTypeArguments() == 0) {
-    return false;
-  }
-  AbstractTypeArguments& type_arguments =
-      AbstractTypeArguments::Handle(instance.GetTypeArguments());
-  if (type_arguments.IsNull()) {
-    return false;
-  }
-  bool replaced = false;
-  if (type_arguments.IsInstantiatedTypeArguments()) {
-    AbstractTypeArguments& uninstantiated = AbstractTypeArguments::Handle();
-    AbstractTypeArguments& instantiator = AbstractTypeArguments::Handle();
-    do {
-      const InstantiatedTypeArguments& instantiated_type_arguments =
-          InstantiatedTypeArguments::Cast(type_arguments);
-      uninstantiated =
-          instantiated_type_arguments.uninstantiated_type_arguments();
-      instantiator = instantiated_type_arguments.instantiator_type_arguments();
-      Error& bound_error = Error::Handle();
-      type_arguments = uninstantiated.InstantiateFrom(instantiator,
-                                                      &bound_error);
-      ASSERT(bound_error.IsNull());  // Malbounded types are not optimized.
-    } while (type_arguments.IsInstantiatedTypeArguments());
-    AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
-    new_type_arguments = type_arguments.Canonicalize();
-    instance.SetTypeArguments(new_type_arguments);
-    replaced = true;
-  } else if (!type_arguments.IsCanonical()) {
-    AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
-    new_type_arguments = type_arguments.Canonicalize();
-    instance.SetTypeArguments(new_type_arguments);
-    replaced = true;
-  }
-  ASSERT(AbstractTypeArguments::Handle(
-      instance.GetTypeArguments()).IsTypeArguments());
-  return replaced;
-}
-
-
 // This updates the type test cache, an array containing 4-value elements
 // (instance class, instance type arguments, instantiator type arguments and
 // test_result). It can be applied to classes with type arguments in which
 // case it contains just the result of the class subtype test, not including
 // the evaluation of type arguments.
 // This operation is currently very slow (lookup of code is not efficient yet).
 // 'instantiator' can be null, in which case inst_targ
 static void UpdateTypeTestCache(
     const Instance& instance,
     const AbstractType& type,
     const Instance& instantiator,
-    const AbstractTypeArguments& incoming_instantiator_type_arguments,
+    const TypeArguments& instantiator_type_arguments,
     const Bool& result,
     const SubtypeTestCache& new_cache) {
   // Since the test is expensive, don't do it unless necessary.
   // The list of disallowed cases will decrease as they are implemented in
   // inlined assembly.
   if (new_cache.IsNull()) {
     if (FLAG_trace_type_checks) {
       OS::Print("UpdateTypeTestCache: cache is null\n");
     }
     return;
   }
-  // Instantiator type arguments may be canonicalized later.
-  AbstractTypeArguments& instantiator_type_arguments =
-      AbstractTypeArguments::Handle(incoming_instantiator_type_arguments.raw());
-  AbstractTypeArguments& instance_type_arguments =
-      AbstractTypeArguments::Handle();
+  if (instance.IsSmi()) {
+    if (FLAG_trace_type_checks) {
+      OS::Print("UpdateTypeTestCache: instance is Smi\n");
+    }
+    return;
+  }
+  TypeArguments& instance_type_arguments =
+      TypeArguments::Handle();

[srdjan, 2014/02/07 21:59:47]

This should fit on one line.

   const Class& instance_class = Class::Handle(instance.clazz());
 
-  // Canonicalize type arguments.
-  bool type_arguments_replaced = false;
   if (instance_class.NumTypeArguments() > 0) {
-    // Canonicalize type arguments.
-    type_arguments_replaced = OptimizeTypeArguments(instance);
     instance_type_arguments = instance.GetTypeArguments();
   }
-  if (!instantiator.IsNull()) {
-    if (OptimizeTypeArguments(instantiator)) {
-      type_arguments_replaced = true;
-    }
-    instantiator_type_arguments = instantiator.GetTypeArguments();
-  }
 
-  intptr_t last_instance_class_id = -1;
-  AbstractTypeArguments& last_instance_type_arguments =
-      AbstractTypeArguments::Handle();
-  AbstractTypeArguments& last_instantiator_type_arguments =
-      AbstractTypeArguments::Handle();
-  Bool& last_result = Bool::Handle();
   const intptr_t len = new_cache.NumberOfChecks();
   if (len >= FLAG_max_subtype_cache_entries) {
     return;
   }
+#if defined(DEBUG)
+  ASSERT(instance_type_arguments.IsNull() ||
+         instance_type_arguments.IsCanonical());
+  ASSERT(instantiator_type_arguments.IsNull() ||
+         instantiator_type_arguments.IsCanonical());
+  intptr_t last_instance_class_id = -1;
+  TypeArguments& last_instance_type_arguments =
+      TypeArguments::Handle();
+  TypeArguments& last_instantiator_type_arguments =
+      TypeArguments::Handle();
+  Bool& last_result = Bool::Handle();
   for (intptr_t i = 0; i < len; ++i) {
     new_cache.GetCheck(
         i,
         &last_instance_class_id,
         &last_instance_type_arguments,
         &last_instantiator_type_arguments,
         &last_result);
     if ((last_instance_class_id == instance_class.id()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
-      if (FLAG_trace_type_checks) {
-        OS::PrintErr("%" Pd " ", i);
-        if (type_arguments_replaced) {
-          PrintTypeCheck("Duplicate cache entry (canonical.)", instance, type,
-              instantiator_type_arguments, result);
-        } else {
-          PrintTypeCheck("WARNING Duplicate cache entry", instance, type,
-              instantiator_type_arguments, result);
-        }
-      }
-      // Can occur if we have canonicalized arguments.
-      // TODO(srdjan): Investigate why this assert can fail.
-      // ASSERT(type_arguments_replaced);
+      OS::PrintErr("  Error in test cache %p ix: %" Pd ",", new_cache.raw(), i);
+      PrintTypeCheck(" duplicate cache entry", instance, type,
+          instantiator_type_arguments, result);
+      UNREACHABLE();
       return;
     }
   }
-  if (!instantiator_type_arguments.IsInstantiatedTypeArguments()) {
-    new_cache.AddCheck(instance_class.id(),
-                       instance_type_arguments,
-                       instantiator_type_arguments,
-                       result);
-  }
+#endif
+  new_cache.AddCheck(instance_class.id(),
+                     instance_type_arguments,
+                     instantiator_type_arguments,
+                     result);
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       Error& bound_error = Error::Handle();
       test_type = type.InstantiateFrom(instantiator_type_arguments,
                                        &bound_error);
       ASSERT(bound_error.IsNull());  // Malbounded types are not optimized.
     }
     OS::PrintErr("  Updated test cache %p ix: %" Pd " with "
         "(cid: %" Pd ", type-args: %p, instantiator: %p, result: %s)\n"
@@ skipping 28 matching lines @@
 // Arg0: instance being checked.
 // Arg1: type.
 // Arg2: instantiator (or null).
 // Arg3: type arguments of the instantiator of the type.
 // Arg4: SubtypeTestCache.
 // Return value: true or false, or may throw a type error in checked mode.
 DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
   const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
   const AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(1));
   const Instance& instantiator = Instance::CheckedHandle(arguments.ArgAt(2));
-  const AbstractTypeArguments& instantiator_type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
+  const TypeArguments& instantiator_type_arguments =
+      TypeArguments::CheckedHandle(arguments.ArgAt(3));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(arguments.ArgAt(4));
   ASSERT(type.IsFinalized());
   ASSERT(!type.IsDynamicType());  // No need to check assignment.
   ASSERT(!type.IsMalformed());  // Already checked in code generator.
   ASSERT(!type.IsMalbounded());  // Already checked in code generator.
   Error& bound_error = Error::Handle();
   const Bool& result =
       Bool::Get(instance.IsInstanceOf(type,
                                       instantiator_type_arguments,
@@ skipping 26 matching lines @@
 // Arg3: type arguments of the instantiator of the type being assigned to.
 // Arg4: name of variable being assigned to.
 // Arg5: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
 DEFINE_RUNTIME_ENTRY(TypeCheck, 6) {
   const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
   const AbstractType& dst_type =
       AbstractType::CheckedHandle(arguments.ArgAt(1));
   const Instance& dst_instantiator =
       Instance::CheckedHandle(arguments.ArgAt(2));
-  const AbstractTypeArguments& instantiator_type_arguments =
-      AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
+  const TypeArguments& instantiator_type_arguments =
+      TypeArguments::CheckedHandle(arguments.ArgAt(3));
   const String& dst_name = String::CheckedHandle(arguments.ArgAt(4));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(arguments.ArgAt(5));
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
   ASSERT(!dst_type.IsMalformed());  // Already checked in code generator.
   ASSERT(!dst_type.IsMalbounded());  // Already checked in code generator.
   ASSERT(!src_instance.IsNull());  // Already checked in inlined code.
 
   Error& bound_error = Error::Handle();
   const bool is_instance_of = src_instance.IsInstanceOf(
@@ skipping 1074 matching lines @@
 // of the given value.
 //   Arg0: Field object;
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
   field.UpdateGuardedCidAndLength(value);
 }
 
 }  // namespace dart