[csa] Replace remaining old-style GetProperty calls

src/builtins/builtins-conversion.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-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/objects-inl.h"
 
@@ skipping 24 matching lines @@
   return Handle<Code>::null();
 }
 
 // ES6 section 7.1.1 ToPrimitive ( input [ , PreferredType ] )
 void ConversionBuiltinsAssembler::Generate_NonPrimitiveToPrimitive(
     ToPrimitiveHint hint) {
   Node* input = Parameter(TypeConversionDescriptor::kArgument);
   Node* context = Parameter(TypeConversionDescriptor::kContext);
 
   // Lookup the @@toPrimitive property on the {input}.
-  Callable callable = CodeFactory::GetProperty(isolate());
-  Node* to_primitive_symbol = HeapConstant(factory()->to_primitive_symbol());
   Node* exotic_to_prim =
-      CallStub(callable, context, input, to_primitive_symbol);
+      GetProperty(context, input, factory()->to_primitive_symbol());
 
   // Check if {exotic_to_prim} is neither null nor undefined.
   Label ordinary_to_primitive(this);
   GotoIf(WordEqual(exotic_to_prim, NullConstant()), &ordinary_to_primitive);
   GotoIf(WordEqual(exotic_to_prim, UndefinedConstant()),
          &ordinary_to_primitive);
   {
     // Invoke the {exotic_to_prim} method on the {input} with a string
     // representation of the {hint}.
     Callable callable =
@@ skipping 138 matching lines @@
       method_names[0] = factory()->valueOf_string();
       method_names[1] = factory()->toString_string();
       break;
     case OrdinaryToPrimitiveHint::kString:
       method_names[0] = factory()->toString_string();
       method_names[1] = factory()->valueOf_string();
       break;
   }
   for (Handle<String> name : method_names) {
     // Lookup the {name} on the {input}.
-    Callable callable = CodeFactory::GetProperty(isolate());
-    Node* name_string = HeapConstant(name);
-    Node* method = CallStub(callable, context, input, name_string);
+    Node* method = GetProperty(context, input, name);
 
     // Check if the {method} is callable.
     Label if_methodiscallable(this),
         if_methodisnotcallable(this, Label::kDeferred);
     GotoIf(TaggedIsSmi(method), &if_methodisnotcallable);
     Node* method_map = LoadMap(method);
     Branch(IsCallableMap(method_map), &if_methodiscallable,
            &if_methodisnotcallable);
 
     Bind(&if_methodiscallable);
@@ skipping 186 matching lines @@
 
 // ES6 section 12.5.5 typeof operator
 TF_BUILTIN(Typeof, CodeStubAssembler) {
   Node* object = Parameter(TypeofDescriptor::kObject);
 
   Return(Typeof(object));
 }
 
 }  // namespace internal
 }  // namespace v8