Consider upper bounds of type parameters in type checks.

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 3155 matching lines @@
         Class::New(String::Handle(String::NewSymbol(":factory_signature")),
                    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.
+    // the interface in number and names, but not necessarily in bounds.
     if (factory_class.NumTypeParameters() > 0) {
+      const bool check_type_parameter_bounds = false;
       if (!AbstractTypeArguments::AreIdentical(
           AbstractTypeArguments::Handle(interface.type_parameters()),
-          AbstractTypeArguments::Handle(factory_class.type_parameters()))) {
+          AbstractTypeArguments::Handle(factory_class.type_parameters()),
+          check_type_parameter_bounds)) {

[hausner, 2012/06/27 19:59:40]

Indentation

[regis, 2012/06/27 20:06:50]

I think the indentation is correct.

         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 69 matching lines @@
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     const GrowableObjectArray& type_parameters_array =
         GrowableObjectArray::Handle(GrowableObjectArray::New());
-    const GrowableObjectArray& bounds_array =
-        GrowableObjectArray::Handle(GrowableObjectArray::New());
     intptr_t index = 0;
     TypeParameter& type_parameter = TypeParameter::Handle();
     TypeParameter& existing_type_parameter = TypeParameter::Handle();
     String& existing_type_parameter_name = String::Handle();
-    AbstractType& bound = Type::Handle();
+    AbstractType& type_parameter_bound = Type::Handle();
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
-      type_parameter = TypeParameter::New(cls,
-                                          index,
-                                          type_parameter_name,
-                                          TokenPos());
+      const intptr_t type_parameter_pos = TokenPos();
       // Check for duplicate type parameters.
       for (intptr_t i = 0; i < index; i++) {
         existing_type_parameter ^= type_parameters_array.At(i);
         existing_type_parameter_name = existing_type_parameter.Name();
         if (existing_type_parameter_name.Equals(type_parameter_name)) {
           ErrorMsg("duplicate type parameter '%s'",
                    type_parameter_name.ToCString());
         }
       }
       ConsumeToken();
-      bound = Type::DynamicType();
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         // A bound may refer to the owner of the type parameter it applies to,
         // i.e. to the class or interface currently being parsed.
         // Postpone resolution in order to avoid resolving the class and its
         // type parameters, as they are not fully parsed yet.
-        bound = ParseType(ClassFinalizer::kDoNotResolve);
+        type_parameter_bound = ParseType(ClassFinalizer::kDoNotResolve);
+      } else {
+        type_parameter_bound = Type::DynamicType();
       }
+      type_parameter = TypeParameter::New(cls,
+                                          index,
+                                          type_parameter_name,
+                                          type_parameter_bound,
+                                          type_parameter_pos);
       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");
     }
     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.
-    const intptr_t num_types = bounds.Length();
+    const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
-      bound = bounds.TypeAt(i);
-      ResolveTypeFromClass(cls, ClassFinalizer::kTryResolve, &bound);
-      bounds.SetTypeAt(i, bound);
+      type_parameter ^= type_parameters.TypeAt(i);
+      type_parameter_bound = type_parameter.bound();
+      ResolveTypeFromClass(cls,
+                           ClassFinalizer::kTryResolve,
+                           &type_parameter_bound);
+      type_parameter.set_bound(type_parameter_bound);
     }
   }
 }
 
 
 RawAbstractTypeArguments* Parser::ParseTypeArguments(
     Error* malformed_error,
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
@@ skipping 5292 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart