Change the handling of catch blocks to use context extension objects...

src/parser.cc

 // Copyright 2006-2008 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 2046 matching lines @@
     *ok = false;
     return NULL;
   }
   Expression* exception = ParseExpression(true, CHECK_OK);
   ExpectSemicolon(CHECK_OK);
 
   return NEW(ExpressionStatement(new Throw(exception, pos)));
 }
 
 
-Expression* Parser::MakeCatchContext(Handle<String> id, VariableProxy* value) {
-  ZoneListWrapper<ObjectLiteral::Property> properties =
-      factory()->NewList<ObjectLiteral::Property>(1);
-  Literal* key = NEW(Literal(id));
-  ObjectLiteral::Property* property = NEW(ObjectLiteral::Property(key, value));
-  properties.Add(property);
-
-  // This must be called always, even during pre-parsing!
-  // (Computation of literal index must happen before pre-parse bailout.)
-  int literal_index = temp_scope_->NextMaterializedLiteralIndex();
-  if (is_pre_parsing_) {
-    return NULL;
-  }
-
-  // Construct the expression for calling Runtime::CreateObjectLiteral
-  // with the literal array as argument.
-  Handle<FixedArray> constant_properties = Factory::empty_fixed_array();
-  ZoneList<Expression*>* arguments = new ZoneList<Expression*>(1);
-  arguments->Add(new Literal(constant_properties));
-
-  return new ObjectLiteral(constant_properties,
-                           properties.elements(),
-                           literal_index);
-}
-
-
 TryStatement* Parser::ParseTryStatement(bool* ok) {
   // TryStatement ::
   //   'try' Block Catch
   //   'try' Block Finally
   //   'try' Block Catch Finally
   //
   // Catch ::
   //   'catch' '(' Identifier ')' Block
   //
   // Finally ::
@@ skipping 31 matching lines @@
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
     Handle<String> name = ParseIdentifier(CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
 
     if (peek() == Token::LBRACE) {
       // Allocate a temporary for holding the finally state while
       // executing the finally block.
       catch_var = top_scope_->NewTemporary(Factory::catch_var_symbol());
-      Expression* obj = MakeCatchContext(name, catch_var);
+      Literal* name_literal = NEW(Literal(name));
+      Expression* obj = NEW(CatchExtensionObject(name_literal, catch_var));
       { Target target(this, &catch_collector);
         catch_block = WithHelper(obj, NULL, true, CHECK_OK);
       }
     } else {
       Expect(Token::LBRACE, CHECK_OK);
     }
 
     tok = peek();
   }
 
@@ skipping 941 matching lines @@
     // value for COMPUTED properties, the real value is filled in at
     // runtime. The enumeration order is maintained.
     Handle<Object> key = property->key()->handle();
     Literal* literal = GetBoilerplateValue(property);
 
     // Add name, value pair to the fixed array.
     constant_properties->set(position++, *key);
     constant_properties->set(position++, *literal->handle());
   }
 
-  // Construct the expression for calling Runtime::CreateObjectLiteral
-  // with the literal array as argument.
-  ZoneList<Expression*>* arguments = new ZoneList<Expression*>(1);
-  arguments->Add(new Literal(constant_properties));
   return new ObjectLiteral(constant_properties,
                            properties.elements(),
                            literal_index);
 }
 
 
 Expression* Parser::ParseRegExpLiteral(bool seen_equal, bool* ok) {
   if (!scanner_.ScanRegExpPattern(seen_equal)) {
     Next();
     ReportMessage("unterminated_regexp", Vector<const char*>::empty());
@@ skipping 1258 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal