Optimize isFinite and isNaN.

src/ast.h

 // Copyright 2011 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 302 matching lines @@
 
   unsigned id() const { return id_; }
   unsigned test_id() const { return test_id_; }
 
  private:
   unsigned id_;
   unsigned test_id_;
 };
 
 
+/**
+ * A sentinel used during pre parsing that represents some expression
+ * that is a valid left hand side without having to actually build
+ * the expression.
+ */
+class ValidLeftHandSideSentinel: public Expression {
+ public:
+  explicit ValidLeftHandSideSentinel(Isolate* isolate) : Expression(isolate) {}
+  virtual bool IsValidLeftHandSide() { return true; }
+  virtual void Accept(AstVisitor* v) { UNREACHABLE(); }
+  virtual bool IsInlineable() const;
+};
+
+
 class BreakableStatement: public Statement {
  public:
   enum Type {
     TARGET_FOR_ANONYMOUS,
     TARGET_FOR_NAMED_ONLY
   };
 
   // The labels associated with this statement. May be NULL;
   // if it is != NULL, guaranteed to contain at least one entry.
   ZoneStringList* labels() const { return labels_; }
@@ skipping 820 matching lines @@
   bool is_this_;
   bool inside_with_;
   bool is_trivial_;
   int position_;
 
   VariableProxy(Isolate* isolate,
                 Handle<String> name,
                 bool is_this,
                 bool inside_with,
                 int position = RelocInfo::kNoPosition);
+  VariableProxy(Isolate* isolate, bool is_this);
 
   friend class Scope;
 };
 
 
+class VariableProxySentinel: public VariableProxy {
+ public:
+  virtual bool IsValidLeftHandSide() { return !is_this(); }
+
+ private:
+  VariableProxySentinel(Isolate* isolate, bool is_this)
+      : VariableProxy(isolate, is_this) { }
+
+  friend class AstSentinels;
+};
+
+
 class Slot: public Expression {
  public:
   enum Type {
     // A slot in the parameter section on the stack. index() is
     // the parameter index, counting left-to-right, starting at 0.
     PARAMETER,
 
     // A slot in the local section on the stack. index() is
     // the variable index in the stack frame, starting at 0.
     LOCAL,
@@ skipping 137 matching lines @@
   CheckType check_type_;
   SmallMapList receiver_types_;
   Handle<JSFunction> target_;
   Handle<JSObject> holder_;
   Handle<JSGlobalPropertyCell> cell_;
 
   int return_id_;
 };
 
 
+class AstSentinels {
+ public:
+  ~AstSentinels() { }
+
+  // Returns a property singleton property access on 'this'.  Used
+  // during preparsing.
+  Property* this_property() { return &this_property_; }
+  VariableProxySentinel* this_proxy() { return &this_proxy_; }
+  VariableProxySentinel* identifier_proxy() { return &identifier_proxy_; }
+  ValidLeftHandSideSentinel* valid_left_hand_side_sentinel() {
+    return &valid_left_hand_side_sentinel_;
+  }
+  Call* call_sentinel() { return &call_sentinel_; }
+  EmptyStatement* empty_statement() { return &empty_statement_; }
+
+ private:
+  AstSentinels();
+  VariableProxySentinel this_proxy_;
+  VariableProxySentinel identifier_proxy_;
+  ValidLeftHandSideSentinel valid_left_hand_side_sentinel_;
+  Property this_property_;
+  Call call_sentinel_;
+  EmptyStatement empty_statement_;
+
+  friend class Isolate;
+
+  DISALLOW_COPY_AND_ASSIGN(AstSentinels);
+};
+
+
 class CallNew: public Expression {
  public:
   CallNew(Isolate* isolate,
           Expression* expression,
           ZoneList<Expression*>* arguments,
           int pos)
       : Expression(isolate),
         expression_(expression),
         arguments_(arguments),
         pos_(pos) { }
@@ skipping 873 matching lines @@
 
  private:
   Isolate* isolate_;
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_