Add CALL_FUNCTION_TYPE_INIT

Bypass `_type_dunder_call` in cases where types do not define a
`__new__` and are not a metaclass. Cache the `__init__` and call it
directly.

Add tests.

runtime/bytecode.h

···
   V(UNUSED_BYTECODE_172, 172, doInvalidBytecode)                               \
   V(UNUSED_BYTECODE_173, 173, doInvalidBytecode)                               \
   V(UNUSED_BYTECODE_174, 174, doInvalidBytecode)                               \
-  V(UNUSED_BYTECODE_175, 175, doInvalidBytecode)                               \
+  V(CALL_FUNCTION_TYPE_INIT, 175, doCallFunctionTypeInit)                      \
   V(CALL_FUNCTION_TYPE_NEW, 176, doCallFunctionTypeNew)                        \
   V(CALL_FUNCTION_ANAMORPHIC, 177, doCallFunctionAnamorphic)                   \
   V(COMPARE_NE_STR, 178, doCompareNeStr)                                       \
···
     case COMPARE_OP_MONOMORPHIC:
     case COMPARE_OP_POLYMORPHIC:
     case COMPARE_OP_ANAMORPHIC:
+    case CALL_FUNCTION_TYPE_INIT:
     case CALL_FUNCTION_TYPE_NEW:
     case FOR_ITER_MONOMORPHIC:
     case FOR_ITER_POLYMORPHIC:

runtime/ic.cpp

···
   word id = static_cast<word>(type.instanceLayoutId());
   caches.atPut(index + kIcEntryKeyOffset, SmallInt::fromWord(id));
   caches.atPut(index + kIcEntryValueOffset, *constructor);
-  MutableBytes bytecode(&scope, dependent.rewrittenBytecode());
-  word pc = thread->currentFrame()->virtualPC() - kCodeUnitSize;
-  DCHECK(bytecode.byteAt(pc) == CALL_FUNCTION_ANAMORPHIC,
-         "current opcode must be CALL_FUNCTION_ANAMORPHIC");
-  bytecode.byteAtPut(pc, CALL_FUNCTION_TYPE_NEW);
   if (!type.isBuiltin()) {
     icInsertConstructorDependencies(thread, static_cast<LayoutId>(id),
                                     dependent);
···
     case BINARY_SUBSCR_MONOMORPHIC:
     case BINARY_SUBSCR_POLYMORPHIC:
       return attr_name == runtime_->symbols()->at(ID(__getitem__));
+    case CALL_FUNCTION_TYPE_INIT:
+      return attr_name == runtime_->symbols()->at(ID(__new__)) ||
+             attr_name == runtime_->symbols()->at(ID(__init__));
     case CALL_FUNCTION_TYPE_NEW:
       return attr_name == runtime_->symbols()->at(ID(__new__)) ||
              attr_name == runtime_->symbols()->at(ID(__init__));

runtime/ic.h

···
       case BINARY_SUBSCR_ANAMORPHIC:
       case BINARY_SUBSCR_MONOMORPHIC:
       case BINARY_SUBSCR_POLYMORPHIC:
+      case CALL_FUNCTION_TYPE_INIT:
       case CALL_FUNCTION_TYPE_NEW:
       case FOR_ITER_MONOMORPHIC:
       case FOR_ITER_POLYMORPHIC:

runtime/interpreter-test.cpp

···
   HandleScope scope(thread_);
   ASSERT_FALSE(runFromCStr(runtime_, R"(
 class C:
+  def __new__(cls):
+    return object.__new__(cls)
   def __init__(self):
     pass
 def foo(fn):
···
 
   // Invalidate cache
   Object new_init(&scope, mainModuleAt(runtime_, "new_init"));
-  typeAtPutById(thread_, type, ID(__new__), new_init);
+  typeAtPutById(thread_, type, ID(__init__), new_init);
+
+  // Cache miss
+  expected = Interpreter::call1(thread_, function, type);
+  EXPECT_FALSE(expected.isError());
+  EXPECT_EQ(expected.layoutId(), type.instanceLayoutId());
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION));
+}
+
+TEST_F(InterpreterTest, CallFunctionAnamorphicRewritesToCallFunctionTypeInit) {
+  HandleScope scope(thread_);
+  ASSERT_FALSE(runFromCStr(runtime_, R"(
+class C:
+  def __init__(self):
+    pass
+def foo(fn):
+  return fn()
+def non_type():
+  return 5
+)")
+                   .isError());
+  Function function(&scope, mainModuleAt(runtime_, "foo"));
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION_ANAMORPHIC));
+
+  Type type(&scope, mainModuleAt(runtime_, "C"));
+  Object expected(&scope, Interpreter::call1(thread_, function, type));
+  EXPECT_FALSE(expected.isError());
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION_TYPE_INIT));
+  EXPECT_EQ(expected.layoutId(), type.instanceLayoutId());
+
+  Object non_type(&scope, mainModuleAt(runtime_, "non_type"));
+  expected = Interpreter::call1(thread_, function, non_type);
+  EXPECT_FALSE(expected.isError());
+  EXPECT_TRUE(isIntEqualsWord(*expected, 5));
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION));
+}
+
+TEST_F(InterpreterTest,
+       CallFunctionTypeInitWithNewDunderInitRewritesToCallFunction) {
+  HandleScope scope(thread_);
+  ASSERT_FALSE(runFromCStr(runtime_, R"(
+class C:
+  def __init__(self):
+    pass
+def foo(fn):
+  return fn()
+def new_init(self):
+  pass
+)")
+                   .isError());
+  Function function(&scope, mainModuleAt(runtime_, "foo"));
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION_ANAMORPHIC));
+
+  Type type(&scope, mainModuleAt(runtime_, "C"));
+  Object expected(&scope, Interpreter::call1(thread_, function, type));
+  EXPECT_FALSE(expected.isError());
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION_TYPE_INIT));
+  EXPECT_EQ(expected.layoutId(), type.instanceLayoutId());
+
+  // Invalidate cache
+  Object new_init(&scope, mainModuleAt(runtime_, "new_init"));
+  typeAtPutById(thread_, type, ID(__init__), new_init);
+
+  // Cache miss
+  expected = Interpreter::call1(thread_, function, type);
+  EXPECT_FALSE(expected.isError());
+  EXPECT_EQ(expected.layoutId(), type.instanceLayoutId());
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION));
+}
+
+TEST_F(InterpreterTest,
+       CallFunctionTypeInitWithNewDunderNewRewritesToCallFunction) {
+  HandleScope scope(thread_);
+  ASSERT_FALSE(runFromCStr(runtime_, R"(
+class C:
+  def __init__(self):
+    pass
+def foo(fn):
+  return fn()
+def new_new(self):
+  pass
+)")
+                   .isError());
+  Function function(&scope, mainModuleAt(runtime_, "foo"));
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION_ANAMORPHIC));
+
+  Type type(&scope, mainModuleAt(runtime_, "C"));
+  Object expected(&scope, Interpreter::call1(thread_, function, type));
+  EXPECT_FALSE(expected.isError());
+  EXPECT_TRUE(containsBytecode(function, CALL_FUNCTION_TYPE_INIT));
+  EXPECT_EQ(expected.layoutId(), type.instanceLayoutId());
+
+  // Invalidate cache
+  Object new_new(&scope, mainModuleAt(runtime_, "new_new"));
+  typeAtPutById(thread_, type, ID(__new__), new_new);
 
   // Cache miss
   expected = Interpreter::call1(thread_, function, type);

runtime/interpreter.cpp

···
   }
   MutableTuple caches(&scope, frame->caches());
   Object ctor(&scope, receiver.ctor());
+  bool set_ctor = false;
   if (arg == 1) {
     Runtime* runtime = thread->runtime();
     switch (receiver.instanceLayoutId()) {
···
         ctor = runtime->lookupNameInModule(thread, ID(_builtins),
                                            ID(_str_ctor_obj));
         DCHECK(!ctor.isError(), "cannot find _str_ctor_obj");
+        set_ctor = true;
         break;
       case LayoutId::kType:
         ctor =
             runtime->lookupNameInModule(thread, ID(_builtins), ID(_type_ctor));
         DCHECK(!ctor.isError(), "cannot find _type_ctor");
         break;
+        set_ctor = true;
       case LayoutId::kInt:
         ctor = runtime->lookupNameInModule(thread, ID(_builtins),
                                            ID(_int_ctor_obj));
         DCHECK(!ctor.isError(), "cannot find _int_ctor_obj");
+        set_ctor = true;
         break;
       default:
         break;
     }
   }
+  if (!set_ctor) {
+    // TODO(emacs): Split out objectInit from objectNew and split opcode into
+    // slots vs no slots
+    // TODO(emacs): Only cache if not abstract (and do not include that in
+    // objectInit)
+    // TODO(emacs): Also split by tuple overflow/no tuple overflow
+    // TODO(emacs): Also cache instanceSize so we can allocate without the
+    // layout object
+    bool use_object_dunder_new =
+        receiver.isType() && receiver.hasFlag(Type::Flag::kHasObjectDunderNew);
+    if (use_object_dunder_new) {
+      // Metaclass is "type" so we do not need to check for __init__ being a
+      // datadescriptor and we can look it up directly on the type.
+      ctor = typeLookupInMroById(thread, *receiver, ID(__init__));
+      DCHECK(!ctor.isError(), "self must have __init__");
+      rewriteCurrentBytecode(frame, CALL_FUNCTION_TYPE_INIT);
+      icUpdateCallFunctionTypeNew(thread, caches, cache, receiver, ctor,
+                                  dependent);
+      return doCallFunctionTypeInit(thread, arg);
+    }
+  }
+  rewriteCurrentBytecode(frame, CALL_FUNCTION_TYPE_NEW);
   icUpdateCallFunctionTypeNew(thread, caches, cache, receiver, ctor, dependent);
   return doCallFunctionTypeNew(thread, arg);
 }
···
   thread->stackSetAt(callable_idx, *ctor);
   thread->stackInsertAt(callable_idx, *receiver);
   return tailcallFunction(thread, arg + 1, *ctor);
+}
+
+HANDLER_INLINE Continue Interpreter::doCallFunctionTypeInit(Thread* thread,
+                                                            word arg) {
+  HandleScope scope(thread);
+  Frame* frame = thread->currentFrame();
+  word callable_idx = arg;
+  Object receiver(&scope, thread->stackPeek(callable_idx));
+  if (!receiver.isType()) {
+    EVENT_CACHE(CALL_FUNCTION_TYPE_INIT);
+    rewriteCurrentBytecode(frame, CALL_FUNCTION);
+    return doCallFunction(thread, arg);
+  }
+  MutableTuple caches(&scope, frame->caches());
+  word cache = currentCacheIndex(frame);
+  bool is_found;
+  Object init(&scope, icLookupMonomorphic(
+                          *caches, cache,
+                          Type::cast(*receiver).instanceLayoutId(), &is_found));
+  if (!is_found) {
+    EVENT_CACHE(CALL_FUNCTION_TYPE_INIT);
+    rewriteCurrentBytecode(frame, CALL_FUNCTION);
+    return doCallFunction(thread, arg);
+  }
+  Type type(&scope, *receiver);
+  Object instance(&scope, objectNew(thread, type));
+  DCHECK(init.isFunction(), "cached is expected to be a function");
+  thread->stackSetAt(callable_idx, *init);
+  thread->stackInsertAt(callable_idx, *instance);
+  Object result(&scope, callFunction(thread, arg + 1, *init));
+  // TODO(emacs): When we have real call/ret working in the assembly
+  // interpreter, add an asm implementation of this. Right now it does not make
+  // much sense to do that because the only way to call an entryAsm is to
+  // tailcall it... but we need to do the None check and return the instance.
+  if (!result.isNoneType()) {
+    if (!result.isErrorException()) {
+      Object type_name(&scope, type.name());
+      thread->raiseWithFmt(LayoutId::kTypeError,
+                           "%S.__init__ returned non None", &type_name);
+    }
+    return Continue::UNWIND;
+  }
+  thread->stackPush(*instance);
+  return Continue::NEXT;
 }
 
 HANDLER_INLINE Continue Interpreter::doMakeFunction(Thread* thread, word arg) {

runtime/interpreter.h

···
   static Continue doCallMethod(Thread* thread, word arg);
   static Continue doCallFunctionAnamorphic(Thread* thread, word arg);
   static Continue doCallFunctionTypeNew(Thread* thread, word arg);
+  static Continue doCallFunctionTypeInit(Thread* thread, word arg);
   static Continue doCompareInAnamorphic(Thread* thread, word arg);
   static Continue doCompareInStr(Thread* thread, word arg);
   static Continue doCompareInTuple(Thread* thread, word arg);