Represent declared type parameters of a class as an array of TypeParameter

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 2601 matching lines @@
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
-  // Allocate an interface to hold the type parameters and their 'extends'
-  // constraints. Make it the owner of the function type descriptor.
+  // Allocate an interface to hold the type parameters and their bounds.
+  // Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol(":alias_owner")),
                  Script::Handle(),
                  token_index_));
   alias_owner.set_is_interface();
   alias_owner.set_library(library_);
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
@@ skipping 136 matching lines @@
                    script_,
                    factory_name.ident_pos));
     factory_class.set_library(library_);
     factory_class.set_is_finalized();
     ParseTypeParameters(factory_class);
     unresolved_factory_class.set_factory_signature_class(factory_class);
     interface.set_factory_class(unresolved_factory_class);
     // If a type parameter list is included in the default factory clause (it
     // can be omitted), verify that it matches the list of type parameters of
     // the interface in number and names.
-    const intptr_t num_default_type_params = factory_class.NumTypeParameters();
-    if (num_default_type_params > 0) {
-      String& interface_type_param_name = String::Handle();
-      String& factory_type_param_name = String::Handle();
-      const Array& interface_type_param_names =
-          Array::Handle(interface.type_parameters());
-      const Array& factory_type_param_names =
-          Array::Handle(factory_class.type_parameters());
-      bool mismatch = interface.NumTypeParameters() != num_default_type_params;
-      for (intptr_t i = 0; !mismatch && (i < num_default_type_params); i++) {
-        interface_type_param_name ^= interface_type_param_names.At(i);
-        factory_type_param_name ^= factory_type_param_names.At(i);
-        if (!interface_type_param_name.Equals(factory_type_param_name)) {
-          mismatch = true;
-        }
-      }
-      if (mismatch) {
+    if (factory_class.NumTypeParameters() > 0) {
+      const TypeArguments& interface_type_parameters =
+          TypeArguments::Handle(interface.type_parameters());
+      const TypeArguments& factory_type_parameters =
+          TypeArguments::Handle(factory_class.type_parameters());
+      if (!AbstractTypeArguments::AreEqual(interface_type_parameters,
+                                           factory_type_parameters)) {
         const String& interface_name = String::Handle(interface.Name());
         ErrorMsg(factory_name.ident_pos,
                  "mismatch in number or names of type parameters between "
                  "interface '%s' and default factory class '%s'.\n",
                  interface_name.ToCString(),
                  factory_name.ident->ToCString());
       }
     }
   }
 
@@ skipping 56 matching lines @@
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   if (CurrentToken() == Token::kLT) {
-    GrowableArray<String*> type_parameters;
-    GrowableArray<AbstractType*> type_parameter_extends;
+    GrowableArray<AbstractType*> type_parameters_array;
+    GrowableArray<AbstractType*> bounds_array;
+    intptr_t index = 0;
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
+      AbstractType& type_parameter = TypeParameter::ZoneHandle(
+          TypeParameter::New(index, type_parameter_name, token_index_));
       ConsumeToken();
-      AbstractType& type_extends = Type::ZoneHandle(Type::DynamicType());
+      AbstractType& bound = Type::ZoneHandle(Type::DynamicType());
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
-        type_extends = ParseType(kCanResolve);
+        bound = ParseType(kCanResolve);
       }
-      type_parameters.Add(&type_parameter_name);
-      type_parameter_extends.Add(&type_extends);
+      type_parameters_array.Add(&type_parameter);
+      bounds_array.Add(&bound);
+      index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
-    cls.set_type_parameters(Array::Handle(NewArray<String>(type_parameters)));
-    const TypeArguments& extends_array =
-        TypeArguments::Handle(NewTypeArguments(type_parameter_extends));
-    cls.set_type_parameter_extends(extends_array);
+    const TypeArguments& type_parameters =
+        TypeArguments::Handle(NewTypeArguments(type_parameters_array));
+    const TypeArguments& bounds =
+        TypeArguments::Handle(NewTypeArguments(bounds_array));
+    cls.set_type_parameters(type_parameters);
+    cls.set_type_parameter_bounds(bounds);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
-    AbstractType& type_extends = AbstractType::Handle();
-    const intptr_t num_types = extends_array.Length();
+    AbstractType& bound = AbstractType::Handle();
+    const intptr_t num_types = bounds.Length();
     for (intptr_t i = 0; i < num_types; i++) {
-      type_extends = extends_array.TypeAt(i);
-      ResolveTypeFromClass(cls, kCanResolve, &type_extends);
-      extends_array.SetTypeAt(i, type_extends);
+      bound = bounds.TypeAt(i);
+      ResolveTypeFromClass(cls, kCanResolve, &bound);
+      bounds.SetTypeAt(i, bound);
     }
   }
 }
 
 
 RawAbstractTypeArguments* Parser::ParseTypeArguments(
     TypeResolution type_resolution) {
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     do {
@@ skipping 3449 matching lines @@
     const Class& type_class,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   // +2 for implicit receiver and construction phase arguments.
   GrowableArray<const Object*> arg_values(arguments->length() + 2);
   Instance& instance = Instance::Handle();
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class);
     if (!type_arguments.IsNull()) {
-      // TODO(regis): Where should we check the constraints on type parameters?
+      // TODO(regis): Where should we check the type parameter bounds?
       if (!type_arguments.IsInstantiated()) {
         ErrorMsg("type must be constant in const constructor");
       }
       instance.SetTypeArguments(type_arguments);
     }
     arg_values.Add(&instance);
     arg_values.Add(&Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
@@ skipping 1372 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart