Support redirecting factory constructors in the VM (issue 3969).

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 501 matching lines @@
   bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   bool has_operator;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
-  // For constructors: NULL or redirected constructor.
+  // For constructors: NULL or name of redirected to constructor.
   String* redirect_name;
   // For constructors: NULL for unnamed constructor,
   // identifier after classname for named constructors.
   String* constructor_name;
   ParamList params;
   RawFunction::Kind kind;
 };
 
 
 class ClassDesc : public ValueObject {
@@ skipping 168 matching lines @@
   const Script& script = Script::Handle(isolate, func.script());
   Parser parser(script, func, func.token_pos());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle(isolate, Array::null());
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor:
+      // The call to a redirecting factory is redirected.
+      ASSERT(!func.IsRedirectingFactory());
       node_sequence = parser.ParseFunc(func, default_parameter_values);
       break;
     case RawFunction::kImplicitGetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceGetter(func);
       break;
     case RawFunction::kImplicitSetter:
       ASSERT(!func.is_static());
       node_sequence = parser.ParseInstanceSetter(func);
       break;
@@ skipping 1632 matching lines @@
              "static method '%s' cannot be abstract",
              method->name->ToCString());
   }
   if (method->has_const && !(method->IsConstructor() || method->IsFactory())) {
     ErrorMsg(method->name_pos, "'const' not allowed for methods");
   }
   if (method->IsFactoryOrConstructor() && method->has_abstract) {
     ErrorMsg(method->name_pos, "constructor cannot be abstract");
   }
   if (method->IsConstructor() && method->has_const) {
-    Class& cls = Class::ZoneHandle(library_.LookupClass(members->class_name()));
+    Class& cls = Class::Handle(library_.LookupClass(members->class_name()));
     cls.set_is_const();
   }
   if (method->has_abstract && members->is_interface()) {
     ErrorMsg(method->name_pos,
              "'abstract' method only allowed in class definition");
   }
   if (method->has_external && members->is_interface()) {
     ErrorMsg(method->name_pos,
              "'external' method only allowed in class definition");
   }
 
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the AbstractTypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
     method->params.AddReceiver(ReceiverType(formal_param_pos));
-  } else if (method->has_factory) {
+  } else if (method->IsFactory()) {
     method->params.AddFinalParameter(
         formal_param_pos,
         &String::ZoneHandle(Symbols::TypeArgumentsParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   // Constructors have an implicit parameter for the construction phase.
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
@@ skipping 40 matching lines @@
       expected_num_parameters = (method->has_static) ? 1 : 2;
       method->name = &String::ZoneHandle(Field::SetterSymbol(*method->name));
     }
     if ((method->params.num_fixed_parameters != expected_num_parameters) ||
         (method->params.num_optional_parameters != 0)) {
       ErrorMsg(method->name_pos, "illegal %s parameters",
                method->IsGetter() ? "getter" : "setter");
     }
   }
 
-  // Parse initializers.
-  if (CurrentToken() == Token::kCOLON) {
+  // Parse redirecting factory constructor.
+  Type& redirection_type = Type::Handle();
+  String& redirection_identifier = String::Handle();
+  if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
+    ConsumeToken();
+    const intptr_t type_pos = TokenPos();
+    const AbstractType& type = AbstractType::Handle(
+        ParseType(ClassFinalizer::kTryResolve));
+    if (type.IsTypeParameter()) {
+      // TODO(regis): Spec is not clear. Throw dynamic error or report
+      // compile-time error? Same question for new and const operators.
+      ErrorMsg(type_pos, "factory may not redirect via a type parameter");
+    }
+    redirection_type ^= type.raw();
+    if (CurrentToken() == Token::kPERIOD) {
+      // Named constructor or factory.
+      ConsumeToken();
+      redirection_identifier = ExpectIdentifier("identifier expected")->raw();
+    }
+  } else if (CurrentToken() == Token::kCOLON) {
+    // Parse initializers.
     if (!method->IsConstructor()) {
       ErrorMsg("initializers only allowed on constructors");
     }
     if ((LookaheadToken(1) == Token::kTHIS) &&
         ((LookaheadToken(2) == Token::kLPAREN) ||
          LookaheadToken(4) == Token::kLPAREN)) {
       // Redirected constructor: either this(...) or this.xxx(...).
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
@@ skipping 73 matching lines @@
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     ParseNativeDeclaration();
   } else {
     // We haven't found a method body. Issue error if one is required.
     const bool must_have_body =
         !members->is_interface() &&
-        method->has_static && !method->has_external;
+        method->has_static &&
+        !method->has_external &&
+        redirection_type.IsNull();
     if (must_have_body) {
       ErrorMsg(method->name_pos,
                "function body expected for method '%s'",
                method->name->ToCString());
     }
 
     if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       if (!members->is_interface() &&
           !method->has_static &&
@@ skipping 36 matching lines @@
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method->has_abstract,
                     method->has_external,
                     current_class(),
                     method_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
 
+  // If this method is a redirecting factory, set the redirection information.
+  if (!redirection_type.IsNull()) {
+    ASSERT(func.IsFactory());
+    func.SetRedirectionType(redirection_type);
+    if (!redirection_identifier.IsNull()) {
+      func.SetRedirectionIdentifier(redirection_identifier);
+    }
+  }
+
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   members->AddFunction(func);
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
@@ skipping 356 matching lines @@
       if (member.has_factory) {
         ErrorMsg("factory constructors are not allowed in interfaces");
       } else {
         ErrorMsg("static methods are not allowed in interfaces");
       }
     }
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
+    ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
     if (member.has_operator) {
       CheckOperatorArity(member, operator_token);
     }
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
@@ skipping 5728 matching lines @@
 AstNode* Parser::ParseNewOperator() {
   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(
+  AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeWellFormed));
   // Malformed bounds never result in a compile time error, therefore, the
   // 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.UserVisibleName()).ToCString());
   }
   if (type.IsDynamicType()) {
     ErrorMsg(type_pos, "Dynamic cannot be instantiated");
   }
-  const Class& type_class = Class::Handle(type.type_class());
+  Class& type_class = Class::Handle(type.type_class());
   const String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
   // The constructor class and its name are those of the parsed type, unless the
   // parsed type is an interface and a default factory class is specified, in
   // which case constructor_class and constructor_class_name are modified below.
   Class& constructor_class = Class::ZoneHandle(type_class.raw());
   String& constructor_class_name = String::Handle(type_class_name.raw());
 
@@ skipping 74 matching lines @@
     ASSERT(!constructor_class.is_interface());
   }
 
   // Make sure that an appropriate constructor exists.
   const String& constructor_name =
       BuildConstructorName(constructor_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(
       constructor_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = constructor_class.LookupFactory(constructor_name);
-    // A factory does not have the implicit 'phase' parameter.
-    arguments_length -= 1;
-  }
-  if (constructor.IsNull()) {
-    const String& external_constructor_name =
-        (named_constructor ? constructor_name : constructor_class_name);
-    ErrorMsg(type_pos,
-             "class '%s' has no constructor or factory named '%s'",
-             String::Handle(constructor_class.Name()).ToCString(),
-             external_constructor_name.ToCString());
+    if (constructor.IsNull()) {
+      const String& external_constructor_name =
+          (named_constructor ? constructor_name : constructor_class_name);
+      ErrorMsg(type_pos,
+               "class '%s' has no constructor or factory named '%s'",
+               String::Handle(constructor_class.Name()).ToCString(),
+               external_constructor_name.ToCString());
+    } else if (constructor.IsRedirectingFactory()) {
+      type = constructor.RedirectionType();
+      constructor = constructor.RedirectionTarget();
+      if (constructor.IsNull()) {
+        // TODO(regis): We normally report a compile-time error if the
+        // constructor is not found. See above. However, we should throw a
+        // dynamic error instead. We do it here. This is the first step.
+        ASSERT(type.IsMalformed());
+      } else {
+        type_class = type.type_class();
+        type_arguments = type.arguments();
+        constructor_class = constructor.Owner();
+        ASSERT(type_class.raw() == constructor_class.raw());
+      }
+    }
+    if (!constructor.IsNull() && constructor.IsFactory()) {
+      // A factory does not have the implicit 'phase' parameter.
+      arguments_length -= 1;
+    }
   }
 
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
-  if (constructor_class.is_abstract() && !constructor.IsFactory()) {
+  if (!constructor.IsNull() &&
+      constructor_class.is_abstract() &&
+      !constructor.IsFactory()) {
     ArgumentListNode* arguments = new ArgumentListNode(type_pos);
     arguments->Add(new LiteralNode(
         TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
     arguments->Add(new LiteralNode(
         TokenPos(), String::ZoneHandle(constructor_class_name.raw())));
     const String& cls_name =
         String::Handle(Symbols::AbstractClassInstantiationError());
     const String& func_name = String::Handle(Symbols::ThrowNew());
     return MakeStaticCall(cls_name, func_name, arguments);
   }
 
   String& error_message = String::Handle();
-  if (!constructor.AreValidArguments(arguments_length,
+  if (!constructor.IsNull() &&
+      !constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
         (named_constructor ? constructor_name : constructor_class_name);
     ErrorMsg(call_pos,
              "invalid arguments passed to constructor '%s' for class '%s': %s",
              external_constructor_name.ToCString(),
              String::Handle(constructor_class.Name()).ToCString(),
              error_message.ToCString());
   }
 
   // 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()) {
+  if (!constructor.IsNull() && (constructor_class.raw() != type_class.raw())) {
     const intptr_t num_type_parameters = constructor_class.NumTypeParameters();
     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, Heap::kNew);
       AbstractType& type_argument = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
@@ skipping 14 matching lines @@
     // 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());
       type.set_malformed_error(error);
     }
   }
-
+  if (type.IsMalformed()) {
+    // Compile the throw of a dynamic type error due to a bound error or to
+    // a redirection error.
+    return ThrowTypeError(type_pos, type);
+  }
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       ErrorMsg("'const' requires const constructor: '%s'",
           String::Handle(constructor.name()).ToCString());
     }
-    if (type.IsMalformed()) {
-      // Compile the throw of a dynamic type error due to a bound error.
-      return ThrowTypeError(type_pos, type);
-    }
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(constructor_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
       new_object = GenerateRethrow(new_pos, constructor_result);
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       new_object = new LiteralNode(new_pos,
                                    Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
-    if (type.IsMalformed()) {
-      // Compile the throw of a dynamic type error due to a bound error.
-      return ThrowTypeError(type_pos, type);
-    }
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(ArrayNode* values) {
@@ skipping 579 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart