Remove deprecated PrintableUnique.

src/compiler/js-operator.h

 // Copyright 2013 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.
 
 #ifndef V8_COMPILER_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
 #include "src/compiler/linkage.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
@@ skipping 22 matching lines @@
   // For space reasons, we keep this tightly packed, otherwise we could just use
   // a simple int/int/bool POD.
   const bool immutable_;
   const uint16_t depth_;
   const uint32_t index_;
 };
 
 // Defines the property being loaded from an object by a named load. This is
 // used as a parameter by JSLoadNamed operators.
 struct LoadNamedParameters {
-  PrintableUnique<Name> name;
+  Unique<Name> name;
   ContextualMode contextual_mode;
 };
 
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCall operators.
 struct CallParameters {
   int arity;
   CallFunctionFlags flags;
 };
 
 // Defines the property being stored to an object by a named store. This is
 // used as a parameter by JSStoreNamed operators.
 struct StoreNamedParameters {
   StrictMode strict_mode;
-  PrintableUnique<Name> name;
+  Unique<Name> name;
 };
 
 // Interface for building JavaScript-level operators, e.g. directly from the
 // AST. Most operators have no parameters, thus can be globally shared for all
 // graphs.
 class JSOperatorBuilder {
  public:
   explicit JSOperatorBuilder(Zone* zone) : zone_(zone) {}
 
 #define SIMPLE(name, properties, inputs, outputs) \
@@ skipping 48 matching lines @@
         arguments, 1);
   }
 
   Operator* CallNew(int arguments) {
     return new (zone_)
         Operator1<int>(IrOpcode::kJSCallConstruct, Operator::kNoProperties,
                        arguments, 1, "JSCallConstruct", arguments);
   }
 
   Operator* LoadProperty() { BINOP(JSLoadProperty); }
-  Operator* LoadNamed(PrintableUnique<Name> name,
+  Operator* LoadNamed(Unique<Name> name,
                       ContextualMode contextual_mode = NOT_CONTEXTUAL) {
     LoadNamedParameters parameters = {name, contextual_mode};
     OP1(JSLoadNamed, LoadNamedParameters, parameters, Operator::kNoProperties,
         1, 1);
   }
 
   Operator* StoreProperty(StrictMode strict_mode) {
     OP1(JSStoreProperty, StrictMode, strict_mode, Operator::kNoProperties, 3,
         0);
   }
 
-  Operator* StoreNamed(StrictMode strict_mode, PrintableUnique<Name> name) {
+  Operator* StoreNamed(StrictMode strict_mode, Unique<Name> name) {
     StoreNamedParameters parameters = {strict_mode, name};
     OP1(JSStoreNamed, StoreNamedParameters, parameters, Operator::kNoProperties,
         2, 0);
   }
 
   Operator* DeleteProperty(StrictMode strict_mode) {
     OP1(JSDeleteProperty, StrictMode, strict_mode, Operator::kNoProperties, 2,
         1);
   }
 
   Operator* HasProperty() { NOPROPS(JSHasProperty, 2, 1); }
 
   Operator* LoadContext(uint16_t depth, uint32_t index, bool immutable) {
     ContextAccess access(depth, index, immutable);
     OP1(JSLoadContext, ContextAccess, access,
         Operator::kEliminatable | Operator::kNoWrite, 1, 1);
   }
   Operator* StoreContext(uint16_t depth, uint32_t index) {
     ContextAccess access(depth, index, false);
     OP1(JSStoreContext, ContextAccess, access, Operator::kNoProperties, 2, 1);
   }
 
   Operator* TypeOf() { SIMPLE(JSTypeOf, Operator::kPure, 1, 1); }
   Operator* InstanceOf() { NOPROPS(JSInstanceOf, 2, 1); }
   Operator* Debugger() { NOPROPS(JSDebugger, 0, 0); }
 
   // TODO(titzer): nail down the static parts of each of these context flavors.
   Operator* CreateFunctionContext() { NOPROPS(JSCreateFunctionContext, 1, 1); }
-  Operator* CreateCatchContext(PrintableUnique<String> name) {
-    OP1(JSCreateCatchContext, PrintableUnique<String>, name,
-        Operator::kNoProperties, 1, 1);
+  Operator* CreateCatchContext(Unique<String> name) {
+    OP1(JSCreateCatchContext, Unique<String>, name, Operator::kNoProperties, 1,
+        1);
   }
   Operator* CreateWithContext() { NOPROPS(JSCreateWithContext, 2, 1); }
   Operator* CreateBlockContext() { NOPROPS(JSCreateBlockContext, 2, 1); }
   Operator* CreateModuleContext() { NOPROPS(JSCreateModuleContext, 2, 1); }
   Operator* CreateGlobalContext() { NOPROPS(JSCreateGlobalContext, 2, 1); }
 
   Operator* Runtime(Runtime::FunctionId function, int arguments) {
     const Runtime::Function* f = Runtime::FunctionForId(function);
     DCHECK(f->nargs == -1 || f->nargs == arguments);
     OP1(JSCallRuntime, Runtime::FunctionId, function, Operator::kNoProperties,
@@ skipping 36 matching lines @@
   static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
   static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
     return a == b;
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_