Make 'module' a context-sensitive keyword.

src/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1170 matching lines @@
   //    ModuleDeclaration
   //    ImportDeclaration
   //    ExportDeclaration
 
   switch (peek()) {
     case Token::FUNCTION:
       return ParseFunctionDeclaration(ok);
     case Token::LET:
     case Token::CONST:
       return ParseVariableStatement(kModuleElement, ok);
-    case Token::MODULE:
-      return ParseModuleDeclaration(ok);
     case Token::IMPORT:
       return ParseImportDeclaration(ok);
     case Token::EXPORT:
       return ParseExportDeclaration(ok);
-    default:
-      return ParseStatement(labels, ok);
+    default: {
+      Statement* stmt = ParseStatement(labels, CHECK_OK);
+      // Handle 'module' as a context-sensitive keyword.
+      if (FLAG_harmony_modules &&
+          peek() == Token::IDENTIFIER &&
+          !scanner().HasAnyLineTerminatorBeforeNext() &&
+          stmt != NULL) {
+        ExpressionStatement* estmt = stmt->AsExpressionStatement();
+        if (estmt != NULL &&
+            estmt->expression()->AsVariableProxy() != NULL &&
+            estmt->expression()->AsVariableProxy()->name()->Equals(
+                isolate()->heap()->module_symbol()) &&
+            !scanner().literal_contains_escapes()) {

[Michael Starzinger, 2012/02/24 12:31:05]

As discussed offline ignoring escapes here is consistent with the rest of our
code-base. But looking at the spec more closely we came to the conclusion that
escapes should be allowed in keywords as well.

+          return ParseModuleDeclaration(ok);
+        }
+      }
+      return stmt;
+    }
   }
 }
 
 
 Block* Parser::ParseModuleDeclaration(bool* ok) {
   // ModuleDeclaration:
   //    'module' Identifier Module
 
   // Create new block with one expected declaration.
   Block* block = factory()->NewBlock(NULL, 1, true);
-  Expect(Token::MODULE, CHECK_OK);
   Handle<String> name = ParseIdentifier(CHECK_OK);
   // top_scope_->AddDeclaration(
   //     factory()->NewModuleDeclaration(proxy, module, top_scope_));
   VariableProxy* proxy = Declare(name, LET, NULL, true, CHECK_OK);
   Module* module = ParseModule(ok);
   // TODO(rossberg): Add initialization statement to block.
   USE(proxy);
   USE(module);
   return block;
 }
@@ skipping 945 matching lines @@
       peek() == Token::FUNCTION &&
       !scanner().HasAnyLineTerminatorBeforeNext() &&
       expr != NULL &&
       expr->AsVariableProxy() != NULL &&
       expr->AsVariableProxy()->name()->Equals(
           isolate()->heap()->native_symbol()) &&
       !scanner().literal_contains_escapes()) {
     return ParseNativeDeclaration(ok);
   }
 
-  // Parsed expression statement.
-  ExpectSemicolon(CHECK_OK);
+  // Parsed expression statement, or the context-sensitive 'module' keyword.
+  // Only expect semicolon in the former case.
+  if (!FLAG_harmony_modules ||
+      peek() != Token::IDENTIFIER ||
+      scanner().HasAnyLineTerminatorBeforeNext() ||
+      expr->AsVariableProxy() == NULL ||
+      !expr->AsVariableProxy()->name()->Equals(
+          isolate()->heap()->module_symbol()) ||
+      scanner().literal_contains_escapes()) {

[Michael Starzinger, 2012/02/24 12:19:16]

A seven line condition. That's an achievement unlocked I think. :)

+    ExpectSemicolon(CHECK_OK);
+  }
   return factory()->NewExpressionStatement(expr);
 }
 
 
 IfStatement* Parser::ParseIfStatement(ZoneStringList* labels, bool* ok) {
   // IfStatement ::
   //   'if' '(' Expression ')' Statement ('else' Statement)?
 
   Expect(Token::IF, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
@@ skipping 3593 matching lines @@
       ASSERT(info->isolate()->has_pending_exception());
     } else {
       result = parser.ParseProgram(info);
     }
   }
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal