Allocate types in proper heap space.

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1035 matching lines @@
     // We either parse a type or assume that no type is specified.
     if ((follower == Token::kLT) ||  // Parameterized type.
         (follower == Token::kPERIOD) ||  // Qualified class name of type.
         Token::IsIdentifier(follower) ||  // Parameter name following a type.
         (follower == Token::kTHIS)) {  // Field parameter following a type.
       // The types of formal parameters are never ignored, even in unchecked
       // mode, because they are part of the function type of closurized
       // functions appearing in type tests with typedefs.
       parameter.type = &AbstractType::ZoneHandle(
           ParseType(is_top_level_ ? ClassFinalizer::kTryResolve :
-                                    ClassFinalizer::kFinalize));
+                                    ClassFinalizer::kCanonicalize));
     } else {
       parameter.type = &Type::ZoneHandle(Type::DynamicType());
     }
   }
   if (!this_seen && (CurrentToken() == Token::kTHIS)) {
     ConsumeToken();
     ExpectToken(Token::kPERIOD);
     this_seen = true;
     parameter.is_field_initializer = true;
   }
@@ skipping 52 matching lines @@
                                                    script_);
         // Record the function signature class in the current library.
         library_.AddClass(signature_class);
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         signature_type ^= ClassFinalizer::FinalizeType(
-            signature_class, signature_type, ClassFinalizer::kFinalize);
+            signature_class, signature_type, ClassFinalizer::kCanonicalize);
       }
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
   if (CurrentToken() == Token::kASSIGN) {
     if (!params->has_named_optional_parameters ||
         !allow_explicit_default_value) {
       ErrorMsg("parameter must not specify a default value");
@@ skipping 3018 matching lines @@
 }
 
 
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   bool is_final = (CurrentToken() == Token::kFINAL);
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-      FLAG_enable_type_checks ? ClassFinalizer::kFinalize :
+      FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
                                 ClassFinalizer::kIgnore));
   if (!IsIdentifier()) {
     ErrorMsg("identifier expected");
   }
 
   AstNode* initializers = ParseVariableDeclaration(type, is_final);
   ASSERT(initializers != NULL);
   while (CurrentToken() == Token::kCOMMA) {
     ConsumeToken();
     if (!IsIdentifier()) {
@@ skipping 16 matching lines @@
   AbstractType& result_type = AbstractType::Handle();
   const String* variable_name = NULL;
   const String* function_name = NULL;
 
   result_type = Type::DynamicType();
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if ((CurrentToken() == Token::kIDENT) &&
              (LookaheadToken(1) != Token::kLPAREN)) {
-    result_type = ParseType(ClassFinalizer::kFinalize);
+    result_type = ParseType(ClassFinalizer::kCanonicalize);
   }
   const intptr_t ident_pos = TokenPos();
   if (IsIdentifier()) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
@@ skipping 106 matching lines @@
     // We need to create a new type for proper finalization, since the existing
     // type is already marked as finalized.
     Type& signature_type = Type::Handle(signature_class.SignatureType());
     const AbstractTypeArguments& signature_type_arguments =
         AbstractTypeArguments::Handle(signature_type.arguments());
 
     // Since the signature type is cached by the signature class, it may have
     // been finalized already.
     if (!signature_type.IsFinalized()) {
       signature_type ^= ClassFinalizer::FinalizeType(
-          signature_class, signature_type, ClassFinalizer::kFinalize);
+          signature_class, signature_type, ClassFinalizer::kCanonicalize);
       // The call to ClassFinalizer::FinalizeType may have
       // extended the vector of type arguments.
       ASSERT(signature_type_arguments.IsNull() ||
              (signature_type_arguments.Length() ==
               signature_class.NumTypeArguments()));
       // The signature_class should not have changed.
       ASSERT(signature_type.type_class() == signature_class.raw());
     }
 
     // Now patch the function type of the variable.
@@ skipping 546 matching lines @@
   bool is_final = (CurrentToken() == Token::kFINAL);
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
-      FLAG_enable_type_checks ? ClassFinalizer::kFinalize :
+      FLAG_enable_type_checks ? ClassFinalizer::kCanonicalize :
                                 ClassFinalizer::kIgnore));
     loop_var_pos = TokenPos();
     loop_var_name = ExpectIdentifier("variable name expected");
     loop_var = new LocalVariable(loop_var_pos, *loop_var_name, type);
     if (is_final) {
       loop_var->set_is_final();
     }
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
@@ skipping 235 matching lines @@
 
 
 // Parse the parameter specified in the catch clause.
 void Parser::ParseCatchParameter(CatchParamDesc* catch_param) {
   TRACE_PARSER("ParseCatchParameter");
   ASSERT(catch_param != NULL);
   catch_param->is_final = (CurrentToken() == Token::kFINAL);
   // The type of the catch parameter must always be resolved, even in unchecked
   // mode.
   catch_param->type = &AbstractType::ZoneHandle(
-      ParseFinalVarOrType(ClassFinalizer::kFinalizeWellFormed));
+      ParseFinalVarOrType(ClassFinalizer::kCanonicalizeWellFormed));
   catch_param->token_pos = TokenPos();
   catch_param->var = ExpectIdentifier("identifier expected");
 }
 
 
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(const CatchParamDesc& exception_param,
                                    const CatchParamDesc& stack_trace_param,
                                    LocalScope* scope) {
   ASSERT(exception_param.var != NULL);
@@ skipping 814 matching lines @@
       if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' and 'as' we expect the right operand to be a type.
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
         const AbstractType& type =
-            AbstractType::ZoneHandle(ParseType(ClassFinalizer::kFinalize));
+            AbstractType::ZoneHandle(ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureReceiver();
         }
         right_operand = new TypeNode(type_pos, type);
         if ((op_kind == Token::kIS) && type.IsMalformed()) {
           // Note that a type error is thrown even if the tested value is null
           // in a type test. However, no cast exception is thrown if the value
           // is null in a type cast.
@@ skipping 879 matching lines @@
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Local lookup in library prefix scope.
       resolved_type_class = lib_prefix.LookupLocalClass(unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
-    } else if (finalization >= ClassFinalizer::kFinalize) {
+    } else if (finalization >= ClassFinalizer::kCanonicalize) {
       // The type is malformed.
       ClassFinalizer::FinalizeMalformedType(
           Error::Handle(),  // No previous error.
           current_class(), parameterized_type, finalization,
           "type '%s' is not loaded",
           String::Handle(parameterized_type.Name()).ToCString());
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
@@ skipping 542 matching lines @@
   if (FLAG_enable_type_checks && !malformed_error.IsNull()) {
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type.raw();
     parameterized_type.set_type_class(Class::Handle(Object::dynamic_class()));
     parameterized_type.set_arguments(AbstractTypeArguments::Handle());
     parameterized_type.set_malformed_error(malformed_error);
   }
   if (finalization >= ClassFinalizer::kTryResolve) {
     const Class& scope_class = Class::Handle(TypeParametersScopeClass());
     ResolveTypeFromClass(scope_class, finalization, &type);
-    if (finalization >= ClassFinalizer::kFinalize) {
+    if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= ClassFinalizer::FinalizeType(current_class(), type, finalization);
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
@@ skipping 361 matching lines @@
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = TokenPos();
   Error& malformed_error = Error::Handle();
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle(
       ParseTypeArguments(&malformed_error,
-                         ClassFinalizer::kFinalizeWellFormed));
+                         ClassFinalizer::kCanonicalizeWellFormed));
   // Map and List interfaces do not declare bounds on their type parameters, so
   // we should never see a malformed type error here.
   // Note that a bound error is the only possible malformed type error returned
-  // when requesting kFinalizeWellFormed type finalization.
+  // when requesting kCanonicalizeWellFormed type finalization.
   ASSERT(malformed_error.IsNull());
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
@@ skipping 21 matching lines @@
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   const AbstractType& type = AbstractType::Handle(
-      ParseType(ClassFinalizer::kFinalizeWellFormed));
+      ParseType(ClassFinalizer::kCanonicalizeWellFormed));
   // Malformed bounds never result in a compile time error, therefore, the
-  // parsed type may be malformed although we requested kFinalizeWellFormed.
+  // parsed type may be malformed although we requested kCanonicalizeWellFormed.
   // In that case, we throw a dynamic type error instead of calling the
   // constructor.
   if (type.IsTypeParameter()) {
     ErrorMsg(type_pos,
              "type parameter '%s' cannot be instantiated",
              String::Handle(type.Name()).ToCString());
   }
   if (type.IsDynamicType()) {
     ErrorMsg(type_pos, "Dynamic cannot be instantiated");
   }
@@ skipping 111 matching lines @@
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   // The type argument vector of the parsed type was finalized in ParseType.
   // If the constructor class was changed from the interface class to the
   // factory class, we need to finalize the type argument vector again, because
   // it may be longer due to the factory class extending a class, or/and because
   // the bounds on the factory class may be tighter than on the interface.
   if (constructor_class.raw() != type_class.raw()) {
     const intptr_t num_type_parameters = constructor_class.NumTypeParameters();
-    // TODO(regis): Temporary type args should be allocated in new gen heap.
     TypeArguments& temp_type_arguments = TypeArguments::Handle();
     if (!type_arguments.IsNull()) {
       // Copy the parsed type arguments starting at offset 0, because interfaces
       // have no super types.
       ASSERT(type_class.NumTypeArguments() == type_class.NumTypeParameters());
       const intptr_t num_type_arguments = type_arguments.Length();
-      temp_type_arguments = TypeArguments::New(num_type_parameters);
+      temp_type_arguments = TypeArguments::New(num_type_parameters, Heap::kNew);
       AbstractType& type_argument = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         if (i < num_type_arguments) {
           type_argument = type_arguments.TypeAt(i);
         } else {
           type_argument = Type::DynamicType();
         }
         temp_type_arguments.SetTypeAt(i, type_argument);
       }
     }
-    // TODO(regis): Temporary type should be allocated in new gen heap.
-    Type& temp_type = Type::Handle(
-        Type::New(constructor_class, temp_type_arguments, type.token_pos()));
+    Type& temp_type = Type::Handle(Type::New(
+         constructor_class, temp_type_arguments, type.token_pos(), Heap::kNew));
+    // No need to canonicalize temporary type.
     temp_type ^= ClassFinalizer::FinalizeType(
         current_class(), temp_type, ClassFinalizer::kFinalize);
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the temporary type.
     type_arguments = temp_type.arguments();
     // The type parameter bounds of the factory class may be more specific than
     // the type parameter bounds of the interface class. Therefore, although
     // type was not malformed, temp_type may be malformed.
     if (!type.IsMalformed() && temp_type.IsMalformed()) {
       const Error& error = Error::Handle(temp_type.malformed_error());
@@ skipping 607 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart