[cleanup][csa] Remove unused using compiler::Node* occurences

Also add the qualifier `compiler::` to places where it should have been
used in the first place.

Bug: v9:6949
Change-Id: Ib5ca6829cd9d72b1e3047afc92363910c902bbbf
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2731529Reviewed-by: Nico Hartmann <nicohartmann@chromium.org>
Reviewed-by: Mythri Alle <mythria@chromium.org>
Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#73155}

src/builtins/builtins-array-gen.cc

@@ -19,9 +19,6 @@
 namespace v8 {
 namespace internal {
 
-using Node = compiler::Node;
-using IteratorRecord = TorqueStructIteratorRecord;
-
 ArrayBuiltinsAssembler::ArrayBuiltinsAssembler(
     compiler::CodeAssemblerState* state)
     : CodeStubAssembler(state),

src/builtins/builtins-async-gen.cc

@@ -13,8 +13,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
-
 namespace {
 // Describe fields of Context associated with the AsyncIterator unwrap closure.
 class ValueUnwrapContext {

src/builtins/builtins-async-generator-gen.cc

@@ -14,8 +14,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
-
 namespace {
 
 class AsyncGeneratorBuiltinsAssembler : public AsyncBuiltinsAssembler {

src/builtins/builtins-collections-gen.cc

@@ -19,7 +19,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
 template <class T>
 using TVariable = compiler::TypedCodeAssemblerVariable<T>;
 

src/builtins/builtins-constructor-gen.cc

@@ -175,8 +175,6 @@ void CallOrConstructBuiltinsAssembler::BuildConstructWithSpread(
   CallOrConstructWithSpread(target, new_target, spread, argc, eager_context);
 }
 
-using Node = compiler::Node;
-
 TF_BUILTIN(FastNewClosure, ConstructorBuiltinsAssembler) {
   auto shared_function_info =
       Parameter<SharedFunctionInfo>(Descriptor::kSharedFunctionInfo);

src/builtins/builtins-iterator-gen.cc

@@ -16,7 +16,6 @@ namespace v8 {
 namespace internal {
 
 using IteratorRecord = TorqueStructIteratorRecord;
-using compiler::Node;
 
 TNode<Object> IteratorBuiltinsAssembler::GetIteratorMethod(
     TNode<Context> context, TNode<Object> object) {

src/builtins/builtins-iterator-gen.h

@@ -10,8 +10,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
-
 class GrowableFixedArray;
 
 class IteratorBuiltinsAssembler : public CodeStubAssembler {

src/builtins/builtins-proxy-gen.h

@@ -10,7 +10,6 @@
 
 namespace v8 {
 namespace internal {
-using compiler::Node;
 
 class ProxiesCodeStubAssembler : public CodeStubAssembler {
  public:

src/builtins/builtins-regexp-gen.cc

@@ -22,8 +22,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
-
 // Tail calls the regular expression interpreter.
 // static
 void Builtins::Generate_RegExpInterpreterTrampoline(MacroAssembler* masm) {

src/builtins/builtins-string-gen.cc

@@ -18,8 +18,6 @@
 namespace v8 {
 namespace internal {
 
-using Node = compiler::Node;
-
 TNode<RawPtrT> StringBuiltinsAssembler::DirectStringData(
     TNode<String> string, TNode<Word32T> string_instance_type) {
   // Compute the effective offset of the first character.

src/builtins/builtins-typed-array-gen.cc

@@ -15,8 +15,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
-
 // -----------------------------------------------------------------------------
 // ES6 section 22.2 TypedArray Objects
 

src/codegen/code-stub-assembler.cc

@@ -30,8 +30,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::Node;
-
 CodeStubAssembler::CodeStubAssembler(compiler::CodeAssemblerState* state)
     : compiler::CodeAssembler(state),
       TorqueGeneratedExportedMacrosAssembler(state) {

src/codegen/code-stub-assembler.h

@@ -305,7 +305,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
     : public compiler::CodeAssembler,
       public TorqueGeneratedExportedMacrosAssembler {
  public:
-  using Node = compiler::Node;
   using ScopedExceptionHandler = compiler::ScopedExceptionHandler;
 
   template <typename T>
@@ -3849,8 +3848,6 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
 
 class V8_EXPORT_PRIVATE CodeStubArguments {
  public:
-  using Node = compiler::Node;
-
   // |argc| specifies the number of arguments passed to the builtin excluding
   // the receiver. The arguments include the receiver.
   CodeStubArguments(CodeStubAssembler* assembler, TNode<IntPtrT> argc)

src/codegen/tnode.h

@@ -353,10 +353,8 @@ class TNode {
 
   static TNode UncheckedCast(compiler::Node* node) { return TNode(node); }
 
- protected:
-  explicit TNode(compiler::Node* node) : node_(node) { LazyTemplateChecks(); }
-
  private:
+  explicit TNode(compiler::Node* node) : node_(node) { LazyTemplateChecks(); }
   // These checks shouldn't be checked before TNode is actually used.
   void LazyTemplateChecks() {
     static_assert(is_valid_type_tag<T>::value, "invalid type tag");

src/ic/accessor-assembler.cc

@@ -24,9 +24,6 @@
 namespace v8 {
 namespace internal {
 
-using compiler::CodeAssemblerState;
-using compiler::Node;
-
 //////////////////// Private helpers.
 
 // Loads dataX field from the DataHandler object.

src/ic/accessor-assembler.h

@@ -20,8 +20,6 @@ class ExitPoint;
 
 class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  public:
-  using Node = compiler::Node;
-
   explicit AccessorAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 

src/torque/csa-generator.cc

@@ -747,7 +747,7 @@ void CSAGenerator::EmitInstruction(const CallRuntimeInstruction& instruction,
 void CSAGenerator::EmitInstruction(const BranchInstruction& instruction,
                                    Stack<std::string>* stack) {
   out() << "    ca_.Branch(" << stack->Pop() << ", &"
-        << BlockName(instruction.if_true) << ", std::vector<Node*>{";
+        << BlockName(instruction.if_true) << ", std::vector<compiler::Node*>{";
 
   const auto& true_definitions = instruction.if_true->InputDefinitions();
   DCHECK_EQ(stack->Size(), true_definitions.Size());
@@ -760,7 +760,8 @@ void CSAGenerator::EmitInstruction(const BranchInstruction& instruction,
     }
   }
 
-  out() << "}, &" << BlockName(instruction.if_false) << ", std::vector<Node*>{";
+  out() << "}, &" << BlockName(instruction.if_false)
+        << ", std::vector<compiler::Node*>{";
 
   const auto& false_definitions = instruction.if_false->InputDefinitions();
   DCHECK_EQ(stack->Size(), false_definitions.Size());

test/unittests/codegen/code-stub-assembler-unittest.cc

@@ -13,7 +13,6 @@
 #include "test/unittests/compiler/node-test-utils.h"
 
 using ::testing::_;
-using v8::internal::compiler::Node;
 
 namespace c = v8::internal::compiler;
 

test/unittests/interpreter/interpreter-assembler-unittest.h

@@ -57,7 +57,8 @@ class InterpreterAssemblerTest : public TestWithIsolateAndZone {
         const Matcher<compiler::Node*>& index_matcher,
         const Matcher<compiler::Node*>& value_matcher);
 
-    Matcher<Node*> IsWordNot(const Matcher<Node*>& value_matcher);
+    Matcher<compiler::Node*> IsWordNot(
+        const Matcher<compiler::Node*>& value_matcher);
 
     Matcher<compiler::Node*> IsUnsignedByteOperand(
         int offset, LoadSensitivity needs_poisoning);