[modules] Don't unnecessarily keep function alive after evaluation.

src/objects.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 19926 matching lines @@
   if (must_resolve) {
     THROW_NEW_ERROR(isolate,
                     NewSyntaxError(MessageTemplate::kUnresolvableExport, name),
                     Cell);
   }
   return MaybeHandle<Cell>();
 }
 
 bool Module::Instantiate(Handle<Module> module, v8::Local<v8::Context> context,
                          v8::Module::ResolveCallback callback) {
-  // Already instantiated.
-  if (module->code()->IsJSFunction()) return true;
+  if (module->instantiated()) return true;
 
   Isolate* isolate = module->GetIsolate();
   Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(module->code()),
                                     isolate);
   Handle<JSFunction> function =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
           shared,
           handle(Utils::OpenHandle(*context)->native_context(), isolate));
   module->set_code(*function);
+  DCHECK(module->instantiated());
 
   Handle<ModuleInfo> module_info(shared->scope_info()->ModuleDescriptorInfo(),
                                  isolate);
 
   // Set up local exports.
   Handle<FixedArray> regular_exports(module_info->regular_exports(), isolate);
   for (int i = 0, n = regular_exports->length(); i < n; i += 2) {
     Handle<FixedArray> export_names(
         FixedArray::cast(regular_exports->get(i + 1)), isolate);
     CreateExport(module, export_names);
@@ skipping 61 matching lines @@
     if (ResolveExport(module, Handle<String>::cast(name), true, &resolve_set)
             .is_null()) {
       return false;
     }
   }
 
   return true;
 }
 
 MaybeHandle<Object> Module::Evaluate(Handle<Module> module) {
-  DCHECK(module->code()->IsJSFunction());  // Instantiated.
-
-  Isolate* isolate = module->GetIsolate();
+  DCHECK(module->instantiated());
 
   // Each module can only be evaluated once.
+  Isolate* isolate = module->GetIsolate();
   if (module->evaluated()) return isolate->factory()->undefined_value();
-  module->set_evaluated(true);
+  Handle<JSFunction> function(JSFunction::cast(module->code()), isolate);
+  module->set_evaluated();
 
   // Initialization.
-  Handle<JSFunction> function(JSFunction::cast(module->code()), isolate);
   DCHECK_EQ(MODULE_SCOPE, function->shared()->scope_info()->scope_type());
   Handle<Object> receiver = isolate->factory()->undefined_value();
   Handle<Object> argv[] = {module};
   Handle<Object> generator;
   ASSIGN_RETURN_ON_EXCEPTION(
       isolate, generator,
       Execution::Call(isolate, function, receiver, arraysize(argv), argv),
       Object);
 
   // Recursion.
   Handle<FixedArray> requested_modules(module->requested_modules(), isolate);
   for (int i = 0, length = requested_modules->length(); i < length; ++i) {
     Handle<Module> import(Module::cast(requested_modules->get(i)), isolate);
     RETURN_ON_EXCEPTION(isolate, Evaluate(import), Object);
   }
 
   // Evaluation of module body.
   Handle<JSFunction> resume(
       isolate->native_context()->generator_next_internal(), isolate);
   return Execution::Call(isolate, resume, generator, 0, nullptr);
 }
 
 namespace {
 
 void FetchStarExports(Handle<Module> module, Zone* zone,
                       UnorderedModuleSet* visited) {
-  DCHECK(module->code()->IsJSFunction());  // Instantiated.
+  DCHECK(module->instantiated());
 
   bool cycle = !visited->insert(module).second;
   if (cycle) return;
 
   Isolate* isolate = module->GetIsolate();
   Handle<ObjectHashTable> exports(module->exports(), isolate);
   UnorderedStringMap more_exports(zone);
 
   // TODO(neis): Only allocate more_exports if there are star exports.
   // Maybe split special_exports into indirect_exports and star_exports.
@@ skipping 110 matching lines @@
         ns, Accessors::ModuleNamespaceEntryInfo(isolate, name, attr))
         .Check();
   }
   JSObject::PreventExtensions(ns, THROW_ON_ERROR).ToChecked();
 
   return ns;
 }
 
 }  // namespace internal
 }  // namespace v8