Move ParseUnaryExpression into ParserBase and add tests.

src/parser.h

 // 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 438 matching lines @@
           function_state->saved_ast_node_id_);
     }
   }
 
   // Helper functions for recursive descent.
   bool IsEvalOrArguments(Handle<String> identifier) const;
 
   // Returns true if the expression is of type "this.foo".
   static bool IsThisProperty(Expression* expression);
 
+  static bool IsIdentifier(Expression* expression);
+
   static bool IsBoilerplateProperty(ObjectLiteral::Property* property) {
     return ObjectLiteral::IsBoilerplateProperty(property);
   }
 
   static bool IsArrayIndex(Handle<String> string, uint32_t* index) {
     return !string.is_null() && string->AsArrayIndex(index);
   }
 
   // Functions for encapsulating the differences between parsing and preparsing;
   // operations interleaved with the recursive descent.
@@ skipping 29 matching lines @@
   // in strict mode.
   void CheckStrictModeLValue(Expression*expression, bool* ok);
 
   // Returns true if we have a binary expression between two numeric
   // literals. In that case, *x will be changed to an expression which is the
   // computed value.
   bool ShortcutNumericLiteralBinaryExpression(
       Expression** x, Expression* y, Token::Value op, int pos,
       AstNodeFactory<AstConstructionVisitor>* factory);
 
+  // Returns true if we can shortcut the unary expression ("not <literal>" or
+  // "+/- <numeric literal>"). In that case, *expression will be changed to the
+  // shortcut.
+  bool ShortcutLiteralUnaryExpression(

[rossberg, 2014/03/19 11:41:46]

Nit: not sure I like the name. This is doing constant folding, so maybe rather
call it FoldUnaryExpression (and say "constant-fold" instead of "shortcut" in
the comment.

+      Expression** expression, Token::Value op, int pos,
+      AstNodeFactory<AstConstructionVisitor>* factory);
+
+  // Returns true if we can desugar '+foo' into 'foo*1' (plus other similar
+  // constructs). This enables the collection of type feedback without any
+  // special stub and the multiplication is removed later in Crankshaft's
+  // canonicalization pass.
+  bool AddUnaryExpressionTypeFeedback(

[rossberg, 2014/03/19 11:41:46]

Similarly here. I'd perhaps call this RewriteUnaryExpression.

In fact, wouldn't it be possible to merge both these helpers into one function
returning the actual expression directly, such that you can simply do

  return BuildUnaryExpression(expression, op, pos, factory())

in ParseUnaryExpression (after checking the DELETE case)?

[marja, 2014/03/19 12:12:43]

Done.

+      Expression** expression, Token::Value op, int pos,
+      AstNodeFactory<AstConstructionVisitor>* factory);
+
   // Reporting errors.
   void ReportMessageAt(Scanner::Location source_location,
                        const char* message,
                        Vector<const char*> args,
                        bool is_reference_error = false);
   void ReportMessage(const char* message,
                      Vector<Handle<String> > args,
                      bool is_reference_error = false);
   void ReportMessageAt(Scanner::Location source_location,
                        const char* message,
@@ skipping 43 matching lines @@
   // Temporary glue; these functions will move to ParserBase.
   Expression* ParseV8Intrinsic(bool* ok);
   FunctionLiteral* ParseFunctionLiteral(
       Handle<String> name,
       Scanner::Location function_name_location,
       bool name_is_strict_reserved,
       bool is_generator,
       int function_token_position,
       FunctionLiteral::FunctionType type,
       bool* ok);
-  Expression* ParseUnaryExpression(bool* ok);
+  Expression* ParsePostfixExpression(bool* ok);
 
  private:
   Parser* parser_;
 };
 
 
 class Parser : public ParserBase<ParserTraits> {
  public:
   explicit Parser(CompilationInfo* info);
   ~Parser() {
@@ skipping 254 matching lines @@
  private:
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_