- Get rid of RawClosure class and use RawInstance for closures.

vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 261 matching lines @@
   ASSERT(arguments.Count() == kAllocateClosureRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(function.IsClosureFunction() && !function.IsImplicitClosureFunction());
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.At(1));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   // The current context was saved in the Isolate structure when entering the
   // runtime.
   const Context& context = Context::Handle(isolate->top_context());
   ASSERT(!context.IsNull());
-  const Closure& closure = Closure::Handle(Closure::New(function, context));
-  closure.SetTypeArguments(type_arguments);
+  const Instance& closure = Instance::Handle(Closure::New(function, context));
+  Closure::SetTypeArguments(closure, type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new implicit static closure.
 // Arg0: local function.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitStaticClosure, 1) {
   ASSERT(arguments.Count() ==
          kAllocateImplicitStaticClosureRuntimeEntry.argument_count());
   ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(!function.IsNull());
   ASSERT(function.IsImplicitStaticClosureFunction());
   const Context& context = Context::Handle(object_store->empty_context());
-  arguments.SetReturn(Closure::Handle(Closure::New(function, context)));
+  arguments.SetReturn(Instance::Handle(Closure::New(function, context)));
 }
 
 
 // Allocate a new implicit instance closure.
 // Arg0: local function.
 // Arg1: receiver object.
 // Arg2: type arguments of the closure.
 // Return value: newly allocated closure.
 DEFINE_RUNTIME_ENTRY(AllocateImplicitInstanceClosure, 3) {
   ASSERT(arguments.Count() ==
          kAllocateImplicitInstanceClosureRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(function.IsImplicitInstanceClosureFunction());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(1));
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.At(2));
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   Context& context = Context::Handle();
   context = Context::New(1);
   context.SetAt(0, receiver);
-  const Closure& closure = Closure::Handle(Closure::New(function, context));
-  closure.SetTypeArguments(type_arguments);
+  const Instance& closure = Instance::Handle(Closure::New(function, context));
+  Closure::SetTypeArguments(closure, type_arguments);
   arguments.SetReturn(closure);
 }
 
 
 // Allocate a new context large enough to hold the given number of variables.
 // Arg0: number of variables.
 // Return value: newly allocated context.
 DEFINE_RUNTIME_ENTRY(AllocateContext, 1) {
   ASSERT(arguments.Count() == kAllocateContextRuntimeEntry.argument_count());
   const Smi& num_variables = Smi::CheckedHandle(arguments.At(0));
@@ skipping 717 matching lines @@
 // Arg1: ic-data.
 // Returns: Closure object or NULL (instance function not found).
 // This is called by the megamorphic stub when it is unable to resolve an
 // instance method. This is done just before the call to noSuchMethod.
 DEFINE_RUNTIME_ENTRY(ResolveImplicitClosureFunction, 2) {
   ASSERT(arguments.Count() ==
          kResolveImplicitClosureFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.At(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.At(1));
   const String& original_function_name = String::Handle(ic_data.target_name());
-  Closure& closure = Closure::Handle();
+  Instance& closure = Instance::Handle();
   if (!Field::IsGetterName(original_function_name)) {
     // This is not a getter so can't be the case where we are trying to
     // create an implicit closure of an instance function.
     arguments.SetReturn(closure);
     return;
   }
   const Class& receiver_class = Class::Handle(receiver.clazz());
   ASSERT(!receiver_class.IsNull());
   String& func_name = String::Handle();
   func_name = Field::NameFromGetter(original_function_name);
@@ skipping 77 matching lines @@
 }
 
 
 // Invoke Implicit Closure function.
 // Arg0: closure object.
 // Arg1: arguments descriptor (originally passed as dart instance invocation).
 // Arg2: arguments array (originally passed to dart instance invocation).
 DEFINE_RUNTIME_ENTRY(InvokeImplicitClosureFunction, 3) {
   ASSERT(arguments.Count() ==
          kInvokeImplicitClosureFunctionRuntimeEntry.argument_count());
-  const Closure& closure = Closure::CheckedHandle(arguments.At(0));
+  const Instance& closure = Instance::CheckedHandle(arguments.At(0));
   const Array& arg_descriptor = Array::CheckedHandle(arguments.At(1));
   const Array& func_arguments = Array::CheckedHandle(arguments.At(2));
-  const Function& function = Function::Handle(closure.function());
+  const Function& function = Function::Handle(Closure::function(closure));
   ASSERT(!function.IsNull());
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
-  const Context& context = Context::Handle(closure.context());
+  const Context& context = Context::Handle(Closure::context(closure));
   const Code& code = Code::Handle(function.CurrentCode());
   ASSERT(!code.IsNull());
   const Instructions& instrs = Instructions::Handle(code.instructions());
   ASSERT(!instrs.IsNull());
 
   // Adjust arguments descriptor array to account for removal of the receiver
   // parameter. Since the arguments descriptor array is canonicalized, create a
   // new one instead of patching the original one.
   const intptr_t len = arg_descriptor.Length();
   const intptr_t num_named_args = (len - 3) / 2;
@@ skipping 572 matching lines @@
     intptr_t line, column;
     script.GetTokenLocation(token_pos, &line, &column);
     String& line_string = String::Handle(script.GetLine(line));
     OS::Print("  Function: %s\n", top_function.ToFullyQualifiedCString());
     OS::Print("  Line %"Pd": '%s'\n", line, line_string.ToCString());
   }
 }
 
 
 }  // namespace dart