Rename Interface to ModuleDescriptor

src/parser.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 1260 matching lines @@
       if (stat && !stat->IsEmpty()) {
         body->AddStatement(stat, zone());
       }
     }
   }
 
   scope->set_end_position(scanner()->location().end_pos);
   body->set_scope(scope);
 
   // Check that all exports are bound.
-  Interface* interface = scope->interface();
-  for (Interface::Iterator it = interface->iterator();
-       !it.done(); it.Advance()) {
+  ModuleDescriptor* descriptor = scope->module();
+  for (ModuleDescriptor::Iterator it = descriptor->iterator(); !it.done();
+       it.Advance()) {
     if (scope->LookupLocal(it.name()) == NULL) {
       ParserTraits::ReportMessage("module_export_undefined", it.name());
       *ok = false;
       return NULL;
     }
   }
 
-  scope->interface()->Freeze();
+  scope->module()->Freeze();
   return body;
 }
 
 
 Literal* Parser::ParseModuleSpecifier(bool* ok) {
   // ModuleSpecifier :
   //    StringLiteral
 
   int pos = peek_position();
   Expect(Token::STRING, CHECK_OK);
@@ skipping 191 matching lines @@
 
     default: {
       int pos = peek_position();
       Expression* expr = ParseAssignmentExpression(true, CHECK_OK);
       ExpectSemicolon(CHECK_OK);
       result = factory()->NewExpressionStatement(expr, pos);
       break;
     }
   }
 
-  // TODO(ES6): Add default export to scope_->interface()
+  // TODO(ES6): Add default export to scope_->module()
 
   return result;
 }
 
 
 Statement* Parser::ParseExportDeclaration(bool* ok) {
   // ExportDeclaration:
   //    'export' '*' 'from' ModuleSpecifier ';'
   //    'export' ExportClause ('from' ModuleSpecifier)? ';'
   //    'export' VariableStatement
@@ skipping 84 matching lines @@
       continue;
     }
     if (!IsImmutableVariableMode(var->mode())) {
       var->set_maybe_assigned();
     }
   }
 
   // TODO(ES6): Handle 'export from' once imports are properly implemented.
   // For now we just drop such exports on the floor.
   if (!is_export_from) {
-    // Extract declared names into export declarations and interface.
-    Interface* interface = scope_->interface();
+    // Extract declared names into export declarations and module descriptor.
+    ModuleDescriptor* descriptor = scope_->module();
     for (int i = 0; i < names.length(); ++i) {
-#ifdef DEBUG
-      if (FLAG_print_interface_details)
-        PrintF("# Export %.*s ", names[i]->length(), names[i]->raw_data());
-#endif
       // TODO(adamk): Make early errors here provide the right error message
       // (duplicate exported names).
-      interface->Add(names[i], zone(), CHECK_OK);
+      descriptor->Add(names[i], zone(), CHECK_OK);
       // TODO(rossberg): Rethink whether we actually need to store export
       // declarations (for compilation?).
       // ExportDeclaration* declaration =
       //     factory()->NewExportDeclaration(proxy, scope_, position);
       // scope_->AddDeclaration(declaration);
     }
   }
 
   DCHECK(result != NULL);
   return result;
@@ skipping 3816 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal