Disallow const native factories

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 2421 matching lines @@
     ErrorMsg(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
     ErrorMsg(method->name_pos, "'final' not allowed for methods");
   }
   if (method->has_abstract && method->has_static) {
     ErrorMsg(method->name_pos,
              "static method '%s' cannot be abstract",
              method->name->ToCString());
   }
-  if (method->has_const && !(method->IsConstructor() || method->IsFactory())) {
+  if (method->has_const && !method->IsFactoryOrConstructor()) {
     ErrorMsg(method->name_pos, "'const' not allowed for methods");
   }
-  if (method->IsFactoryOrConstructor() && method->has_abstract) {
+  if (method->has_abstract && method->IsFactoryOrConstructor()) {
     ErrorMsg(method->name_pos, "constructor cannot be abstract");
   }
-  if (method->IsConstructor() && method->has_const) {
+  if (method->has_const && method->IsConstructor()) {
     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");
@@ skipping 146 matching lines @@
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->has_external) {
       ErrorMsg(method->name_pos,
                "external method '%s' may not have a function body",
                method->name->ToCString());
-    } else if (method->IsConstructor() && method->has_const) {
+    } else if (method->IsFactoryOrConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
-               "const constructor '%s' may not have a function body",
-               method->name->ToCString());
-    } else if (method->IsFactory() && method->has_const) {
-      ErrorMsg(method->name_pos,
-               "const factory '%s' may not have a function body",
+               "const constructor or factory '%s' may not have a function body",
                method->name->ToCString());
     } else if (members->is_interface()) {
       ErrorMsg(method->name_pos,
                "function body not allowed in interface declaration");
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
     } else {
       ConsumeToken();
       SkipExpr();
       ExpectSemicolon();
     }
     method_end_pos = TokenPos();
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (members->is_interface()) {
       ErrorMsg(method->name_pos,
                "function body not allowed in interface declaration");
-    } else if (method->IsConstructor() && method->has_const) {
+    } else if (method->IsFactoryOrConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
-               "const constructor '%s' may not have a function body",
+               "const constructor or factory '%s' may not be native",
                method->name->ToCString());
     }
     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 =
@@ skipping 5433 matching lines @@
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     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, Heap::kOld);
-    if (!type_arguments.IsNull()) {
-      if (!type_arguments.IsInstantiated()) {
-        ErrorMsg("type must be constant in const constructor");
-      }
-      instance.SetTypeArguments(
-          AbstractTypeArguments::Handle(type_arguments.Canonicalize()));
+  ASSERT(!constructor.IsFactory());
+  instance = Instance::New(type_class, Heap::kOld);
+  if (!type_arguments.IsNull()) {
+    if (!type_arguments.IsInstantiated()) {
+      ErrorMsg("type must be constant in const constructor");
     }
-    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());
-    arg_values.Add(&type_arguments);
+    instance.SetTypeArguments(
+        AbstractTypeArguments::Handle(type_arguments.Canonicalize()));
   }
+  arg_values.Add(&instance);
+  arg_values.Add(&Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* arg = arguments->NodeAt(i);
     // Arguments have been evaluated to a literal value already.
     ASSERT(arg->IsLiteralNode());
     arg_values.Add(&arg->AsLiteralNode()->literal());
   }
   const Array& opt_arg_names = arguments->names();
   const Object& result = Object::Handle(
       DartEntry::InvokeStatic(constructor, arg_values, opt_arg_names));
   if (result.IsError()) {
       if (result.IsUnhandledException()) {
         return result.raw();
       } else {
         Isolate::Current()->long_jump_base()->Jump(1, Error::Cast(result));
         UNREACHABLE();
         return Object::null();
       }
   } else {
-    if (constructor.IsFactory()) {
-      // The factory method returns the allocated object.
-      instance ^= result.raw();
-    }
     if (!instance.IsNull()) {
       instance ^= instance.Canonicalize();
     }
     return instance.raw();
   }
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
@@ skipping 1860 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart