Remove support for obsolete syntax of factory methods and default classes.

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 2328 matching lines @@
       if (CurrentToken() == Token::kPERIOD) {
         LibraryPrefix& lib_prefix = LibraryPrefix::ZoneHandle();
         lib_prefix = current_class().LookupLibraryPrefix(*member.name);
         if (!lib_prefix.IsNull()) {
           // We have a library prefix qualified identifier.
           ConsumeToken();  // Consume the kPERIOD token.
           qualifier ^= member.name->raw();
           member.name = ExpectIdentifier("identifier expected");
         }
       }
-      // TODO(regis): Remove support for type parameters on factories.
-      // Once done, stop postponing resolution of the factory result type until
-      // class finalization.
+      // TODO(regis): Stop postponing resolution of the factory result type
+      // until class finalization. Use TryResolveTypeFromClass.
+      // Factory result type is the same as the type name of the factory.
       const UnresolvedClass& unresolved_factory_class =
           UnresolvedClass::Handle(UnresolvedClass::New(member.name_pos,
                                                        qualifier,
                                                        *member.name));
-      const Class& signature_class = Class::Handle(
-          Class::New(String::Handle(String::NewSymbol(":factory_signature")),
-                     script_));
-      signature_class.set_is_finalized();
-      signature_class.set_library(library_);
-      unresolved_factory_class.set_factory_signature_class(signature_class);
       // The type arguments of the result type are set during finalization.
-      const TypeArguments& args = TypeArguments::Handle();
       member.type = &Type::ZoneHandle(
-          Type::NewParameterizedType(unresolved_factory_class, args));
-      ParseTypeParameters(signature_class);
-      if (signature_class.NumTypeParameters() > 0) {
-        Warning("factory method '%s' should not declare type parameters.\n",
-                member.name->ToCString());
-      } else {
-        // Remove factory signature class, since no type parameters declared.
-        unresolved_factory_class.set_factory_signature_class(Class::Handle());
-      }
+          Type::NewParameterizedType(unresolved_factory_class,
+                                     TypeArguments::Handle()));
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *name);
     }
@@ skipping 388 matching lines @@
   set_current_class(interface);
   ParseTypeParameters(interface);
 
   if (CurrentToken() == Token::kEXTENDS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = token_index_;
     interfaces = ParseInterfaceList();
     AddInterfaces(interfaces_pos, interface, interfaces);
   }
 
-  // TODO(regis): Remove support for "factory" keyword.
-  if ((CurrentToken() == Token::kDEFAULT) ||
-      (CurrentToken() == Token::kFACTORY)) {
-    if (CurrentToken() == Token::kFACTORY) {
-      Warning("'factory' is obsolete, use 'default' instead.");
-    }
+  if (CurrentToken() == Token::kDEFAULT) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       ErrorMsg("class name expected");
     }
     const intptr_t factory_pos = token_index_;
     QualIdent factory_name;
     ParseQualIdent(&factory_name);
     String& qualifier = String::Handle();
     if (factory_name.qualifier != NULL) {
       qualifier ^= factory_name.qualifier->raw();
     }
     const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle(
         UnresolvedClass::New(factory_pos, qualifier, *factory_name.ident));
     const Class& factory_class = Class::Handle(
         Class::New(String::Handle(String::NewSymbol(":factory_signature")),
                    script_));
     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);
     // Verify that the type parameters of the factory class and of the interface
     // have identical names.
+    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());
     const intptr_t num_type_params = factory_class.NumTypeParameters();
     bool mismatch = interface.NumTypeParameters() != num_type_params;
-    if (mismatch && (num_type_params == 0)) {
-      // TODO(regis): For now, and until the core lib is fixed, we accept a
-      // factory clause with a class missing its list of type parameters.
-      // See bug 5408808.
+    for (intptr_t i = 0; !mismatch && (i < num_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) {
       const String& interface_name = String::Handle(interface.Name());
       const String& factory_name = String::Handle(factory_class.Name());
-      Warning(factory_pos,
-              "class '%s' in default clause of interface '%s' is "
-              "missing its type parameter list.\n",
-              factory_name.ToCString(),
-              interface_name.ToCString());
-    } else {
-      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());
-      for (intptr_t i = 0; !mismatch && (i < num_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) {
-        const String& interface_name = String::Handle(interface.Name());
-        const String& factory_name = String::Handle(factory_class.Name());
-        ErrorMsg(factory_pos,
-                 "mismatch in number or names of type parameters between "
-                 "interface '%s' and default factory class '%s'.\n",
-                 interface_name.ToCString(),
-                 factory_name.ToCString());
-      }
+      ErrorMsg(factory_pos,
+               "mismatch in number or names of type parameters between "
+               "interface '%s' and default factory class '%s'.\n",
+               interface_name.ToCString(),
+               factory_name.ToCString());
     }
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(interface, interface_name, true, interface_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
@@ skipping 3406 matching lines @@
 }
 
 
 // If type parameters are currently in scope, return their declaring class,
 // otherwise return null.
 RawClass* Parser::TypeParametersScopeClass() {
   // Type parameters cannot be referred to from a static function, except from
   // a constructor or from a factory.
   // A constructor is considered as non-static by the compiler.
   if (is_top_level_) {
-    if ((current_member_ != NULL) && current_member_->has_factory) {
-      const AbstractType& factory_result_type = *current_member_->type;
-      ASSERT(!factory_result_type.IsNull());
-      const UnresolvedClass& unresolved_factory_class =
-          UnresolvedClass::Handle(factory_result_type.unresolved_class());
-      // TODO(regis): Remove support for type parameters declared by factory
-      // methods.
-      if (unresolved_factory_class.factory_signature_class() != Class::null()) {
-        return unresolved_factory_class.factory_signature_class();
-      }
-      return current_class().raw();
-    }
-    if ((current_member_ == NULL) || !current_member_->has_static) {
+    if ((current_member_ == NULL) ||
+        (current_member_->has_factory || !current_member_->has_static)) {
       return current_class().raw();
     }
   } else {
     if (!current_function().IsNull()) {
       Function& outer_function = Function::Handle(current_function().raw());
       while (outer_function.IsLocalFunction()) {
         outer_function = outer_function.parent_function();
       }
-      if (outer_function.IsFactory()) {
-        // TODO(regis): Remove support for type parameters declared by factory
-        // methods.
-        if (outer_function.signature_class() != Class::null()) {
-          return outer_function.signature_class();
-        }
-        return current_class().raw();
-      }
-      if (!outer_function.is_static()) {
+      if (outer_function.IsFactory() || !outer_function.is_static()) {
         return current_class().raw();
       }
     }
   }
   return Class::null();
 }
 
 
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   Function& outer_function = Function::Handle(current_function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
-  if (outer_function.IsFactory()) {
-    // TODO(regis): Remove support for type parameters on factories.
-    Class& signature_class = Class::Handle(outer_function.signature_class());
-    if (signature_class.IsNull()) {
-      return current_class().NumTypeParameters() > 0;
-    }
-    return signature_class.NumTypeParameters() > 0;
-  }
-  if (!outer_function.is_static()) {
+  if (outer_function.IsFactory() || !outer_function.is_static()) {
     return current_class().NumTypeParameters() > 0;
   }
   return false;
 }
 
 
 void Parser::RunStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   const Instance& value = Instance::Handle(field.value());
   if (value.raw() == Object::transition_sentinel()) {
@@ skipping 395 matching lines @@
     }
   }
   return type.raw();
 }
 
 
 void Parser::CheckConstructorCallTypeArguments(
     intptr_t pos, Function& constructor,
     const AbstractTypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
-    // TODO(regis): Remove support for type parameters on factories.
-    Class& signature_class = Class::Handle();
-    if (constructor.IsFactory() &&
-        (constructor.signature_class() != Class::null())) {
-      signature_class = constructor.signature_class();
-    } else {
-      signature_class = constructor.owner();
-    }
-    ASSERT(!signature_class.IsNull());
-    ASSERT(signature_class.is_finalized());
+    const Class& constructor_class = Class::Handle(constructor.owner());
+    ASSERT(!constructor_class.IsNull());
+    ASSERT(constructor_class.is_finalized());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
-    if (type_arguments.Length() != signature_class.NumTypeArguments()) {
+    if (type_arguments.Length() != constructor_class.NumTypeArguments()) {
       ErrorMsg(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
 
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
@@ skipping 498 matching lines @@
   if (!constructor.AreValidArguments(arguments_length, arguments->names())) {
     ErrorMsg(new_pos, "invalid arguments passed to constructor '%s' "
              "for class '%s'",
              external_constructor_name.ToCString(),
              String::Handle(type_class.Name()).ToCString());
   }
 
   // Now that the constructor to be called is identified, finalize the type
   // argument vector to be passed.
   {
-    // TODO(regis): Remove support for type parameters on factories.
-    Class& signature_class = Class::Handle();
-    if (constructor.IsFactory() &&
-        (constructor.signature_class() != Class::null())) {
-      signature_class = constructor.signature_class();
-    } else {
-      signature_class = constructor.owner();
-      ASSERT(signature_class.raw() == type_class.raw());
-    }
+    ASSERT(constructor.owner() == type_class.raw());
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
-        Type::NewParameterizedType(signature_class, type_arguments));
+        Type::NewParameterizedType(type_class, type_arguments));
     Error& error = Error::Handle();
-    type ^= ClassFinalizer::FinalizeAndCanonicalizeType(signature_class,
+    type ^= ClassFinalizer::FinalizeAndCanonicalizeType(type_class,
                                                         type,
                                                         &error);
     if (!error.IsNull()) {
       ErrorMsg(error.ToErrorCString());
     }
     // The type argument vector may have been expanded with the type arguments
     // of the super type when finalizing the type.
     type_arguments = type.arguments();
   }
 
@@ skipping 478 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart