Add an assertion to ensure that the return type and types of parameters are canonical or a TypeParam

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 53 matching lines @@
 
 const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
 
+#if defined(DEBUG)
+// An object visitor which will iterate over all the function objects in the
+// heap and check if the result type and parameter types are canonicalized
+// or not. An assertion is raised if a type is not canonicalized.
+class FunctionVisitor : public ObjectVisitor {
+ public:
+  explicit FunctionVisitor(Isolate* isolate) :
+      ObjectVisitor(isolate),
+      classHandle_(Class::Handle(isolate)),
+      funcHandle_(Function::Handle(isolate)),
+      typeHandle_(AbstractType::Handle(isolate)) {}
+
+  void VisitObject(RawObject* obj) {
+    if (obj->IsFunction()) {
+      funcHandle_ ^= obj;
+      classHandle_ ^= funcHandle_.Owner();
+      // Verify that the result type of a function is canonical or a
+      // TypeParameter.
+      typeHandle_ ^= funcHandle_.result_type();
+      ASSERT(typeHandle_.IsNull() ||
+             typeHandle_.IsTypeParameter() ||
+             typeHandle_.IsCanonical());
+      // Verify that the types in the function signature are all canonical or
+      // a TypeParameter.
+      const intptr_t num_parameters = funcHandle_.NumParameters();
+      for (intptr_t i = 0; i < num_parameters; i++) {
+        typeHandle_ = funcHandle_.ParameterTypeAt(i);
+        ASSERT(typeHandle_.IsTypeParameter() || typeHandle_.IsCanonical());
+      }
+    }
+  }
+
+ private:
+  Class& classHandle_;
+  Function& funcHandle_;
+  AbstractType& typeHandle_;
+};
+#endif  // #if defined(DEBUG).
+
+
 static RawInstance* GetListInstance(Isolate* isolate, const Object& obj) {
   if (obj.IsInstance()) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
     const Class& list_class =
         Class::Handle(core_lib.LookupClass(Symbols::List()));
     ASSERT(!list_class.IsNull());
     const Instance& instance = Instance::Cast(obj);
     const Class& obj_class = Class::Handle(isolate, obj.clazz());
     Error& malformed_type_error = Error::Handle(isolate);
     if (obj_class.IsSubtypeOf(Object::null_type_arguments(),
@@ skipping 1372 matching lines @@
     RETURN_NULL_ERROR(isolate_snapshot_buffer);
   }
   if (isolate_snapshot_size == NULL) {
     RETURN_NULL_ERROR(isolate_snapshot_size);
   }
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(isolate);
   if (::Dart_IsError(state)) {
     return state;
   }
+  isolate->heap()->CollectAllGarbage();
+#if defined(DEBUG)
+  FunctionVisitor check_canonical(isolate);
+  isolate->heap()->VisitObjects(&check_canonical);
+#endif  // #if defined(DEBUG).
+
   // Since this is only a snapshot the root library should not be set.
   isolate->object_store()->set_root_library(Library::Handle(isolate));
   FullSnapshotWriter writer(vm_isolate_snapshot_buffer,
                             isolate_snapshot_buffer,
                             ApiReallocate);
   writer.WriteFullSnapshot();
   *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
   *isolate_snapshot_size = writer.IsolateSnapshotSize();
   return Api::Success();
 }
@@ skipping 4130 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart