Merge arguments branch to bleeding merge.

src/full-codegen.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 95 matching lines @@
     return NULL;
   }
 
  private:
   class Breakable;
   class Iteration;
   class TryCatch;
   class TryFinally;
   class Finally;
   class ForIn;
-  class TestContext;
 
   class NestedStatement BASE_EMBEDDED {
    public:
     explicit NestedStatement(FullCodeGenerator* codegen) : codegen_(codegen) {
       // Link into codegen's nesting stack.
       previous_ = codegen->nesting_stack_;
       codegen->nesting_stack_ = this;
     }
     virtual ~NestedStatement() {
       // Unlink from codegen's nesting stack.
@@ skipping 165 matching lines @@
   // parameter slot.
   int SlotOffset(Slot* slot);
 
   // Determine whether or not to inline the smi case for the given
   // operation.
   bool ShouldInlineSmiCase(Token::Value op);
 
   // Helper function to convert a pure value into a test context.  The value
   // is expected on the stack or the accumulator, depending on the platform.
   // See the platform-specific implementation for details.
-  void DoTest(Expression* condition,
-              Label* if_true,
-              Label* if_false,
-              Label* fall_through);
-  void DoTest(const TestContext* context);
+  void DoTest(Label* if_true, Label* if_false, Label* fall_through);
 
   // Helper function to split control flow and avoid a branch to the
   // fall-through label if it is set up.
 #ifdef V8_TARGET_ARCH_MIPS
   void Split(Condition cc,
              Register lhs,
              const Operand&  rhs,
              Label* if_true,
              Label* if_false,
              Label* fall_through);
@@ skipping 28 matching lines @@
 
   void VisitForStackValue(Expression* expr) {
     StackValueContext context(this);
     VisitInCurrentContext(expr);
   }
 
   void VisitForControl(Expression* expr,
                        Label* if_true,
                        Label* if_false,
                        Label* fall_through) {
-    TestContext context(this, expr, if_true, if_false, fall_through);
+    TestContext context(this, if_true, if_false, fall_through);
     VisitInCurrentContext(expr);
   }
 
   void VisitDeclarations(ZoneList<Declaration*>* declarations);
   void DeclareGlobals(Handle<FixedArray> pairs);
 
   // Try to perform a comparison as a fast inlined literal compare if
   // the operands allow it.  Returns true if the compare operations
   // has been matched and all code generated; false otherwise.
   bool TryLiteralCompare(Token::Value op,
@@ skipping 302 matching lines @@
     virtual void PrepareTest(Label* materialize_true,
                              Label* materialize_false,
                              Label** if_true,
                              Label** if_false,
                              Label** fall_through) const;
     virtual bool IsStackValue() const { return true; }
   };
 
   class TestContext : public ExpressionContext {
    public:
-    TestContext(FullCodeGenerator* codegen,
-                Expression* condition,
-                Label* true_label,
-                Label* false_label,
-                Label* fall_through)
+    explicit TestContext(FullCodeGenerator* codegen,
+                         Label* true_label,
+                         Label* false_label,
+                         Label* fall_through)
         : ExpressionContext(codegen),
-          condition_(condition),
           true_label_(true_label),
           false_label_(false_label),
           fall_through_(fall_through) { }
 
     static const TestContext* cast(const ExpressionContext* context) {
       ASSERT(context->IsTest());
       return reinterpret_cast<const TestContext*>(context);
     }
 
-    Expression* condition() const { return condition_; }
     Label* true_label() const { return true_label_; }
     Label* false_label() const { return false_label_; }
     Label* fall_through() const { return fall_through_; }
 
     virtual void Plug(bool flag) const;
     virtual void Plug(Register reg) const;
     virtual void Plug(Label* materialize_true, Label* materialize_false) const;
     virtual void Plug(Slot* slot) const;
     virtual void Plug(Handle<Object> lit) const;
     virtual void Plug(Heap::RootListIndex) const;
     virtual void PlugTOS() const;
     virtual void DropAndPlug(int count, Register reg) const;
     virtual void PrepareTest(Label* materialize_true,
                              Label* materialize_false,
                              Label** if_true,
                              Label** if_false,
                              Label** fall_through) const;
     virtual bool IsTest() const { return true; }
 
    private:
-    Expression* condition_;
     Label* true_label_;
     Label* false_label_;
     Label* fall_through_;
   };
 
   class EffectContext : public ExpressionContext {
    public:
     explicit EffectContext(FullCodeGenerator* codegen)
         : ExpressionContext(codegen) { }
 
@@ skipping 26 matching lines @@
 
   friend class NestedStatement;
 
   DISALLOW_COPY_AND_ASSIGN(FullCodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_