[modules] Detect and throw exceptions for cyclic dependencies

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 30 matching lines @@
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-decoder.h"
 #include "src/interpreter/interpreter.h"
 #include "src/isolate-inl.h"
 #include "src/keys.h"
 #include "src/list.h"
 #include "src/log.h"
 #include "src/lookup.h"
 #include "src/macro-assembler.h"
 #include "src/messages.h"
+#include "src/module-resolve-set-inl.h"
 #include "src/objects-body-descriptors-inl.h"
 #include "src/property-descriptor.h"
 #include "src/prototype.h"
 #include "src/regexp/jsregexp.h"
 #include "src/safepoint-table.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/source-position-table.h"
 #include "src/string-builder.h"
 #include "src/string-search.h"
 #include "src/string-stream.h"
@@ skipping 19561 matching lines @@
 
 Handle<Object> Module::LoadImport(Handle<Module> module, Handle<String> name,
                                   int module_request) {
   Isolate* isolate = module->GetIsolate();
   Handle<Module> requested_module(
       Module::cast(module->requested_modules()->get(module_request)), isolate);
   return Module::LoadExport(requested_module, name);
 }
 
 MaybeHandle<Cell> Module::ResolveImport(Handle<Module> module,
-                                        Handle<String> name,
-                                        int module_request) {
+                                        Handle<String> name, int module_request,
+                                        Module::ResolveSet* resolve_set,
+                                        Zone* zone) {
   Isolate* isolate = module->GetIsolate();
   Handle<Module> requested_module(
       Module::cast(module->requested_modules()->get(module_request)), isolate);
-  return Module::ResolveExport(requested_module, name);
+  return Module::ResolveExport(requested_module, name, resolve_set, zone);
 }
 
 MaybeHandle<Cell> Module::ResolveExport(Handle<Module> module,
-                                        Handle<String> name) {
-  // TODO(neis): Detect cycles.
+                                        Handle<String> name,
+                                        Module::ResolveSet* resolve_set,
+                                        Zone* zone) {
+  Isolate* isolate = module->GetIsolate();
 
-  Isolate* isolate = module->GetIsolate();
+  auto it = resolve_set->find(module);
+  if (it != resolve_set->end()) {
+    auto& name_set = it->second;
+    if (name_set->count(name)) {
+      THROW_NEW_ERROR(isolate,
+                      NewSyntaxError(MessageTemplate::kCyclicModuleDependency),
+                      Cell);
+    }
+    name_set->insert(name);
+  } else {
+    UnorderedStringSet* name_set =
+        new (zone->New(sizeof(UnorderedStringSet))) UnorderedStringSet(zone);
+    name_set->insert(name);
+    resolve_set->insert({module, name_set});
+  }
+
   Handle<Object> object(module->exports()->Lookup(name), isolate);
 
   if (object->IsCell()) {
     // Already resolved (e.g. because it's a local export).
     return Handle<Cell>::cast(object);
   }
 
   if (object->IsModuleInfoEntry()) {
     // Not yet resolved indirect export.
     Handle<ModuleInfoEntry> entry = Handle<ModuleInfoEntry>::cast(object);
     int module_request = Smi::cast(entry->module_request())->value();
     Handle<String> import_name(String::cast(entry->import_name()), isolate);
 
     Handle<Cell> cell;
-    if (!ResolveImport(module, import_name, module_request).ToHandle(&cell)) {
+    if (!ResolveImport(module, import_name, module_request, resolve_set, zone)
+             .ToHandle(&cell)) {
       return MaybeHandle<Cell>();
     }
 
     // The export table may have changed but the entry in question should be
     // unchanged.
     Handle<ObjectHashTable> exports(module->exports(), isolate);
     DCHECK(exports->Lookup(name)->IsModuleInfoEntry());
 
     exports = ObjectHashTable::Put(exports, name, cell);
     module->set_exports(*exports);
     return cell;
   }
 
   DCHECK(object->IsTheHole(isolate));
   // TODO(neis): Implement star exports.
 
   // Unresolvable.
   THROW_NEW_ERROR(isolate,
                   NewSyntaxError(MessageTemplate::kUnresolvableExport, name),
                   Cell);
 }
 
 }  // namespace internal
 }  // namespace v8