[modules] Basic support of import statements.

src/interpreter/bytecode-generator.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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 1987 matching lines @@
       ModuleDescriptor* descriptor = scope()->GetModuleScope()->module();
       if (variable->IsExport()) {
         auto it = descriptor->regular_exports().find(variable->raw_name());
         DCHECK(it != descriptor->regular_exports().end());
         Register export_name = register_allocator()->NewRegister();
         builder()
             ->LoadLiteral(it->second->export_name->string())
             .StoreAccumulatorInRegister(export_name)
             .CallRuntime(Runtime::kLoadModuleExport, export_name, 1);
       } else {
-        UNIMPLEMENTED();
+        auto it = descriptor->regular_imports().find(variable->raw_name());

[rmcilroy, 2016/09/22 10:18:13]

Could you add some tests to test-bytecode-generator to generate expected output
for module import and export please.

+        DCHECK(it != descriptor->regular_imports().end());
+        register_allocator()->PrepareForConsecutiveAllocations(2);
+        Register import_name = register_allocator()->NextConsecutiveRegister();
+        Register module_request =
+            register_allocator()->NextConsecutiveRegister();
+        builder()
+            ->LoadLiteral(it->second->import_name->string())
+            .StoreAccumulatorInRegister(import_name)
+            .LoadLiteral(Smi::FromInt(it->second->module_request))
+            .StoreAccumulatorInRegister(module_request)
+            .CallRuntime(Runtime::kLoadModuleImport, import_name, 2);
       }
       break;
     }
   }
   execution_result()->SetResultInAccumulator();
 }
 
 void BytecodeGenerator::VisitVariableLoadForAccumulatorValue(
     Variable* variable, FeedbackVectorSlot slot, TypeofMode typeof_mode) {
   AccumulatorResultScope accumulator_result(this);
@@ skipping 179 matching lines @@
         builder()->CallRuntime(Runtime::kThrowConstAssignError, Register(), 0);
         break;
       }
 
       // If we don't throw above, we know that we're dealing with an
       // export because imports are const and we do not generate initializing
       // assignments for them.
       DCHECK(variable->IsExport());
 
       ModuleDescriptor* mod = scope()->GetModuleScope()->module();
+      // There may be several export names for this local name, but it doesn't
+      // matter which one we pick, as they all map to the same cell.
       auto it = mod->regular_exports().find(variable->raw_name());
       DCHECK(it != mod->regular_exports().end());
 
       register_allocator()->PrepareForConsecutiveAllocations(2);
       Register export_name = register_allocator()->NextConsecutiveRegister();
       Register value = register_allocator()->NextConsecutiveRegister();
       builder()
           ->StoreAccumulatorInRegister(value)
           .LoadLiteral(it->second->export_name->string())
           .StoreAccumulatorInRegister(export_name)
@@ skipping 1232 matching lines @@
   return execution_context()->scope()->language_mode();
 }
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return TypeFeedbackVector::GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8