Allocate types in proper heap space.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2012, 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 301 matching lines @@
 // Resolve unresolved supertype (String -> Class).
 void ClassFinalizer::ResolveSuperType(const Class& cls) {
   if (cls.is_finalized()) {
     return;
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (super_type.IsNull()) {
     return;
   }
   // Resolve failures lead to a longjmp.
-  ResolveType(cls, super_type, kFinalizeWellFormed);
+  ResolveType(cls, super_type, kCanonicalizeWellFormed);
   const Class& super_class = Class::Handle(super_type.type_class());
   if (cls.is_interface() != super_class.is_interface()) {
     String& class_name = String::Handle(cls.Name());
     String& super_class_name = String::Handle(super_class.Name());
     const Script& script = Script::Handle(cls.script());
     ReportError(script, cls.token_pos(),
                 "class '%s' and superclass '%s' are not "
                 "both classes or both interfaces",
                 class_name.ToCString(),
                 super_class_name.ToCString());
@@ skipping 192 matching lines @@
 
 
 void ClassFinalizer::FinalizeTypeParameters(const Class& cls) {
   const TypeArguments& type_parameters =
       TypeArguments::Handle(cls.type_parameters());
   if (!type_parameters.IsNull()) {
     TypeParameter& type_parameter = TypeParameter::Handle();
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
-      type_parameter ^= FinalizeType(cls, type_parameter, kFinalizeWellFormed);
+      type_parameter ^= FinalizeType(cls,
+                                     type_parameter,
+                                     kCanonicalizeWellFormed);
       type_parameters.SetTypeAt(i, type_parameter);
     }
   }
 }
 
 
 // Finalize the type argument vector 'arguments' of the type defined by the
 // class 'cls' parameterized with the type arguments 'cls_args'.
 // The vector 'cls_args' is already initialized as a subvector at the correct
 // position in the passed in 'arguments' vector.
@@ skipping 46 matching lines @@
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumTypeParameters()));
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = 0; i < num_super_type_params; i++) {
       if (!super_type_args.IsNull()) {
         super_type_arg = super_type_args.TypeAt(super_offset + i);
         if (!super_type_arg.IsInstantiated()) {
           super_type_arg = super_type_arg.InstantiateFrom(arguments);
         }
-        super_type_arg = super_type_arg.Canonicalize();
+        if (finalization >= kCanonicalize) {
+          super_type_arg = super_type_arg.Canonicalize();
+        }
       }
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments, finalization);
   }
 }
 
 
 RawAbstractType* ClassFinalizer::FinalizeType(const Class& cls,
                                               const AbstractType& type,
                                               FinalizationKind finalization) {
   if (type.IsFinalized()) {
     return type.raw();
   }
   ASSERT(type.IsResolved());
-  ASSERT((finalization == kFinalize) || (finalization == kFinalizeWellFormed));
+  ASSERT(finalization >= kFinalize);
 
   if (FLAG_trace_type_finalization) {
     OS::Print("Finalize type '%s'\n", String::Handle(type.Name()).ToCString());
   }
 
   if (type.IsTypeParameter()) {
     const TypeParameter& type_parameter = TypeParameter::Cast(type);
     const Class& parameterized_class =
         Class::Handle(type_parameter.parameterized_class());
     ASSERT(!parameterized_class.IsNull());
@@ skipping 112 matching lines @@
         ASSERT(!signature_fun.is_static());
         const Class& sig_fun_owner = Class::Handle(signature_fun.owner());
         FinalizeTypeArguments(sig_fun_owner, full_arguments, finalization);
       } else {
         FinalizeTypeArguments(type_class, full_arguments, finalization);
       }
       if (full_arguments.IsRaw(num_type_arguments)) {
         // The parameterized_type is raw. Set its argument vector to null, which
         // is more efficient in type tests.
         full_arguments = TypeArguments::null();
-      } else {
+      } else if (finalization >= kCanonicalize) {
         // FinalizeTypeArguments can modify 'full_arguments',
         // canonicalize afterwards.
         full_arguments ^= full_arguments.Canonicalize();
       }
       parameterized_type.set_arguments(full_arguments);
     } else {
       ASSERT(full_arguments.IsNull());  // Use null vector for raw type.
     }
   }
 
@@ skipping 53 matching lines @@
       // This type is a function type alias. Its class may need to be finalized
       // and checked for illegal self reference.
       FinalizeClass(type_class, false);
       // Finalizing the signature function here (as in the canonical case above)
       // would not mark the canonical signature type as finalized.
       const Type& signature_type = Type::Handle(type_class.SignatureType());
       FinalizeType(cls, signature_type, finalization);
     }
   }
 
-  return parameterized_type.Canonicalize();
+  if (finalization >= kCanonicalize) {
+    return parameterized_type.Canonicalize();
+  } else {
+    return parameterized_type.raw();
+  }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
   // In case of a factory, the parser sets the factory result type to a type
   // with an unresolved class whose name matches the factory name.
   // It is not a compile time error if this name does not resolve to a class or
   // interface.
-  ResolveType(cls, type, kFinalize);
-  type = FinalizeType(cls, type, kFinalize);
+  ResolveType(cls, type, kCanonicalize);
+  type = FinalizeType(cls, type, kCanonicalize);
   // In production mode, a malformed result type is mapped to Dynamic.
   if (!FLAG_enable_type_checks && type.IsMalformed()) {
     type = Type::DynamicType();
   }
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
-    ResolveType(cls, type, kFinalize);
-    type = FinalizeType(cls, type, kFinalize);
+    ResolveType(cls, type, kCanonicalize);
+    type = FinalizeType(cls, type, kCanonicalize);
     // In production mode, a malformed parameter type is mapped to Dynamic.
     if (!FLAG_enable_type_checks && type.IsMalformed()) {
       type = Type::DynamicType();
     }
     function.SetParameterTypeAt(i, type);
   }
 }
 
 
 static RawClass* FindSuperOwnerOfInstanceMember(const Class& cls,
@@ skipping 43 matching lines @@
   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()) {
       continue;
     }
-    ResolveType(cls, bound, kFinalize);
-    bound = FinalizeType(cls, bound, kFinalize);
+    ResolveType(cls, bound, kCanonicalize);
+    bound = FinalizeType(cls, bound, kCanonicalize);
     type_param.set_bound(bound);
   }
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeMemberTypes(const Class& cls) {
   // Note that getters and setters are explicitly listed as such in the list of
   // functions of a class, so we do not need to consider fields as implicitly
   // generating getters and setters.
   // The only compile errors we report are therefore:
   // - a getter having the same name as a method (but not a getter) in a super
   //   class or in a subclass.
   // - a setter having the same name as a method (but not a setter) in a super
   //   class or in a subclass.
   // - a static field, instance field, or static method (but not an instance
   //   method) having the same name as an instance member in a super class.
 
   // Resolve type of fields and check for conflicts in super classes.
   Array& array = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   AbstractType& type = AbstractType::Handle();
   String& name = String::Handle();
   Class& super_class = Class::Handle();
   intptr_t num_fields = array.Length();
   for (intptr_t i = 0; i < num_fields; i++) {
     field ^= array.At(i);
     type = field.type();
-    ResolveType(cls, type, kFinalize);
-    type = FinalizeType(cls, type, kFinalize);
+    ResolveType(cls, type, kCanonicalize);
+    type = FinalizeType(cls, type, kCanonicalize);
     field.set_type(type);
     name = field.name();
     super_class = FindSuperOwnerOfInstanceMember(cls, name);
     if (!super_class.IsNull()) {
       const String& class_name = String::Handle(cls.Name());
       const String& super_class_name = String::Handle(super_class.Name());
       const Script& script = Script::Handle(cls.script());
       ReportError(script, field.token_pos(),
                   "field '%s' of class '%s' conflicts with instance "
                   "member '%s' of super class '%s'",
@@ skipping 141 matching lines @@
   // Finalize super class.
   const Class& super_class = Class::Handle(cls.SuperClass());
   if (!super_class.IsNull()) {
     FinalizeClass(super_class, generating_snapshot);
   }
   // Finalize type parameters before finalizing the super type.
   FinalizeTypeParameters(cls);
   // Finalize super type.
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
-    super_type ^= FinalizeType(cls, super_type, kFinalizeWellFormed);
+    super_type ^= FinalizeType(cls, super_type, kCanonicalizeWellFormed);
     cls.set_super_type(super_type);
   }
   // Signature classes are finalized upon creation, except function type
   // aliases.
   if (cls.IsSignatureClass()) {
     ASSERT(!cls.IsCanonicalSignatureClass());
     // Check for illegal self references.
     GrowableArray<intptr_t> visited_aliases;
     if (!IsAliasCycleFree(cls, &visited_aliases)) {
       const String& name = String::Handle(cls.Name());
@@ skipping 16 matching lines @@
           return;
         }
       }
     }
   }
   // Finalize interface types (but not necessarily interface classes).
   Array& interface_types = Array::Handle(cls.interfaces());
   AbstractType& interface_type = AbstractType::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
-    interface_type = FinalizeType(cls, interface_type, kFinalizeWellFormed);
+    interface_type = FinalizeType(cls, interface_type, kCanonicalizeWellFormed);
     interface_types.SetAt(i, interface_type);
   }
   // Mark as finalized before resolving type parameter upper bounds and member
   // types in order to break cycles.
   cls.Finalize();
   ResolveAndFinalizeUpperBounds(cls);
   ResolveAndFinalizeMemberTypes(cls);
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
@@ skipping 50 matching lines @@
       // We have already visited alias 'cls'. We found a cycle.
       return false;
     }
   }
 
   // Visit the result type and parameter types of this signature type.
   visited->Add(cls.id());
   const Function& function = Function::Handle(cls.signature_function());
   // Check class of result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
-  ResolveType(cls, type, kFinalize);
+  ResolveType(cls, type, kCanonicalize);
   if (type.IsType() && !type.IsMalformed()) {
     const Class& type_class = Class::Handle(type.type_class());
     if (!type_class.is_finalized() &&
         type_class.IsSignatureClass() &&
         !type_class.IsCanonicalSignatureClass()) {
       if (!IsAliasCycleFree(type_class, visited)) {
         return false;
       }
     }
   }
   // Check classes of formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
-    ResolveType(cls, type, kFinalize);
+    ResolveType(cls, type, kCanonicalize);
     if (type.IsType() && !type.IsMalformed()) {
       const Class& type_class = Class::Handle(type.type_class());
       if (!type_class.is_finalized() &&
           type_class.IsSignatureClass() &&
           !type_class.IsCanonicalSignatureClass()) {
         if (!IsAliasCycleFree(type_class, visited)) {
           return false;
         }
       }
     }
@@ skipping 66 matching lines @@
   const bool cls_belongs_to_core_lib =
       (cls.library() == Library::CoreLibrary()) ||
       (cls.library() == Library::CoreImplLibrary());
 
   // Resolve and check the interfaces of cls.
   visited->Add(cls_index);
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
   for (intptr_t i = 0; i < super_interfaces.Length(); i++) {
     interface ^= super_interfaces.At(i);
-    ResolveType(cls, interface, kFinalizeWellFormed);
+    ResolveType(cls, interface, kCanonicalizeWellFormed);
     if (interface.IsTypeParameter()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
                   "type parameter '%s' cannot be used as interface",
                   String::Handle(interface.Name()).ToCString());
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const Script& script = Script::Handle(cls.script());
       ReportError(script, cls.token_pos(),
@@ skipping 109 matching lines @@
 void ClassFinalizer::FinalizeMalformedType(const Error& prev_error,
                                            const Class& cls,
                                            const Type& type,
                                            FinalizationKind finalization,
                                            const char* format, ...) {
   va_list args;
   va_start(args, format);
   LanguageError& error = LanguageError::Handle();
   if (FLAG_enable_type_checks ||
       !type.HasResolvedTypeClass() ||
-      (finalization == kFinalizeWellFormed)) {
+      (finalization == kCanonicalizeWellFormed)) {
     const Script& script = Script::Handle(cls.script());
     if (prev_error.IsNull()) {
       error ^= Parser::FormatError(
           script, type.token_pos(), "Error", format, args);
     } else {
       error ^= Parser::FormatErrorWithAppend(
           prev_error, script, type.token_pos(), "Error", format, args);
     }
-    if (finalization == kFinalizeWellFormed) {
+    if (finalization == kCanonicalizeWellFormed) {
       ReportError(error);
     }
   }
   if (FLAG_enable_type_checks || !type.HasResolvedTypeClass()) {
     // In check mode, always mark the type as malformed.
     // In production mode, mark the type as malformed only if its type class is
     // not resolved.
     type.set_malformed_error(error);
   } else {
      // In production mode, do not mark the type with a resolved type class as
@@ skipping 32 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