CSE2410 Fall 2014 Bounce

// Implementation of Parser

Parser::Parser(CompilationInfo* info)

      symbol_cache_(0, info->zone()),

      script_(info->script()),

      scanner_(isolate_->unicode_cache()),

      extension_(info->extension()),

      pre_parse_data_(NULL),

      fni_(NULL),

      parenthesized_function_(false),

      zone_(info->zone()),

      info_(info) {

FunctionLiteral* Parser::ParseProgram() {

  Handle<String> source(String::cast(script_->source()));

  isolate()->counters()->total_parse_size()->Increment(source->length());

  ElapsedTimer timer;

    top_scope_->SetLanguageMode(info->language_mode());

    ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());

    bool ok = true;

    ParseSourceElements(body, Token::EOS, info->is_eval(), true, &ok);

    if (ok && !top_scope_->is_classic_mode()) {

    }

    if (ok && is_extended_mode()) {

          FunctionLiteral::ANONYMOUS_EXPRESSION,

          FunctionLiteral::kGlobalOrEval,

          FunctionLiteral::kNotParenthesized,

      result->set_ast_properties(factory()->visitor()->ast_properties());

      result->set_dont_optimize_reason(

          factory()->visitor()->dont_optimize_reason());

      isolate()->StackOverflow();

    }

  }

  ASSERT(target_stack_ == NULL);

  if (result == NULL) {

  } else {

    Handle<String> inferred_name(shared_info->inferred_name());

    result->set_inferred_name(inferred_name);

  // ModuleDeclaration:

  //    'module' Identifier Module

  Handle<String> name = ParseIdentifier(CHECK_OK);

#ifdef DEBUG

  Module* module = ParseModule(CHECK_OK);

  VariableProxy* proxy = NewUnresolved(name, MODULE, module->interface());

  Declaration* declaration =

  Declare(declaration, true, CHECK_OK);

#ifdef DEBUG

  if (names) names->Add(name, zone());

  if (module->body() == NULL)

  else

}

  // Module:

  //    '{' ModuleElement '}'

  // Construct block expecting 16 statements.

#ifdef DEBUG

  if (FLAG_print_interface_details) PrintF("# Literal ");

#endif

  ASSERT(*ok);

  interface->Freeze(ok);

  ASSERT(*ok);

}

  //    Identifier

  //    ModulePath '.' Identifier

  Module* result = ParseModuleVariable(CHECK_OK);

  while (Check(Token::PERIOD)) {

    Handle<String> name = ParseIdentifierName(CHECK_OK);

    if (FLAG_print_interface_details)

      PrintF("# Path .%s ", name->ToAsciiArray());

#endif

    result->interface()->Add(name, member->interface(), zone(), ok);

    if (!*ok) {

#ifdef DEBUG

  // ModulePath:

  //    Identifier

  Handle<String> name = ParseIdentifier(CHECK_OK);

#ifdef DEBUG

  if (FLAG_print_interface_details)

      factory(), name, Interface::NewModule(zone()),

      scanner().location().beg_pos);

}

  // Module:

  //    String

  Expect(Token::STRING, CHECK_OK);

  Handle<String> symbol = GetSymbol();

  // Create an empty literal as long as the feature isn't finished.

  USE(symbol);

  Scope* scope = NewScope(top_scope_, MODULE_SCOPE);

  body->set_scope(scope);

  Interface* interface = scope->interface();

  interface->Freeze(ok);

  ASSERT(*ok);

  interface->Unify(scope->interface(), zone(), ok);

  //

  // TODO(ES6): implement destructuring ImportSpecifiers

  Expect(Token::IMPORT, CHECK_OK);

  ZoneStringList names(1, zone());

  // Generate a separate declaration for each identifier.

  // TODO(ES6): once we implement destructuring, make that one declaration.

  for (int i = 0; i < names.length(); ++i) {

#ifdef DEBUG

    if (FLAG_print_interface_details)

    }

    VariableProxy* proxy = NewUnresolved(names[i], LET, interface);

    Declaration* declaration =

    Declare(declaration, true, CHECK_OK);

  }

  ZoneStringList names(1, zone());

  switch (peek()) {

    case Token::IDENTIFIER: {

      Handle<String> name = ParseIdentifier(CHECK_OK);

      // Handle 'module' as a context-sensitive keyword.

      if (!name->IsOneByteEqualTo(STATIC_ASCII_VECTOR("module"))) {

          names.Add(name, zone());

        }

        ExpectSemicolon(CHECK_OK);

      } else {

        result = ParseModuleDeclaration(&names, CHECK_OK);

      }

    // TODO(rossberg): Rethink whether we actually need to store export

    // declarations (for compilation?).

    // ExportDeclaration* declaration =

    // top_scope_->AddDeclaration(declaration);

  }

  // labels can be simply ignored in all other cases; except for

  // trivial labeled break statements 'label: break label' which is

  // parsed into an empty statement.

  switch (peek()) {

    case Token::LBRACE:

      return ParseBlock(labels, ok);

    case Token::CONST:  // fall through

    case Token::LET:

    case Token::VAR:

    case Token::SEMICOLON:

      Next();

    case Token::IF:

    case Token::DO:

    case Token::WHILE:

    case Token::FOR:

    case Token::CONTINUE:

    case Token::BREAK:

    case Token::RETURN:

    case Token::WITH:

    case Token::SWITCH:

    case Token::THROW:

    case Token::TRY: {

      // NOTE: It is somewhat complicated to have labels on

      // one must take great care not to treat it as a

      // fall-through. It is much easier just to wrap the entire

      // try-statement in a statement block and put the labels there

      Target target(&this->target_stack_, result);

      TryStatement* statement = ParseTryStatement(CHECK_OK);

      if (result) result->AddStatement(statement, zone());

      return result;

    }

    }

    case Token::DEBUGGER:

    default:

  }

}

  // Let/const variables in harmony mode are always added to the immediately

  // enclosing scope.

  return DeclarationScope(mode)->NewUnresolved(

}

// declaration is resolved by looking up the function through a

// callback provided by the extension.

Statement* Parser::ParseNativeDeclaration(bool* ok) {

  Expect(Token::FUNCTION, CHECK_OK);

  Handle<String> name = ParseIdentifier(CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  // because of lazy compilation.

  DeclarationScope(VAR)->ForceEagerCompilation();

  // TODO(1240846): It's weird that native function declarations are

  // introduced dynamically when we meet their declarations, whereas

  // other functions are set up when entering the surrounding scope.

  VariableProxy* proxy = NewUnresolved(name, VAR, Interface::NewValue());

  Declaration* declaration =

  Declare(declaration, true, CHECK_OK);

  return factory()->NewExpressionStatement(

      factory()->NewAssignment(

}

  //   'function' '*' Identifier '(' FormalParameterListopt ')'

  //      '{' FunctionBody '}'

  Expect(Token::FUNCTION, CHECK_OK);

  bool is_generator = allow_generators() && Check(Token::MUL);

  bool is_strict_reserved = false;

  Handle<String> name = ParseIdentifierOrStrictReservedWord(

  FunctionLiteral* fun = ParseFunctionLiteral(name,

                                              is_strict_reserved,

                                              is_generator,

                                              FunctionLiteral::DECLARATION,

                                              CHECK_OK);

  // Even if we're not at the top-level of the global or a function

      is_extended_mode() && !top_scope_->is_global_scope() ? LET : VAR;

  VariableProxy* proxy = NewUnresolved(name, mode, Interface::NewValue());

  Declaration* declaration =

  Declare(declaration, true, CHECK_OK);

  if (names) names->Add(name, zone());

}

  // (ECMA-262, 3rd, 12.2)

  //

  // Construct block expecting 16 statements.

  Target target(&this->target_stack_, result);

  Expect(Token::LBRACE, CHECK_OK);

  while (peek() != Token::RBRACE) {

  //   '{' BlockElement* '}'

  // Construct block expecting 16 statements.

  Scope* block_scope = NewScope(top_scope_, BLOCK_SCOPE);

  // Parse the statements and collect escaping labels.

  // TODO(ES6):

  // ConstBinding ::

  //   BindingPattern '=' AssignmentExpression

  VariableMode mode = VAR;

  // True if the binding needs initialization. 'let' and 'const' declared

  // bindings are created uninitialized by their declaration nodes and

  // is inside an initializer block, it is ignored.

  //

  // Create new block with one expected declaration.

  int nvars = 0;  // the number of variables declared

  Handle<String> name;

  do {

        is_const ? Interface::NewConst() : Interface::NewValue();

    VariableProxy* proxy = NewUnresolved(name, mode, interface);

    Declaration* declaration =

    Declare(declaration, mode != VAR, CHECK_OK);

    nvars++;

    if (declaration_scope->num_var_or_const() > kMaxNumFunctionLocals) {

    Scope* initialization_scope = is_const ? declaration_scope : top_scope_;

    Expression* value = NULL;

    // Harmony consts have non-optional initializers.

    if (peek() == Token::ASSIGN || mode == CONST_HARMONY) {

      Expect(Token::ASSIGN, CHECK_OK);

      value = ParseAssignmentExpression(var_context != kForStatement, CHECK_OK);

      // Don't infer if it is "a = function(){...}();"-like expression.

      if (fni_ != NULL &&

    // Record the end position of the initializer.

    if (proxy->var() != NULL) {

    }

    // Make sure that 'const x' and 'let x' initialize 'x' to undefined.

    if (value == NULL && needs_init) {

    }

    // Global variable declarations must be compiled in a specific

      ZoneList<Expression*>* arguments =

          new(zone()) ZoneList<Expression*>(3, zone());

      // We have at least 1 parameter.

      CallRuntime* initialize;

      if (is_const) {

        initialize = factory()->NewCallRuntime(

            isolate()->factory()->InitializeConstGlobal_string(),

            Runtime::FunctionForId(Runtime::kInitializeConstGlobal),

      } else {

        // Add strict mode.

        // We may want to pass singleton to avoid Literal allocations.

        LanguageMode language_mode = initialization_scope->language_mode();

        // Be careful not to assign a value to the global variable if

        // we're in a with. The initialization value should not

        initialize = factory()->NewCallRuntime(

            isolate()->factory()->InitializeVarGlobal_string(),

            Runtime::FunctionForId(Runtime::kInitializeVarGlobal),

      }

    } else if (needs_init) {

      // Constant initializations always assign to the declared constant which

      // is always at the function scope level. This is only relevant for

      ASSERT(proxy->var() != NULL);

      ASSERT(value != NULL);

      Assignment* assignment =

      value = NULL;

    }

      VariableProxy* proxy =

          initialization_scope->NewUnresolved(factory(), name, interface);

      Assignment* assignment =

    }

    if (fni_ != NULL) fni_->Leave();

  // ExpressionStatement | LabelledStatement ::

  //   Expression ';'

  //   Identifier ':' Statement

  bool starts_with_idenfifier = peek_any_identifier();

  Expression* expr = ParseExpression(true, CHECK_OK);

  if (peek() == Token::COLON && starts_with_idenfifier && expr != NULL &&

      scanner().literal_contains_escapes()) {

    ExpectSemicolon(CHECK_OK);

  }

}

  // IfStatement ::

  //   'if' '(' Expression ')' Statement ('else' Statement)?

  Expect(Token::IF, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  Expression* condition = ParseExpression(true, CHECK_OK);

    Next();

    else_statement = ParseStatement(labels, CHECK_OK);

  } else {

  }

}

  // ContinueStatement ::

  //   'continue' Identifier? ';'

  Expect(Token::CONTINUE, CHECK_OK);

  Handle<String> label = Handle<String>::null();

  Token::Value tok = peek();

    return NULL;

  }

  ExpectSemicolon(CHECK_OK);

}

  // BreakStatement ::

  //   'break' Identifier? ';'

  Expect(Token::BREAK, CHECK_OK);

  Handle<String> label;

  Token::Value tok = peek();

  // empty statements, e.g. 'l1: l2: l3: break l2;'

  if (!label.is_null() && ContainsLabel(labels, label)) {

    ExpectSemicolon(CHECK_OK);

  }

  BreakableStatement* target = NULL;

  target = LookupBreakTarget(label, CHECK_OK);

    return NULL;

  }

  ExpectSemicolon(CHECK_OK);

}

  // ReturnStatement ::

  //   'return' Expression? ';'

  // reporting any errors on it, because of the way errors are

  // reported (underlining).

  Expect(Token::RETURN, CHECK_OK);

  Token::Value tok = peek();

  Statement* result;

      tok == Token::SEMICOLON ||

      tok == Token::RBRACE ||

      tok == Token::EOS) {

  } else {

    return_value = ParseExpression(true, CHECK_OK);

  }

    Expression* generator = factory()->NewVariableProxy(

        current_function_state_->generator_object_variable());

    Expression* yield = factory()->NewYield(

  } else {

  }

  // An ECMAScript program is considered syntactically incorrect if it

    Handle<String> message = isolate()->factory()->illegal_return_string();

    Expression* throw_error =

        NewThrowSyntaxError(message, Handle<Object>::null());

  }

  return result;

}

  //   'with' '(' Expression ')' Statement

  Expect(Token::WITH, CHECK_OK);

  if (!top_scope_->is_classic_mode()) {

    ReportMessage("strict_mode_with", Vector<const char*>::empty());

    stmt = ParseStatement(labels, CHECK_OK);

    with_scope->set_end_position(scanner().location().end_pos);

  }

}

    *default_seen_ptr = true;

  }

  Expect(Token::COLON, CHECK_OK);

  ZoneList<Statement*>* statements =

      new(zone()) ZoneList<Statement*>(5, zone());

  while (peek() != Token::CASE &&

    statements->Add(stat, zone());

  }

}

  // SwitchStatement ::

  //   'switch' '(' Expression ')' '{' CaseClause* '}'

  Target target(&this->target_stack_, statement);

  Expect(Token::SWITCH, CHECK_OK);

  //   'throw' Expression ';'

  Expect(Token::THROW, CHECK_OK);

  if (scanner().HasAnyLineTerminatorBeforeNext()) {

    ReportMessage("newline_after_throw", Vector<const char*>::empty());

    *ok = false;

  Expression* exception = ParseExpression(true, CHECK_OK);

  ExpectSemicolon(CHECK_OK);

}

  //   'finally' Block

  Expect(Token::TRY, CHECK_OK);

  TargetCollector try_collector(zone());

  Block* try_block;

    ASSERT(catch_scope != NULL && catch_variable != NULL);

    int index = current_function_state_->NextHandlerIndex();

    TryCatchStatement* statement = factory()->NewTryCatchStatement(

    statement->set_escaping_targets(try_collector.targets());

    try_block->AddStatement(statement, zone());

    catch_block = NULL;  // Clear to indicate it's been handled.

  }

    ASSERT(catch_scope != NULL && catch_variable != NULL);

    int index = current_function_state_->NextHandlerIndex();

    result = factory()->NewTryCatchStatement(

  } else {

    ASSERT(finally_block != NULL);

    int index = current_function_state_->NextHandlerIndex();

    // Combine the jump targets of the try block and the possible catch block.

    try_collector.targets()->AddAll(*catch_collector.targets(), zone());

  }

  // DoStatement ::

  //   'do' Statement 'while' '(' Expression ')' ';'

  Target target(&this->target_stack_, loop);

  Expect(Token::DO, CHECK_OK);

  Expect(Token::WHILE, CHECK_OK);

  Expect(Token::LPAREN, CHECK_OK);

  Expression* cond = ParseExpression(true, CHECK_OK);

  Expect(Token::RPAREN, CHECK_OK);

  // WhileStatement ::

  //   'while' '(' Expression ')' Statement

  Target target(&this->target_stack_, loop);

  Expect(Token::WHILE, CHECK_OK);

    // var result = iterator.next();

    {

      Expression* iterator_proxy = factory()->NewVariableProxy(iterator);

      Expression* next_property = factory()->NewProperty(

          iterator_proxy, next_literal, RelocInfo::kNoPosition);

      ZoneList<Expression*>* next_arguments =

    // result.done

    {

      Expression* result_proxy = factory()->NewVariableProxy(result);

      result_done = factory()->NewProperty(

          result_proxy, done_literal, RelocInfo::kNoPosition);

    // each = result.value

    {

      Expression* result_proxy = factory()->NewVariableProxy(result);

      Expression* result_value = factory()->NewProperty(

          result_proxy, value_literal, RelocInfo::kNoPosition);

  // ForStatement ::

  //   'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement

  Statement* init = NULL;

  // Create an in-between scope for let-bound iteration variables.

      if (!name.is_null() && CheckInOrOf(accept_OF, &mode)) {

        Interface* interface =

            is_const ? Interface::NewConst() : Interface::NewValue();

        Target target(&this->target_stack_, loop);

        Expression* enumerable = ParseExpression(true, CHECK_OK);

            top_scope_->NewUnresolved(factory(), name, interface);

        Statement* body = ParseStatement(NULL, CHECK_OK);

        InitializeForEachStatement(loop, each, enumerable, body);

        result->AddStatement(variable_statement, zone());

        result->AddStatement(loop, zone());

        top_scope_ = saved_scope;

        Handle<String> tempname = heap_factory->InternalizeString(tempstr);

        Variable* temp = top_scope_->DeclarationScope()->NewTemporary(tempname);

        VariableProxy* temp_proxy = factory()->NewVariableProxy(temp);

        Target target(&this->target_stack_, loop);

        // The expression does not see the loop variable.

        VariableProxy* each =

            top_scope_->NewUnresolved(factory(), name, Interface::NewValue());

        Statement* body = ParseStatement(NULL, CHECK_OK);

        Assignment* assignment = factory()->NewAssignment(

            Token::ASSIGN, each, temp_proxy, RelocInfo::kNoPosition);

        body_block->AddStatement(variable_statement, zone());

        body_block->AddStatement(assignment_statement, zone());

        body_block->AddStatement(body, zone());

              isolate()->factory()->invalid_lhs_in_for_in_string();

          expression = NewThrowReferenceError(message);

        }

        Target target(&this->target_stack_, loop);

        Expression* enumerable = ParseExpression(true, CHECK_OK);

        return loop;

      } else {

      }

    }

  }

  // Standard 'for' loop

  Target target(&this->target_stack_, loop);

  // Parsed initializer at this point.

  Statement* next = NULL;

  if (peek() != Token::RPAREN) {

    Expression* exp = ParseExpression(true, CHECK_OK);

  }

  Expect(Token::RPAREN, CHECK_OK);

    //     for (; c; n) b

    //   }

    ASSERT(init != NULL);

    result->AddStatement(init, zone());

    result->AddStatement(loop, zone());

    result->set_scope(for_scope);

  Expression* result = ParseAssignmentExpression(accept_IN, CHECK_OK);

  while (peek() == Token::COMMA) {

    Expect(Token::COMMA, CHECK_OK);

    Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

  }

  return result;

}

  MarkAsLValue(expression);

  Token::Value op = Next();  // Get assignment operator.

  Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

  // TODO(1231235): We try to estimate the set of properties set by

Expression* Parser::ParseYieldExpression(bool* ok) {

  // YieldExpression ::

  //   'yield' '*'? AssignmentExpression

  Expect(Token::YIELD, CHECK_OK);

  Yield::Kind kind =

      Check(Token::MUL) ? Yield::DELEGATING : Yield::SUSPEND;

  Expression* generator_object = factory()->NewVariableProxy(

      current_function_state_->generator_object_variable());

  Expression* expression = ParseAssignmentExpression(false, CHECK_OK);

  if (kind == Yield::DELEGATING) {

    yield->set_index(current_function_state_->NextHandlerIndex());

  }

  //   LogicalOrExpression

  //   LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression

  // We start using the binary expression parser for prec >= 4 only!

  Expression* expression = ParseBinaryExpression(4, accept_IN, CHECK_OK);

  if (peek() != Token::CONDITIONAL) return expression;

  // In parsing the first assignment expression in conditional

  // expressions we always accept the 'in' keyword; see ECMA-262,

  // section 11.12, page 58.

  Expression* left = ParseAssignmentExpression(true, CHECK_OK);

  Expect(Token::COLON, CHECK_OK);

  Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);

}

  if (tok == Token::IN && !accept_IN)

    return 0;  // 0 precedence will terminate binary expression parsing

    // prec1 >= 4

    while (Precedence(peek(), accept_IN) == prec1) {

      Token::Value op = Next();

      Expression* y = ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);

      // Compute some expressions involving only number literals.

        switch (op) {

          case Token::ADD:

            continue;

          case Token::SUB:

            continue;

          case Token::MUL:

            continue;

          case Token::DIV:

            continue;

          case Token::BIT_OR: {

            int value = DoubleToInt32(x_val) | DoubleToInt32(y_val);

            continue;

          }

          case Token::BIT_AND: {

            int value = DoubleToInt32(x_val) & DoubleToInt32(y_val);

            continue;

          }

          case Token::BIT_XOR: {

            int value = DoubleToInt32(x_val) ^ DoubleToInt32(y_val);

            continue;

          }

          case Token::SHL: {

            int value = DoubleToInt32(x_val) << (DoubleToInt32(y_val) & 0x1f);

            continue;

          }

          case Token::SHR: {

            uint32_t shift = DoubleToInt32(y_val) & 0x1f;

            uint32_t value = DoubleToUint32(x_val) >> shift;

            continue;

          }

          case Token::SAR: {

            uint32_t shift = DoubleToInt32(y_val) & 0x1f;

            int value = ArithmeticShiftRight(DoubleToInt32(x_val), shift);

            continue;

          }

          default:

          case Token::NE_STRICT: cmp = Token::EQ_STRICT; break;

          default: break;

        }

        if (cmp != op) {

          // The comparison was negated - add a NOT.

        }

      } else {

        // We have a "normal" binary operation.

      }

    }

  }

  Token::Value op = peek();

  if (Token::IsUnaryOp(op)) {

    op = Next();

    Expression* expression = ParseUnaryExpression(CHECK_OK);

    if (expression != NULL && (expression->AsLiteral() != NULL)) {

      if (op == Token::NOT) {

        // Convert the literal to a boolean condition and negate it.

        bool condition = literal->BooleanValue();

      } else if (literal->IsNumber()) {

        // Compute some expressions involving only number literals.

        double value = literal->Number();

          case Token::ADD:

            return expression;

          case Token::SUB:

          case Token::BIT_NOT:

          default:

            break;

        }

    if (op == Token::ADD) {

      return factory()->NewBinaryOperation(Token::MUL,

                                           expression,

    }

    // The same idea for '-foo' => 'foo*(-1)'.

    if (op == Token::SUB) {

      return factory()->NewBinaryOperation(Token::MUL,

                                           expression,

    }

    // ...and one more time for '~foo' => 'foo^(~0)'.

    if (op == Token::BIT_NOT) {

      return factory()->NewBinaryOperation(Token::BIT_XOR,

                                           expression,

    }

  } else if (Token::IsCountOp(op)) {

    op = Next();

    }

    MarkAsLValue(expression);

    return factory()->NewCountOperation(op,

                                        true /* prefix */,

                                        expression,

  } else {

    return ParsePostfixExpression(ok);

    MarkAsLValue(expression);

    Token::Value next = Next();

    expression =

        factory()->NewCountOperation(next,

                                     false /* postfix */,

                                     expression,

  }

  return expression;

}

    switch (peek()) {

      case Token::LBRACK: {

        Consume(Token::LBRACK);

        Expression* index = ParseExpression(true, CHECK_OK);

        result = factory()->NewProperty(result, index, pos);

        Expect(Token::RBRACK, CHECK_OK);

        if (scanner().current_token() == Token::IDENTIFIER) {

          // For call of an identifier we want to report position of

          // the identifier as position of the call in the stack trace.

        } else {

          // For other kinds of calls we record position of the parenthesis as

          // position of the call.  Note that this is extremely important for

          // expressions of the form function(){...}() for which call position

          // should not point to the closing brace otherwise it will intersect

          // with positions recorded for function literal and confuse debugger.

          // Also the trailing parenthesis are a hint that the function will

          // be called immediately. If we happen to have parsed a preceding

          // function literal eagerly, we can also compile it eagerly.

      case Token::PERIOD: {

        Consume(Token::PERIOD);

        Handle<String> name = ParseIdentifierName(CHECK_OK);

        if (fni_ != NULL) fni_->PushLiteralName(name);

        break;

      }

  // member expression parser, which is only allowed to match argument

  // lists as long as it has 'new' prefixes left

  Expect(Token::NEW, CHECK_OK);

  Expression* result;

  if (peek() == Token::NEW) {

  Expression* result = NULL;

  if (peek() == Token::FUNCTION) {

    Expect(Token::FUNCTION, CHECK_OK);

    bool is_generator = allow_generators() && Check(Token::MUL);

    Handle<String> name;

    bool is_strict_reserved_name = false;

    switch (peek()) {

      case Token::LBRACK: {

        Consume(Token::LBRACK);

        Expression* index = ParseExpression(true, CHECK_OK);

        result = factory()->NewProperty(result, index, pos);

        if (fni_ != NULL) {

      }

      case Token::PERIOD: {

        Consume(Token::PERIOD);

        Handle<String> name = ParseIdentifierName(CHECK_OK);

        if (fni_ != NULL) fni_->PushLiteralName(name);

        break;

      }

        if ((stack == NULL) || stack->is_empty()) return result;

        // Consume one of the new prefixes (already parsed).

        ZoneList<Expression*>* args = ParseArguments(CHECK_OK);

        break;

      }

      default:

  // DebuggerStatement ::

  //   'debugger' ';'

  Expect(Token::DEBUGGER, CHECK_OK);

  ExpectSemicolon(CHECK_OK);

}

  // We don't report stack overflows here, to avoid increasing the

  // stack depth even further.  Instead we report it after parsing is

  // over, in ParseProgram/ParseJson.

  // Four of the tokens are treated specially

  switch (token) {

    case Token::EOS:

  //   RegExpLiteral

  //   '(' Expression ')'

  Expression* result = NULL;

  switch (peek()) {

    case Token::THIS: {

    case Token::NULL_LITERAL:

      Consume(Token::NULL_LITERAL);

      break;

    case Token::TRUE_LITERAL:

      Consume(Token::TRUE_LITERAL);

      break;

    case Token::FALSE_LITERAL:

      Consume(Token::FALSE_LITERAL);

      break;

    case Token::IDENTIFIER:

        PrintF("# Variable %s ", name->ToAsciiArray());

#endif

      Interface* interface = Interface::NewUnknown(zone());

      break;

    }

                                    scanner().literal_ascii_string(),

                                    ALLOW_HEX | ALLOW_OCTAL |

                                        ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY);

      break;

    }

    case Token::STRING: {

      Consume(Token::STRING);

      Handle<String> symbol = GetSymbol();

      if (fni_ != NULL) fni_->PushLiteralName(symbol);

      break;

    }

  // ArrayLiteral ::

  //   '[' Expression? (',' Expression?)* ']'

  ZoneList<Expression*>* values = new(zone()) ZoneList<Expression*>(4, zone());

  Expect(Token::LBRACK, CHECK_OK);

  while (peek() != Token::RBRACK) {

    Expression* elem;

    if (peek() == Token::COMMA) {

    } else {

      elem = ParseAssignmentExpression(true, CHECK_OK);

    }

  literals->set(1, *element_values);

  return factory()->NewArrayLiteral(

}

}