Early draft of strict mode

src/parser.cc

Index: src/parser.cc
diff --git a/src/parser.cc b/src/parser.cc
index 5ea1c5e083ac44a15ea4ac100f1f6848d9d4fffd..338f34697c484ca3cfbbcd13db0591a537462592 100644
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -561,6 +561,23 @@ class LexicalScope BASE_EMBEDDED {
   int prev_level_;
 };
 
+// ----------------------------------------------------------------------------
+// Support for strict mode parser stack. The constructor saves the current
+// state and the destructor resets it back.
+class StrictMode BASE_EMBEDDED {
+ public:
+  StrictMode(bool* strict_mode_variable)
+    : strict_mode_variable_(strict_mode_variable),
+      previous_strict_mode_(*strict_mode_variable) {
+  }
+
+  ~StrictMode() {
+    *strict_mode_variable_ = previous_strict_mode_;
+  }
+
+  bool *const strict_mode_variable_;
+  const bool previous_strict_mode_;
+};
 
 // ----------------------------------------------------------------------------
 // The CHECK_OK macro is a convenient macro to enforce error
@@ -600,7 +617,8 @@ Parser::Parser(Handle<Script> script,
       extension_(extension),
       pre_data_(pre_data),
       fni_(NULL),
-      stack_overflow_(false) {
+      stack_overflow_(false),
+      strict_mode_(false) {
   AstNode::ResetIds();
 }
 
@@ -668,7 +686,8 @@ FunctionLiteral* Parser::DoParseProgram(Handle<String> source,
           0,
           source->length(),
           false,
-          temp_scope.ContainsLoops());
+          temp_scope.ContainsLoops(),
+          strict_mode_);
     } else if (stack_overflow_) {
       Top::StackOverflow();
     }
@@ -1058,7 +1077,23 @@ void* Parser::ParseSourceElements(ZoneList<Statement*>* processor,
   ASSERT(processor != NULL);
   InitializationBlockFinder block_finder;
   ThisNamedPropertyAssigmentFinder this_property_assignment_finder;
+  bool directive_prologue = true; // Parsing directive prologue.
+
   while (peek() != end_token) {
+    if (!strict_mode_ && directive_prologue) {
+      if (peek() == Token::STRING) {

[Lasse Reichstein, 2011/01/13 07:18:40]

As you pointed out, this is too simple (and ECMAScript is rarely simple :).
The missing parts is checking that the "use strict" is not part of a larger
expression, and that it doesn't contain escapes. There are ways to do both
without rescanning or prescanning.

If an ExpressionStatement *starts* with a string token, and is itself a single
string, then there are no wrapping parentheses.
And if the string literal's start and end position are exactly strlen("use
strict") + 2 apart (content + quotes), then there are no escapes in the string.

The solution I have come up with is something like (from memory):

Statement* stat;
if (directive_prologue && peek() == Token::STRING) {
  var location = scanner_pos();
  stat = ParseStatement(NULL, CHECK);
  ExpressionStatement* expr_stat = stat->AsExpressionStatement();
  if (expr_stat != NULL) {
    Handle<Object> literal = expr_stat->handle();
    if (literal->IsString()) {
      // It's a directive prologue.
      Handle<String> prologue = Handle<String>::cast(literal);
      if (prologue.Equals(Heap::use_strict_symbol()) &&
          position.end_pos - position.beg_pos == 12) {
        // Literal location, including quotes, leaves
        // no room for escaped characters.
        temp_scope_->SetStrict();
      }
      continue;  // Don't add it to the AST.
    }
  }
  directive_prologue = false;
} else {
  directive_prologue = false;
  stat = ParseStatement(NULL, CHECK);
}
  
I'm not entirely satisfied with the flow yet :).

[Lasse Reichstein, 2011/01/13 07:44:07]

Argh, location should be:
  Scanner::Location location = scanner().peek_location();
and the literal test should be:
  Literal* literal = expr_stat->AsLiteral();
  if (literal != NULL && literal->handle()->IsString()) {
    Handle<String> prologue = Handle<String>::cast(literal->handle());
    ...

[Martin Maly, 2011/01/14 00:06:28]

Done. However, we still need to add the directives to the AST. Consider:

eval("Hello").length

[Lasse Reichstein, 2011/01/14 11:42:05]

I don't see how that example applies. The "Hello" String is a string literal.
When parsed by eval, it will be an identifier. In neither case will it be seen
as a Directive Prologue.

[Martin Maly, 2011/01/14 16:30:43]

Sorry, the example was incorrect

eval("'hello'").length

is what is affected by dropping expression statements that in the directive
prologue.

On 2011/01/14 11:42:05, Lasse Reichstein wrote:

[Lasse Reichstein, 2011/01/17 10:17:49]

Ack, yes, now I see.

+        // "use strict" is an ascii literal so no need to check non-ascii ones.
+        if (scanner().is_next_literal_ascii() &&
+            Factory::use_strict()->IsAsciiEqualTo(
+                scanner().next_literal_ascii_string())) {
+          strict_mode_ = true;
+        }
+      } else {
+        // done with directive prologue
+        directive_prologue = false;
+      }
+    }
+
     Statement* stat = ParseStatement(NULL, CHECK_OK);
     if (stat == NULL || stat->IsEmpty()) continue;
     // We find and mark the initialization blocks on top level code only.
@@ -1414,6 +1449,10 @@ Block* Parser::ParseVariableStatement(bool* ok) {
   return result;
 }
 
+static bool IsEvalOrArguments(Handle<String> string) {
+  return string.is_identical_to(Factory::eval_symbol()) ||
+         string.is_identical_to(Factory::arguments_symbol());
+}
 
 // If the variable declaration declares exactly one non-const
 // variable, then *var is set to that variable. In all other cases,
@@ -1462,6 +1501,13 @@ Block* Parser::ParseVariableDeclarations(bool accept_IN,
     Handle<String> name = ParseIdentifier(CHECK_OK);
     if (fni_ != NULL) fni_->PushVariableName(name);
 
+    // Strict mode variables may not be named eval or arguments
+    if (strict_mode_ && IsEvalOrArguments(name)) {
+      ReportMessage("strict_var_name", Vector<const char*>::empty());
+      *ok = false;
+      return NULL;
+    }
+
     // Declare variable.
     // Note that we *always* must treat the initial value via a separate init
     // assignment for variables and constants because the value must be assigned
@@ -1814,6 +1860,13 @@ Statement* Parser::ParseWithStatement(ZoneStringList* labels, bool* ok) {
   //   'with' '(' Expression ')' Statement
 
   Expect(Token::WITH, CHECK_OK);
+
+  if (strict_mode_) {
+    ReportMessage("strict_mode_with", Vector<const char*>::empty());
+    *ok = false;
+    return NULL;
+  }
+
   Expect(Token::LPAREN, CHECK_OK);
   Expression* expr = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
@@ -1946,6 +1999,13 @@ TryStatement* Parser::ParseTryStatement(bool* ok) {
 
     Expect(Token::LPAREN, CHECK_OK);
     Handle<String> name = ParseIdentifier(CHECK_OK);
+
+    if (strict_mode_ && IsEvalOrArguments(name)) {
+      ReportMessage("strict_catch_variable", Vector<const char*>::empty());
+      *ok = false;
+      return NULL;
+    }
+
     Expect(Token::RPAREN, CHECK_OK);
 
     if (peek() == Token::LBRACE) {
@@ -3188,6 +3248,9 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,
     TemporaryScope temp_scope(&this->temp_scope_);
     top_scope_->SetScopeName(name);
 
+    // Strict mode stack
+    StrictMode strict(&strict_mode_);

[Lasse Reichstein, 2011/01/13 07:18:40]

As stated earlier, we define the TemporaryScope just above, which has the same
liveness and general meaning (collecting stuff to put into FunctionLiteral) as
the StrictMode here.

[Martin Maly, 2011/01/14 00:06:28]

Done.

+
     //  FormalParameterList ::
     //    '(' (Identifier)*[','] ')'
     Expect(Token::LPAREN, CHECK_OK);
@@ -3265,6 +3328,32 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,
       end_pos = scanner().location().end_pos;
     }
 
+    // Validate strict mode.
+    if (strict_mode_) {
+      int position = function_token_position != RelocInfo::kNoPosition
+                       ? function_token_position
+                       : (start_pos > 0 ? start_pos - 1 : start_pos);
+
+      if (IsEvalOrArguments(name)) {
+        ReportMessageAt(Scanner::Location(position, start_pos),
+                        "strict_function_name", Vector<const char*>::empty());
+        *ok = false;
+        return NULL;
+      }
+      if (top_scope_->HasEvalOrArgumentsParameter()) {
+        ReportMessageAt(Scanner::Location(position, start_pos),

[Lasse Reichstein, 2011/01/13 07:18:40]

Could you store the position of the argument that is "eval" or "arguments"?
I.e., so that if thestored position is RelocInfo::kNoPosition, then there is
none, and otherwise it's the position of the offending argument.

[Martin Maly, 2011/01/14 00:06:28]

It is definitely possible. I was trying to avoid any unnecessary work that would
affect non-strict mode code. In this case, checking parameter names for
eval/arguments will have to happen regardless of strict mode because of:

function foo(eval, arguments) { // Seen not in strict mode but must ERR
  "use strict";
}

This check is relatively cheap so I will add it.

On 2011/01/13 07:18:40, Lasse Reichstein wrote:

[Lasse Reichstein, 2011/01/14 11:42:05]

Yes, we need to either detect the problems when they are introduced (to know the
location) before we know that it's strict code, or be able to detect them
properly later.

I prefer just detecting them as soon as possible, and just remember the first
(or last, I don't care) problem that would cause strict mode to fail.
And I think it's much simpler to simply detect strict mode violations when they
occur, and then check at the end whether there was any, if the function is
strict.

[Martin Maly, 2011/01/14 16:30:43]

Sounds good.

On 2011/01/14 11:42:05, Lasse Reichstein wrote:

+                        "strict_param_name", Vector<const char*>::empty());
+        *ok = false;
+        return NULL;
+      }
+      if (top_scope_->HasDuplicateParameterName()) {
+        ReportMessageAt(Scanner::Location(position, start_pos),
+                        "strict_param_dupe", Vector<const char*>::empty());

[Lasse Reichstein, 2011/01/13 07:18:40]

Also here, could you store the actual position of the (second instance of) the
offending variable name?

[Martin Maly, 2011/01/14 00:06:28]

I believe it can be done, also at a relatively small cost to the non-strict mode
parsing.

The only glitch is being able to allocate HashMap temporarily so that only
functions with >N parameters use hashmap for duplicate checks.

How can I allocate such temporary hash map inside V8 parser? I am hoping to put
it onto TemporaryScope as well and allocate it only when needed, and ideally
free it as soon as the arguments have been processed.

On 2011/01/13 07:18:40, Lasse Reichstein wrote:

[Lasse Reichstein, 2011/01/14 11:42:05]

I think I would just drop the HashMap and do the simple, quadratic algorithm in
all cases.
We are comparing symbols, so it's a pretty damn fast check, and I doubt we'll
see any function with more than 10 formal parameters anyway. I.e., let's worry
about that only if it becomes a problem.

[Martin Maly, 2011/01/14 16:30:43]

Done.

+        *ok = false;
+        return NULL;
+      }

[Lasse Reichstein, 2011/01/13 07:18:40]

For later, I would also put the check for octal numbers here.
I imagine letting the scanner hold the position of the most recent octal escape
or octal number literal, and then testing at this point whether it lies between
start_pos and end_pos.
That will report the last octal number, not the first, but I think it's better
than checking all the time.

[Martin Maly, 2011/01/14 00:06:28]

Great idea. that will also handle the case where "use strict" is preceded by
another directive that does contain octal literal. Will do when I implement the
octal detection.

On 2011/01/13 07:18:40, Lasse Reichstein wrote:

+    }
+
     FunctionLiteral* function_literal =
         new FunctionLiteral(name,
                             top_scope_,
@@ -3277,7 +3366,8 @@ FunctionLiteral* Parser::ParseFunctionLiteral(Handle<String> var_name,
                             start_pos,
                             end_pos,
                             function_name->length() > 0,
-                            temp_scope.ContainsLoops());
+                            temp_scope.ContainsLoops(),
+                            strict_mode_);
     function_literal->set_function_token_position(function_token_position);
 
     if (fni_ != NULL && !is_named) fni_->AddFunction(function_literal);