- Implement a first cut for const String.env in the VM to allow

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 3167 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->IsFactoryOrConstructor() && method->has_const) {
+    } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
-               "const constructor or factory '%s' may not have a function body",
+               "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",
                method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
       method_end_pos = TokenPos();
       ExpectToken(Token::kRBRACE);
     } else {
       ConsumeToken();
       SkipExpr();
       method_end_pos = TokenPos();
       ExpectSemicolon();
     }
   } 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 (method->IsFactoryOrConstructor() && method->has_const) {
+    } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
-               "const constructor or factory '%s' may not be native",
+               "const constructor '%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();
     method_end_pos = TokenPos();
     ExpectSemicolon();
   } else {
@@ skipping 5539 matching lines @@
   ASSERT(getter.kind() == RawFunction::kImplicitGetter);
   return new StaticGetterNode(TokenPos(), NULL, false, field_owner, field_name);
 }
 
 
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const AbstractTypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
-  const int kNumExtraArgs = 2;  // implicit rcvr and construction phase args.
+  // Factories have one extra argument: the type arguments.
+  // Constructors have 2 extra arguments: rcvr and construction phase.
+  const int kNumExtraArgs = constructor.IsFactory() ? 1 : 2;
   const int num_arguments = arguments->length() + kNumExtraArgs;
   const Array& arg_values = Array::Handle(Array::New(num_arguments));
   Instance& instance = Instance::Handle();
-  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");
+  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()));
     }
-    instance.SetTypeArguments(
-        AbstractTypeArguments::Handle(type_arguments.Canonicalize()));
+    arg_values.SetAt(0, instance);
+    arg_values.SetAt(1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
+  } else {
+    // Prepend type_arguments to list of arguments to factory.
+    ASSERT(type_arguments.IsZoneHandle());
+    arg_values.SetAt(0, type_arguments);
   }
-  arg_values.SetAt(0, instance);
-  arg_values.SetAt(1, Smi::Handle(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.SetAt((i + kNumExtraArgs), arg->AsLiteralNode()->literal());
   }
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(num_arguments,
                                              arguments->names()));
   const Object& result =
       Object::Handle(DartEntry::InvokeFunction(constructor,
                                                arg_values,
                                                args_descriptor));
   if (result.IsError()) {
       // An exception may not occur in every parse attempt, i.e., the
       // generated AST is not deterministic. Therefore mark the function as
       // not optimizable.
       current_function().set_is_optimizable(false);
       if (result.IsUnhandledException()) {
         return result.raw();
       } else {
         isolate()->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();
+    }
     return TryCanonicalize(instance, TokenPos());
   }
 }
 
 
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
@@ skipping 1103 matching lines @@
                external_constructor_name.ToCString());
     }
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(type_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);
+      // Const constructors can return null in the case where a const native
+      // factory returns a null value. Thus we cannot use a Instance::Cast here.
+      Instance& const_instance = Instance::Handle();
+      const_instance ^= constructor_result.raw();
       new_object = new LiteralNode(new_pos,
                                    Instance::ZoneHandle(const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
         Error& malformed_error = Error::Handle();
         ASSERT(!is_top_level_);  // We cannot check unresolved types.
         if (!const_instance.IsInstanceOf(type_bound,
                                          TypeArguments::Handle(),
                                          &malformed_error)) {
           type_bound = ClassFinalizer::NewFinalizedMalformedType(
@@ skipping 654 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart