[csa] Replace remaining old-style GetProperty calls

src/builtins/builtins-promise.cc

 // Copyright 2016 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/builtins/builtins-promise.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
@@ skipping 262 matching lines @@
   StoreObjectFieldNoWriteBarrier(promise, JSPromise::kFlagsOffset, new_flags);
 }
 
 Node* PromiseBuiltinsAssembler::SpeciesConstructor(Node* context, Node* object,
                                                    Node* default_constructor) {
   Isolate* isolate = this->isolate();
   Variable var_result(this, MachineRepresentation::kTagged);
   var_result.Bind(default_constructor);
 
   // 2. Let C be ? Get(O, "constructor").
-  Node* const constructor_str =
-      HeapConstant(isolate->factory()->constructor_string());
-  Callable getproperty_callable = CodeFactory::GetProperty(isolate);
   Node* const constructor =
-      CallStub(getproperty_callable, context, object, constructor_str);
+      GetProperty(context, object, isolate->factory()->constructor_string());
 
   // 3. If C is undefined, return defaultConstructor.
   Label out(this);
   GotoIf(IsUndefined(constructor), &out);
 
   // 4. If Type(C) is not Object, throw a TypeError exception.
   ThrowIfNotJSReceiver(context, constructor,
                        MessageTemplate::kConstructorNotReceiver);
 
   // 5. Let S be ? Get(C, @@species).
-  Node* const species_symbol =
-      HeapConstant(isolate->factory()->species_symbol());
   Node* const species =
-      CallStub(getproperty_callable, context, constructor, species_symbol);
+      GetProperty(context, constructor, isolate->factory()->species_symbol());
 
   // 6. If S is either undefined or null, return defaultConstructor.
   GotoIf(IsUndefined(species), &out);
   GotoIf(WordEqual(species, NullConstant()), &out);
 
   // 7. If IsConstructor(S) is true, return S.
   Label throw_error(this);
   Node* species_bitfield = LoadMapBitField(LoadMap(species));
   GotoIfNot(Word32Equal(Word32And(species_bitfield,
                                   Int32Constant((1 << Map::kIsConstructor))),
@@ skipping 434 matching lines @@
         InternalPromiseReject(context, promise, thenable_value, false);
         PromiseSetHasHandler(result);
         Goto(&out);
       }
     }
   }
 
   Bind(&if_notnativepromise);
   {
     // 8. Let then be Get(resolution, "then").
-    Node* const then_str = HeapConstant(isolate->factory()->then_string());
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
     Node* const then =
-        CallStub(getproperty_callable, context, result, then_str);
+        GetProperty(context, result, isolate->factory()->then_string());
 
     // 9. If then is an abrupt completion, then
     GotoIfException(then, &if_rejectpromise, &var_reason);
 
     // 11. If IsCallable(thenAction) is false, then
     GotoIf(TaggedIsSmi(then), &fulfill);
     Node* const then_map = LoadMap(then);
     GotoIfNot(IsCallableMap(then_map), &fulfill);
     var_then.Bind(then);
     Goto(&do_enqueue);
@@ skipping 590 matching lines @@
 
   Bind(&if_internalthen);
   {
     Node* const result =
         InternalPromiseThen(context, promise, on_resolve, on_reject);
     Return(result);
   }
 
   Bind(&if_customthen);
   {
-    Isolate* isolate = this->isolate();
-    Node* const then_str = HeapConstant(isolate->factory()->then_string());
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
     Node* const then =
-        CallStub(getproperty_callable, context, promise, then_str);
-    Callable call_callable = CodeFactory::Call(isolate);
+        GetProperty(context, promise, isolate()->factory()->then_string());
+    Callable call_callable = CodeFactory::Call(isolate());
     Node* const result =
         CallJS(call_callable, context, then, promise, on_resolve, on_reject);
     Return(result);
   }
 }
 
 TF_BUILTIN(PromiseResolve, PromiseBuiltinsAssembler) {
   //  1. Let C be the this value.
   Node* receiver = Parameter(0);
   Node* value = Parameter(1);
@@ skipping 27 matching lines @@
     GotoIfNot(WordEqual(promise_fun, receiver), &if_valueisnotnativepromise);
     Return(value);
   }
 
   // At this point, value or/and receiver are not native promises, but
   // they could be of the same subclass.
   Bind(&if_valueisnotnativepromise);
   {
     // 3.a Let xConstructor be ? Get(x, "constructor").
     // The constructor lookup is observable.
-    Node* const constructor_str =
-        HeapConstant(isolate->factory()->constructor_string());
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
     Node* const constructor =
-        CallStub(getproperty_callable, context, value, constructor_str);
+        GetProperty(context, value, isolate->factory()->constructor_string());
 
     // 3.b If SameValue(xConstructor, C) is true, return x.
     GotoIfNot(SameValue(constructor, receiver), &if_valueisnotpromise);
 
     Return(value);
   }
 
   Bind(&if_valueisnotpromise);
   {
     Label if_nativepromise(this), if_notnativepromise(this);
@@ skipping 315 matching lines @@
   {
     Node* deferred_promise = AllocateAndInitJSPromise(context, promise);
     InternalPerformPromiseThen(context, promise, var_then_finally.value(),
                                var_catch_finally.value(), deferred_promise,
                                UndefinedConstant(), UndefinedConstant());
     Return(deferred_promise);
   }
 
   Bind(&if_custompromise);
   {
-    Isolate* isolate = this->isolate();
-    Node* const then_str = HeapConstant(isolate->factory()->then_string());
-    Callable getproperty_callable = CodeFactory::GetProperty(isolate);
     Node* const then =
-        CallStub(getproperty_callable, context, promise, then_str);
-    Callable call_callable = CodeFactory::Call(isolate);
+        GetProperty(context, promise, isolate()->factory()->then_string());
+    Callable call_callable = CodeFactory::Call(isolate());
     // 5. Return ?  Invoke(promise, "then", « thenFinally, catchFinally »).
     Node* const result =
         CallJS(call_callable, context, then, promise, var_then_finally.value(),
                var_catch_finally.value());
     Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8