Deprecte LoweringBuilder in favor of Reducer.

src/compiler/js-generic-lowering.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-aux-data-inl.h"
@@ skipping 138 matching lines @@
  private:
   virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
   virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
   virtual bool UseSpecialCache() V8_OVERRIDE { return true; }
 
   StrictMode strict_mode_;
 };
 
 
 JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph,
-                                     MachineOperatorBuilder* machine,
-                                     SourcePositionTable* source_positions)
-    : LoweringBuilder(jsgraph->graph(), source_positions),
-      info_(info),
+                                     MachineOperatorBuilder* machine)
+    : info_(info),
       jsgraph_(jsgraph),
       linkage_(new (jsgraph->zone()) Linkage(info)),
       machine_(machine) {}
 
 
 void JSGenericLowering::PatchOperator(Node* node, Operator* op) {
   node->set_op(op);
 }
 
 
@@ skipping 20 matching lines @@
 Node* JSGenericLowering::FunctionConstant(Handle<JSFunction> function) {
   return jsgraph()->HeapConstant(function);
 }
 
 
 Node* JSGenericLowering::ExternalConstant(ExternalReference ref) {
   return jsgraph()->ExternalConstant(ref);
 }
 
 
-void JSGenericLowering::Lower(Node* node) {
+Reduction JSGenericLowering::Reduce(Node* node) {
   Node* replacement = NULL;
   // Dispatch according to the opcode.
   switch (node->opcode()) {
 #define DECLARE_CASE(x)           \
   case IrOpcode::k##x:            \
     replacement = Lower##x(node); \
     break;
     DECLARE_CASE(Branch)
     JS_OP_LIST(DECLARE_CASE)
 #undef DECLARE_CASE
     default:
       // Nothing to see.
-      return;
+      return NoChange();
   }
-
-  // Nothing to do if lowering was done by patching the existing node.
-  if (replacement == node) return;
-
-  // Iterate through uses of the original node and replace uses accordingly.
-  UNIMPLEMENTED();
+  DCHECK_EQ(node, replacement);
+  return Changed(replacement);
 }
 
 
 #define REPLACE_IC_STUB_CALL(op, StubDeclaration)  \
   Node* JSGenericLowering::Lower##op(Node* node) { \
     StubDeclaration;                               \
     ReplaceWithICStubCall(node, &stub);            \
     return node;                                   \
   }
 REPLACE_IC_STUB_CALL(JSBitwiseOr, BinaryOpICStub stub(isolate(), Token::BIT_OR))
@@ skipping 307 matching lines @@
 
 Node* JSGenericLowering::LowerJSCallRuntime(Node* node) {
   Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
   int arity = OperatorProperties::GetValueInputCount(node->op());
   ReplaceWithRuntimeCall(node, function, arity);
   return node;
 }
 }
 }
 }  // namespace v8::internal::compiler