Ensure objects emitted in code are allocated in old space.

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 88 matching lines @@
     a.SetTypeAt(i, type);
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
 
 static ThrowNode* GenerateRethrow(intptr_t token_pos, const Object& obj) {
   const UnhandledException& excp = UnhandledException::Cast(obj);
-  const Instance& exception = Instance::ZoneHandle(excp.exception());
-  const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
+  Instance& exception = Instance::ZoneHandle(excp.exception());
+  if (exception.IsNew()) {
+    exception ^= Object::Clone(exception, Heap::kOld);
+  }
+  Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
+  if (stack_trace.IsNew()) {
+    stack_trace ^= Object::Clone(stack_trace, Heap::kOld);
+  }
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
 LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
   return new LocalVariable(token_pos,
                            String::ZoneHandle(String::NewSymbol(":expr_temp")),
                            Type::ZoneHandle(Type::DynamicType()));
@@ skipping 6916 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);
+    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()));
     }
     arg_values.Add(&instance);
     arg_values.Add(&Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   } else {
@@ skipping 1595 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart