Disallow creating instances of abstract classes (#4381)

A good first-pass, at least. (abstract adapters are rejected with this
change, though pending further language design discussion)

---------

Co-authored-by: Richard Smith <[email protected]>

Author: dwblaikie

toolchain/check/context.cpp

@@ -195,6 +195,17 @@ auto Context::DiagnoseNameNotFound(SemIRLoc loc, SemIR::NameId name_id)
   emitter_->Emit(loc, NameNotFound, name_id);
 }
 
+auto Context::NoteAbstractClass(SemIR::ClassId class_id,
+                                DiagnosticBuilder& builder) -> void {
+  const auto& class_info = classes().Get(class_id);
+  CARBON_CHECK(
+      class_info.inheritance_kind == SemIR::Class::InheritanceKind::Abstract,
+      "Class is not abstract");
+  CARBON_DIAGNOSTIC(ClassAbstractHere, Note,
+                    "class was declared abstract here");
+  builder.Note(class_info.definition_id, ClassAbstractHere);
+}
+
 auto Context::NoteIncompleteClass(SemIR::ClassId class_id,
                                   DiagnosticBuilder& builder) -> void {
   const auto& class_info = classes().Get(class_id);
@@ -1128,8 +1139,33 @@ class TypeCompleter {
 }  // namespace
 
 auto Context::TryToCompleteType(SemIR::TypeId type_id,
-                                BuildDiagnosticFn diagnoser) -> bool {
-  return TypeCompleter(*this, diagnoser).Complete(type_id);
+                                BuildDiagnosticFn diagnoser,
+                                BuildDiagnosticFn abstract_diagnoser) -> bool {
+  if (!TypeCompleter(*this, diagnoser).Complete(type_id)) {
+    return false;
+  }
+
+  if (!abstract_diagnoser) {
+    return true;
+  }
+
+  if (auto class_type = types().TryGetAs<SemIR::ClassType>(type_id)) {
+    auto& class_info = classes().Get(class_type->class_id);
+    if (class_info.inheritance_kind !=
+        SemIR::Class::InheritanceKind::Abstract) {
+      return true;
+    }
+
+    auto builder = abstract_diagnoser();
+    if (!builder) {
+      return false;
+    }
+    NoteAbstractClass(class_type->class_id, builder);
+    builder.Emit();
+    return false;
+  }
+
+  return true;
 }
 
 auto Context::TryToDefineType(SemIR::TypeId type_id,

toolchain/check/context.h

@@ -235,6 +235,10 @@ class Context {
   auto NoteIncompleteClass(SemIR::ClassId class_id, DiagnosticBuilder& builder)
       -> void;
 
+  // Adds a note to a diagnostic explaining that a class is abstract.
+  auto NoteAbstractClass(SemIR::ClassId class_id, DiagnosticBuilder& builder)
+      -> void;
+
   // Adds a note to a diagnostic explaining that an interface is not defined.
   auto NoteUndefinedInterface(SemIR::InterfaceId interface_id,
                               DiagnosticBuilder& builder) -> void;
@@ -319,7 +323,9 @@ class Context {
   // if a `diagnoser` is provided. The builder it returns will be annotated to
   // describe the reason why the type is not complete.
   auto TryToCompleteType(SemIR::TypeId type_id,
-                         BuildDiagnosticFn diagnoser = nullptr) -> bool;
+                         BuildDiagnosticFn diagnoser = nullptr,
+                         BuildDiagnosticFn abstract_diagnoser = nullptr)
+      -> bool;
 
   // Attempts to complete and define the type `type_id`. Returns `true` if the
   // type is defined, or `false` if no definition is available. A defined type
@@ -333,11 +339,12 @@ class Context {
   // Returns the type `type_id` as a complete type, or produces an incomplete
   // type error and returns an error type. This is a convenience wrapper around
   // TryToCompleteType. `diagnoser` must not be null.
-  auto AsCompleteType(SemIR::TypeId type_id, BuildDiagnosticFn diagnoser)
+  auto AsCompleteType(SemIR::TypeId type_id, BuildDiagnosticFn diagnoser,
+                      BuildDiagnosticFn abstract_diagnoser = nullptr)
       -> SemIR::TypeId {
-    CARBON_CHECK(diagnoser);
-    return TryToCompleteType(type_id, diagnoser) ? type_id
-                                                 : SemIR::TypeId::Error;
+    return TryToCompleteType(type_id, diagnoser, abstract_diagnoser)
+               ? type_id
+               : SemIR::TypeId::Error;
   }
 
   // Returns whether `type_id` represents a facet type.

toolchain/check/convert.cpp

@@ -533,15 +533,7 @@ static auto ConvertStructToClass(Context& context, SemIR::StructType src_type,
                                  ConversionTarget target) -> SemIR::InstId {
   PendingBlock target_block(context);
   auto& dest_class_info = context.classes().Get(dest_type.class_id);
-  if (dest_class_info.inheritance_kind == SemIR::Class::Abstract) {
-    CARBON_DIAGNOSTIC(ConstructionOfAbstractClass, Error,
-                      "cannot construct instance of abstract class; "
-                      "consider using `partial {0}` instead",
-                      TypeIdAsRawType);
-    context.emitter().Emit(value_id, ConstructionOfAbstractClass,
-                           target.type_id);
-    return SemIR::InstId::BuiltinError;
-  }
+  CARBON_CHECK(dest_class_info.inheritance_kind != SemIR::Class::Abstract);
   auto object_repr_id =
       dest_class_info.GetObjectRepr(context.sem_ir(), dest_type.specific_id);
   if (object_repr_id == SemIR::TypeId::Error) {
@@ -937,23 +929,38 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
   }
 
   // We can only perform initialization for complete types.
-  if (!context.TryToCompleteType(target.type_id, [&] {
-        CARBON_DIAGNOSTIC(IncompleteTypeInInit, Error,
-                          "initialization of incomplete type {0}",
-                          SemIR::TypeId);
-        CARBON_DIAGNOSTIC(IncompleteTypeInValueConversion, Error,
-                          "forming value of incomplete type {0}",
-                          SemIR::TypeId);
-        CARBON_DIAGNOSTIC(IncompleteTypeInConversion, Error,
-                          "invalid use of incomplete type {0}", SemIR::TypeId);
-        return context.emitter().Build(loc_id,
-                                       target.is_initializer()
-                                           ? IncompleteTypeInInit
-                                       : target.kind == ConversionTarget::Value
-                                           ? IncompleteTypeInValueConversion
-                                           : IncompleteTypeInConversion,
-                                       target.type_id);
-      })) {
+  if (!context.TryToCompleteType(
+          target.type_id,
+          [&] {
+            CARBON_DIAGNOSTIC(IncompleteTypeInInit, Error,
+                              "initialization of incomplete type {0}",
+                              SemIR::TypeId);
+            CARBON_DIAGNOSTIC(IncompleteTypeInValueConversion, Error,
+                              "forming value of incomplete type {0}",
+                              SemIR::TypeId);
+            CARBON_DIAGNOSTIC(IncompleteTypeInConversion, Error,
+                              "invalid use of incomplete type {0}",
+                              SemIR::TypeId);
+            assert(!target.is_initializer());
+            assert(target.kind == ConversionTarget::Value);
+            return context.emitter().Build(
+                loc_id,
+                target.is_initializer() ? IncompleteTypeInInit
+                : target.kind == ConversionTarget::Value
+                    ? IncompleteTypeInValueConversion
+                    : IncompleteTypeInConversion,
+                target.type_id);
+          },
+          [&] {
+            CARBON_DIAGNOSTIC(AbstractTypeInInit, Error,
+                              "initialization of abstract type {0}",
+                              SemIR::TypeId);
+            if (!target.is_initializer()) {
+              return context.emitter().BuildSuppressed();
+            }
+            return context.emitter().Build(loc_id, AbstractTypeInInit,
+                                           target.type_id);
+          })) {
     return SemIR::InstId::BuiltinError;
   }
 

toolchain/check/function.cpp

@@ -81,11 +81,18 @@ auto CheckFunctionReturnType(Context& context, SemIRLoc loc,
       return context.emitter().Build(loc, IncompleteTypeInFunctionReturnType,
                                      return_info.type_id);
     };
+    auto diagnose_abstract_return_type = [&] {
+      CARBON_DIAGNOSTIC(AbstractTypeInFunctionReturnType, Error,
+                        "function returns abstract type {0}", SemIR::TypeId);
+      return context.emitter().Build(loc, AbstractTypeInFunctionReturnType,
+                                     return_info.type_id);
+    };
 
     // TODO: Consider suppressing the diagnostic if we've already diagnosed a
     // definition or call to this function.
     if (context.TryToCompleteType(return_info.type_id,
-                                  diagnose_incomplete_return_type)) {
+                                  diagnose_incomplete_return_type,
+                                  diagnose_abstract_return_type)) {
       return_info = SemIR::ReturnTypeInfo::ForFunction(context.sem_ir(),
                                                        function, specific_id);
     }

toolchain/check/handle_binding_pattern.cpp

@@ -100,16 +100,28 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id,
 
       // A `var` declaration at class scope introduces a field.
       auto parent_class_decl = context.GetCurrentScopeAs<SemIR::ClassDecl>();
-      cast_type_id = context.AsCompleteType(cast_type_id, [&] {
-        CARBON_DIAGNOSTIC(IncompleteTypeInVarDecl, Error,
-                          "{0} has incomplete type {1}", llvm::StringLiteral,
-                          InstIdAsType);
-        return context.emitter().Build(type_node, IncompleteTypeInVarDecl,
-                                       parent_class_decl
-                                           ? llvm::StringLiteral("Field")
-                                           : llvm::StringLiteral("Variable"),
-                                       cast_type_inst_id);
-      });
+      cast_type_id = context.AsCompleteType(
+          cast_type_id,
+          [&] {
+            CARBON_DIAGNOSTIC(IncompleteTypeInVarDecl, Error,
+                              "{0} has incomplete type {1}",
+                              llvm::StringLiteral, SemIR::TypeId);
+            return context.emitter().Build(
+                type_node, IncompleteTypeInVarDecl,
+                parent_class_decl ? llvm::StringLiteral("field")
+                                  : llvm::StringLiteral("variable"),
+                cast_type_id);
+          },
+          [&] {
+            CARBON_DIAGNOSTIC(AbstractTypeInVarDecl, Error,
+                              "{0} has abstract type {1}", llvm::StringLiteral,
+                              SemIR::TypeId);
+            return context.emitter().Build(
+                type_node, AbstractTypeInVarDecl,
+                parent_class_decl ? llvm::StringLiteral("field")
+                                  : llvm::StringLiteral("variable"),
+                cast_type_id);
+          });
       if (parent_class_decl) {
         CARBON_CHECK(context_node_kind == Parse::NodeKind::VariableIntroducer,
                      "`returned var` at class scope");

toolchain/check/handle_class.cpp

@@ -383,14 +383,24 @@ auto HandleParseNode(Context& context, Parse::AdaptDeclId node_id) -> bool {
     return true;
   }
 
-  auto [adapted_type_inst_id, adapted_type_id] =
-      ExprAsType(context, node_id, adapted_type_expr_id);
-  adapted_type_id = context.AsCompleteType(adapted_type_id, [&] {
-    CARBON_DIAGNOSTIC(IncompleteTypeInAdaptDecl, Error,
-                      "adapted type {0} is an incomplete type", InstIdAsType);
-    return context.emitter().Build(node_id, IncompleteTypeInAdaptDecl,
-                                   adapted_type_inst_id);
-  });
+  auto adapted_type_id =
+      ExprAsType(context, node_id, adapted_type_expr_id).type_id;
+  adapted_type_id = context.AsCompleteType(
+      adapted_type_id,
+      [&] {
+        CARBON_DIAGNOSTIC(IncompleteTypeInAdaptDecl, Error,
+                          "adapted type {0} is an incomplete type",
+                          SemIR::TypeId);
+        return context.emitter().Build(node_id, IncompleteTypeInAdaptDecl,
+                                       adapted_type_id);
+      },
+      [&] {
+        CARBON_DIAGNOSTIC(AbstractTypeInAdaptDecl, Error,
+                          "adapted type {0} is an abstract type",
+                          SemIR::TypeId);
+        return context.emitter().Build(node_id, AbstractTypeInAdaptDecl,
+                                       adapted_type_id);
+      });
 
   // Build a SemIR representation for the declaration.
   class_info.adapt_id = context.AddInst<SemIR::AdaptDecl>(

toolchain/check/testdata/array/fail_incomplete_element.carbon

@@ -10,7 +10,7 @@
 
 class Incomplete;
 
-// CHECK:STDERR: fail_incomplete_element.carbon:[[@LINE+6]]:8: error: Variable has incomplete type `[Incomplete; 1]`
+// CHECK:STDERR: fail_incomplete_element.carbon:[[@LINE+6]]:8: error: variable has incomplete type `[Incomplete; 1]`
 // CHECK:STDERR: var a: [Incomplete; 1];
 // CHECK:STDERR:        ^~~~~~~~~~~~~~~
 // CHECK:STDERR: fail_incomplete_element.carbon:[[@LINE-5]]:1: note: class was forward declared here

toolchain/check/testdata/class/cross_package_import.carbon

@@ -48,7 +48,7 @@ library "[[@TEST_NAME]]";
 
 import Other library "other_extern";
 
-// CHECK:STDERR: fail_extern.carbon:[[@LINE+8]]:8: error: Variable has incomplete type `C`
+// CHECK:STDERR: fail_extern.carbon:[[@LINE+8]]:8: error: variable has incomplete type `C`
 // CHECK:STDERR: var c: Other.C = {};
 // CHECK:STDERR:        ^~~~~~~
 // CHECK:STDERR: fail_extern.carbon:[[@LINE-5]]:1: in import