Version 0.4.3.5

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 609 matching lines @@
   // production mode and checked mode, because the finalized type may be written
   // to a snapshot. It would be wrong to ignore bounds when generating the
   // snapshot in production mode and then use the unchecked type in checked mode
   // after reading it from the snapshot.
   // However, we do not immediately report a bound error, which would be wrong
   // in production mode, but simply postpone the bound checking to runtime.
   const intptr_t num_type_params = cls.NumTypeParameters();
   const intptr_t offset = cls.NumTypeArguments() - num_type_params;
   AbstractType& type_arg = AbstractType::Handle();
   AbstractType& cls_type_param = AbstractType::Handle();
-  AbstractType& bound = AbstractType::Handle();
+  AbstractType& declared_bound = AbstractType::Handle();
+  AbstractType& instantiated_bound = AbstractType::Handle();
   const TypeArguments& cls_type_params =
       TypeArguments::Handle(cls.type_parameters());
   ASSERT((cls_type_params.IsNull() && (num_type_params == 0)) ||
          (cls_type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_arg = arguments.TypeAt(offset + i);
     if (type_arg.IsDynamicType()) {
       continue;
     }
     cls_type_param = cls_type_params.TypeAt(i);
     const TypeParameter& type_param = TypeParameter::Cast(cls_type_param);
     ASSERT(type_param.IsFinalized());
-    bound = type_param.bound();
-    if (!bound.IsObjectType() && !bound.IsDynamicType()) {
+    declared_bound = type_param.bound();
+    if (!declared_bound.IsObjectType() && !declared_bound.IsDynamicType()) {
       Error& malformed_error = Error::Handle();
       // Note that the bound may be malformed, in which case the bound check
       // will return an error and the bound check will be postponed to run time.
       // Note also that the bound may still be unfinalized.
-      if (!bound.IsFinalized()) {
-        ASSERT(bound.IsBeingFinalized());
+      if (!declared_bound.IsFinalized()) {
+        ASSERT(declared_bound.IsBeingFinalized());
         // The bound refers to type parameters, creating a cycle; postpone
         // bound check to run time, when the bound will be finalized.
         // TODO(regis): Do we need to instantiate an uninstantiated bound here?
-        type_arg = BoundedType::New(type_arg, bound, type_param);
+        type_arg = BoundedType::New(type_arg, declared_bound, type_param);
         arguments.SetTypeAt(offset + i, type_arg);
         continue;
       }
-      if (!bound.IsInstantiated()) {
-        bound = bound.InstantiateFrom(arguments, &malformed_error);
+      if (declared_bound.IsInstantiated()) {
+        instantiated_bound = declared_bound.raw();
+      } else {
+        instantiated_bound =
+            declared_bound.InstantiateFrom(arguments, &malformed_error);
       }
       // TODO(regis): We could simplify this code if we could differentiate
       // between a failed bound check and a bound check that is undecidable at
       // compile time.
-      if (malformed_error.IsNull()) {
-        type_param.CheckBound(type_arg, bound, &malformed_error);
+      // Shortcut the special case where we check a type parameter against its
+      // declared upper bound.
+      if (malformed_error.IsNull() &&
+          (!type_arg.Equals(type_param) ||
+           !instantiated_bound.Equals(declared_bound))) {
+        type_param.CheckBound(type_arg, instantiated_bound, &malformed_error);
       }
       if (!malformed_error.IsNull()) {
-        if (!type_arg.IsInstantiated() || !bound.IsInstantiated()) {
-          type_arg = BoundedType::New(type_arg, bound, type_param);
+        if (!type_arg.IsInstantiated() ||
+            !instantiated_bound.IsInstantiated()) {
+          type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
           arguments.SetTypeAt(offset + i, type_arg);
         } else if (bound_error->IsNull()) {
           *bound_error = malformed_error.raw();
         }
       }
     }
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
@@ skipping 334 matching lines @@
   const intptr_t num_type_params = cls.NumTypeParameters();
   TypeParameter& type_param = TypeParameter::Handle();
   AbstractType& bound = AbstractType::Handle();
   const AbstractTypeArguments& type_params =
       AbstractTypeArguments::Handle(cls.type_parameters());
   ASSERT((type_params.IsNull() && (num_type_params == 0)) ||
          (type_params.Length() == num_type_params));
   for (intptr_t i = 0; i < num_type_params; i++) {
     type_param ^= type_params.TypeAt(i);
     bound = type_param.bound();
-    if (bound.IsFinalized()) {
+    if (bound.IsFinalized() || bound.IsBeingFinalized()) {
+      // A bound involved in F-bounded quantification may form a cycle.
       continue;
     }
     ResolveType(cls, bound, kCanonicalize);
     bound = FinalizeType(cls, bound, kCanonicalize);
     type_param.set_bound(bound);
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
@@ skipping 950 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart