[cfe] Report an error when extending an interface class or mixing in an interface mixin.

Change-Id: I23019c69f74f2405f196eac5d58048138bc6408a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/280244
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Kallen Tu <kallentu@google.com>

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -6283,6 +6283,60 @@ Message _withArgumentsInterfaceCheck(String name, String name2) {
       arguments: {'name': name, 'name2': name2});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateInterfaceClassExtendedOutsideOfLibrary = const Template<
+        Message Function(String name)>(
+    problemMessageTemplate:
+        r"""The class '#name' can't be extended outside of its library because it's an interface class.""",
+    withArguments: _withArgumentsInterfaceClassExtendedOutsideOfLibrary);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)>
+    codeInterfaceClassExtendedOutsideOfLibrary =
+    const Code<Message Function(String name)>(
+        "InterfaceClassExtendedOutsideOfLibrary",
+        analyzerCodes: <String>["INTERFACE_CLASS_EXTENDED_OUTSIDE_OF_LIBRARY"]);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsInterfaceClassExtendedOutsideOfLibrary(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeInterfaceClassExtendedOutsideOfLibrary,
+      problemMessage:
+          """The class '${name}' can't be extended outside of its library because it's an interface class.""",
+      arguments: {'name': name});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateInterfaceMixinMixedInOutsideOfLibrary = const Template<
+        Message Function(String name)>(
+    problemMessageTemplate:
+        r"""The mixin '#name' can't be mixed-in outside of its library because it's an interface mixin.""",
+    withArguments: _withArgumentsInterfaceMixinMixedInOutsideOfLibrary);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)>
+    codeInterfaceMixinMixedInOutsideOfLibrary =
+    const Code<Message Function(String name)>(
+        "InterfaceMixinMixedInOutsideOfLibrary",
+        analyzerCodes: <String>["INTERFACE_MIXIN_MIXED_IN_OUTSIDE_OF_LIBRARY"]);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsInterfaceMixinMixedInOutsideOfLibrary(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeInterfaceMixinMixedInOutsideOfLibrary,
+      problemMessage:
+          """The mixin '${name}' can't be mixed-in outside of its library because it's an interface mixin.""",
+      arguments: {'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeInternalProblemAlreadyInitialized =
     messageInternalProblemAlreadyInitialized;

pkg/front_end/lib/src/fasta/source/source_loader.dart

@@ -2180,6 +2180,16 @@ severity: $severity
       if (supertypeDeclaration is ClassBuilder &&
           cls.libraryBuilder.origin !=
               supertypeDeclaration.libraryBuilder.origin) {
+        if (isClassModifiersEnabled(supertypeDeclaration)) {
+          if (supertypeDeclaration.isInterface && !cls.isMixinDeclaration) {
+            cls.addProblem(
+                templateInterfaceClassExtendedOutsideOfLibrary
+                    .withArguments(supertypeDeclaration.fullNameForErrors),
+                supertypeBuilder.charOffset ?? TreeNode.noOffset,
+                noLength);
+          }
+        }
+
         // Report error for extending a sealed class outside of its library.
         if (isSealedClassEnabled(supertypeDeclaration) &&
             supertypeDeclaration.isSealed &&
@@ -2215,6 +2225,13 @@ severity: $severity
                 mixedInTypeBuilder.charOffset ?? TreeNode.noOffset,
                 noLength);
           }
+          if (mixedInTypeDeclaration.isInterface) {
+            cls.addProblem(
+                templateInterfaceMixinMixedInOutsideOfLibrary
+                    .withArguments(mixedInTypeDeclaration.fullNameForErrors),
+                mixedInTypeBuilder.charOffset ?? TreeNode.noOffset,
+                noLength);
+          }
         }
 
         // Report error for mixing in a sealed mixin outside of its library.

pkg/front_end/messages.status

@@ -491,6 +491,8 @@ InstantiationTooManyArguments/analyzerCode: Fail
 IntegerLiteralIsOutOfRange/example: Fail
 InterfaceCheck/analyzerCode: Fail
 InterfaceCheck/example: Fail
+InterfaceClassExtendedOutsideOfLibrary/part_wrapped_script: Fail # Uses imports
+InterfaceMixinMixedInOutsideOfLibrary/part_wrapped_script: Fail # Uses imports
 InterpolationInUri/example: Fail
 InvalidAssignmentWarning/analyzerCode: Fail
 InvalidAssignmentWarning/example: Fail

pkg/front_end/messages.yaml

@@ -6082,6 +6082,28 @@ BaseMixinImplementedOutsideOfLibrary:
     lib.dart:
       base mixin A {}
 
+InterfaceClassExtendedOutsideOfLibrary:
+  problemMessage: "The class '#name' can't be extended outside of its library because it's an interface class."
+  analyzerCode: INTERFACE_CLASS_EXTENDED_OUTSIDE_OF_LIBRARY
+  experiments: class-modifiers
+  script:
+    main.dart:
+      import 'lib.dart';
+      class B extends A {}
+    lib.dart:
+      interface class A {}
+
+InterfaceMixinMixedInOutsideOfLibrary:
+  problemMessage: "The mixin '#name' can't be mixed-in outside of its library because it's an interface mixin."
+  analyzerCode: INTERFACE_MIXIN_MIXED_IN_OUTSIDE_OF_LIBRARY
+  experiments: class-modifiers
+  script:
+    main.dart:
+      import 'lib.dart';
+      class B with A {}
+    lib.dart:
+      interface mixin A {}
+
 UnspecifiedGetterNameInObjectPattern:
   problemMessage: "The getter name is not specified explicitly, and the pattern is not a variable. Try specifying the getter name explicitly, or using a variable pattern."
   experiments: patterns

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart

@@ -0,0 +1,19 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'main_lib.dart';
+
+class ExtendsInterfaceClass extends A {}
+
+class MixInInterfaceMixin with M {}
+
+class MixInInterfaceMixinExtendsObject extends Object with M {}
+
+enum EnumSubtype with M { x }
+
+mixin MixinOnA on A {}
+
+mixin MixinOnM on M {}
+
+mixin MixinOnAM on A, M {}

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.strong.expect

@@ -0,0 +1,103 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:7:37: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClass extends A {}
+//                                     ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:9:32: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixin with M {}
+//                                ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:11:60: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinExtendsObject extends Object with M {}
+//                                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:13:23: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumSubtype with M { x }
+//                       ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+class ExtendsInterfaceClass extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClass
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixin&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixin&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixin extends self::_MixInInterfaceMixin&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixin
+    : super self::_MixInInterfaceMixin&Object&M::•()
+    ;
+}
+abstract class _MixInInterfaceMixinExtendsObject&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinExtendsObject&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinExtendsObject extends self::_MixInInterfaceMixinExtendsObject&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixinExtendsObject
+    : super self::_MixInInterfaceMixinExtendsObject&Object&M::•()
+    ;
+}
+abstract class _EnumSubtype&_Enum&M = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumSubtype&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumSubtype extends self::_EnumSubtype&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EnumSubtype> values = #C4;
+  enum-element static const field self::EnumSubtype x = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumSubtype
+    : super self::_EnumSubtype&_Enum&M::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumSubtype.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnA extends mai::A /*isMixinDeclaration*/  {
+}
+abstract class MixinOnM extends mai::M /*isMixinDeclaration*/  {
+}
+abstract class _MixinOnAM&A&M extends core::Object implements mai::A, mai::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_MixinOnAM&A&M
+    : super core::Object::•()
+    ;
+}
+abstract class MixinOnAM extends self::_MixinOnAM&A&M /*isMixinDeclaration*/  {
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "x"
+  #C3 = self::EnumSubtype {index:#C1, _name:#C2}
+  #C4 = <self::EnumSubtype>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumSubtype. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumSubtype&_Enum&M. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.strong.transformed.expect

@@ -0,0 +1,103 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:7:37: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClass extends A {}
+//                                     ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:9:32: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixin with M {}
+//                                ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:11:60: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinExtendsObject extends Object with M {}
+//                                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:13:23: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumSubtype with M { x }
+//                       ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+class ExtendsInterfaceClass extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClass
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixin&Object&M extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixin&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixin extends self::_MixInInterfaceMixin&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixin
+    : super self::_MixInInterfaceMixin&Object&M::•()
+    ;
+}
+abstract class _MixInInterfaceMixinExtendsObject&Object&M extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinExtendsObject&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinExtendsObject extends self::_MixInInterfaceMixinExtendsObject&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixinExtendsObject
+    : super self::_MixInInterfaceMixinExtendsObject&Object&M::•()
+    ;
+}
+abstract class _EnumSubtype&_Enum&M extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumSubtype&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumSubtype extends self::_EnumSubtype&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EnumSubtype> values = #C4;
+  enum-element static const field self::EnumSubtype x = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumSubtype
+    : super self::_EnumSubtype&_Enum&M::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumSubtype.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnA extends mai::A /*isMixinDeclaration*/  {
+}
+abstract class MixinOnM extends mai::M /*isMixinDeclaration*/  {
+}
+abstract class _MixinOnAM&A&M extends core::Object implements mai::A, mai::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_MixinOnAM&A&M
+    : super core::Object::•()
+    ;
+}
+abstract class MixinOnAM extends self::_MixinOnAM&A&M /*isMixinDeclaration*/  {
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "x"
+  #C3 = self::EnumSubtype {index:#C1, _name:#C2}
+  #C4 = <self::EnumSubtype>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumSubtype. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumSubtype&_Enum&M. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.textual_outline.expect

@@ -0,0 +1,13 @@
+import 'main_lib.dart';
+
+class ExtendsInterfaceClass extends A {}
+
+class MixInInterfaceMixin with M {}
+
+class MixInInterfaceMixinExtendsObject extends Object with M {}
+
+enum EnumSubtype with M { x }
+
+mixin MixinOnA on A {}
+mixin MixinOnM on M {}
+mixin MixinOnAM on A, M {}

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.textual_outline_modelled.expect

@@ -0,0 +1,13 @@
+import 'main_lib.dart';
+
+class ExtendsInterfaceClass extends A {}
+
+class MixInInterfaceMixin with M {}
+
+class MixInInterfaceMixinExtendsObject extends Object with M {}
+
+enum EnumSubtype with M { x }
+
+mixin MixinOnA on A {}
+mixin MixinOnAM on A, M {}
+mixin MixinOnM on M {}

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.weak.expect

@@ -0,0 +1,103 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:7:37: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClass extends A {}
+//                                     ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:9:32: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixin with M {}
+//                                ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:11:60: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinExtendsObject extends Object with M {}
+//                                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:13:23: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumSubtype with M { x }
+//                       ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+class ExtendsInterfaceClass extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClass
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixin&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixin&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixin extends self::_MixInInterfaceMixin&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixin
+    : super self::_MixInInterfaceMixin&Object&M::•()
+    ;
+}
+abstract class _MixInInterfaceMixinExtendsObject&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinExtendsObject&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinExtendsObject extends self::_MixInInterfaceMixinExtendsObject&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixinExtendsObject
+    : super self::_MixInInterfaceMixinExtendsObject&Object&M::•()
+    ;
+}
+abstract class _EnumSubtype&_Enum&M = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumSubtype&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumSubtype extends self::_EnumSubtype&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EnumSubtype> values = #C4;
+  enum-element static const field self::EnumSubtype x = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumSubtype
+    : super self::_EnumSubtype&_Enum&M::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumSubtype.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnA extends mai::A /*isMixinDeclaration*/  {
+}
+abstract class MixinOnM extends mai::M /*isMixinDeclaration*/  {
+}
+abstract class _MixinOnAM&A&M extends core::Object implements mai::A, mai::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_MixinOnAM&A&M
+    : super core::Object::•()
+    ;
+}
+abstract class MixinOnAM extends self::_MixinOnAM&A&M /*isMixinDeclaration*/  {
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "x"
+  #C3 = self::EnumSubtype {index:#C1, _name:#C2}
+  #C4 = <self::EnumSubtype*>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumSubtype. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumSubtype&_Enum&M. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.weak.modular.expect

@@ -0,0 +1,91 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:7:37: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClass extends A {}
+//                                     ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:9:32: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixin with M {}
+//                                ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:11:60: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinExtendsObject extends Object with M {}
+//                                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:13:23: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumSubtype with M { x }
+//                       ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+class ExtendsInterfaceClass extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClass
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixin&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixin&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixin extends self::_MixInInterfaceMixin&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixin
+    : super self::_MixInInterfaceMixin&Object&M::•()
+    ;
+}
+abstract class _MixInInterfaceMixinExtendsObject&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinExtendsObject&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinExtendsObject extends self::_MixInInterfaceMixinExtendsObject&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixinExtendsObject
+    : super self::_MixInInterfaceMixinExtendsObject&Object&M::•()
+    ;
+}
+abstract class _EnumSubtype&_Enum&M = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumSubtype&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumSubtype extends self::_EnumSubtype&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EnumSubtype> values = #C4;
+  enum-element static const field self::EnumSubtype x = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumSubtype
+    : super self::_EnumSubtype&_Enum&M::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumSubtype.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnA extends mai::A /*isMixinDeclaration*/  {
+}
+abstract class MixinOnM extends mai::M /*isMixinDeclaration*/  {
+}
+abstract class _MixinOnAM&A&M extends core::Object implements mai::A, mai::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_MixinOnAM&A&M
+    : super core::Object::•()
+    ;
+}
+abstract class MixinOnAM extends self::_MixinOnAM&A&M /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "x"
+  #C3 = self::EnumSubtype {index:#C1, _name:#C2}
+  #C4 = <self::EnumSubtype*>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumSubtype. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumSubtype&_Enum&M. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.weak.outline.expect

@@ -0,0 +1,88 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:7:37: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClass extends A {}
+//                                     ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:9:32: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixin with M {}
+//                                ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:11:60: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinExtendsObject extends Object with M {}
+//                                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:13:23: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumSubtype with M { x }
+//                       ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+class ExtendsInterfaceClass extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClass
+    ;
+}
+abstract class _MixInInterfaceMixin&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixin&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixin extends self::_MixInInterfaceMixin&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixin
+    ;
+}
+abstract class _MixInInterfaceMixinExtendsObject&Object&M = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinExtendsObject&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinExtendsObject extends self::_MixInInterfaceMixinExtendsObject&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixinExtendsObject
+    ;
+}
+abstract class _EnumSubtype&_Enum&M = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumSubtype&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumSubtype extends self::_EnumSubtype&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EnumSubtype> values = const <self::EnumSubtype>[self::EnumSubtype::x];
+  enum-element static const field self::EnumSubtype x = const self::EnumSubtype::•(0, "x");
+  const constructor •(core::int #index, core::String #name) → self::EnumSubtype
+    ;
+  method _enumToString() → core::String
+    return "EnumSubtype.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnA extends mai::A /*isMixinDeclaration*/  {
+}
+abstract class MixinOnM extends mai::M /*isMixinDeclaration*/  {
+}
+abstract class _MixinOnAM&A&M extends core::Object implements mai::A, mai::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_MixinOnAM&A&M
+    ;
+}
+abstract class MixinOnAM extends self::_MixinOnAM&A&M /*isMixinDeclaration*/  {
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///main.dart:13:6 -> ListConstant(const <EnumSubtype*>[const EnumSubtype{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///main.dart:13:27 -> InstanceConstant(const EnumSubtype{})
+Extra constant evaluation: evaluated: 7, effectively constant: 2

pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart.weak.transformed.expect

@@ -0,0 +1,103 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:7:37: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClass extends A {}
+//                                     ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:9:32: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixin with M {}
+//                                ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:11:60: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinExtendsObject extends Object with M {}
+//                                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/outside_library/main.dart:13:23: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumSubtype with M { x }
+//                       ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+class ExtendsInterfaceClass extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClass
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixin&Object&M extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixin&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixin extends self::_MixInInterfaceMixin&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixin
+    : super self::_MixInInterfaceMixin&Object&M::•()
+    ;
+}
+abstract class _MixInInterfaceMixinExtendsObject&Object&M extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinExtendsObject&Object&M
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinExtendsObject extends self::_MixInInterfaceMixinExtendsObject&Object&M {
+  synthetic constructor •() → self::MixInInterfaceMixinExtendsObject
+    : super self::_MixInInterfaceMixinExtendsObject&Object&M::•()
+    ;
+}
+abstract class _EnumSubtype&_Enum&M extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumSubtype&_Enum&M
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumSubtype extends self::_EnumSubtype&_Enum&M /*isEnum*/  {
+  static const field core::List<self::EnumSubtype> values = #C4;
+  enum-element static const field self::EnumSubtype x = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumSubtype
+    : super self::_EnumSubtype&_Enum&M::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumSubtype.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class MixinOnA extends mai::A /*isMixinDeclaration*/  {
+}
+abstract class MixinOnM extends mai::M /*isMixinDeclaration*/  {
+}
+abstract class _MixinOnAM&A&M extends core::Object implements mai::A, mai::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_MixinOnAM&A&M
+    : super core::Object::•()
+    ;
+}
+abstract class MixinOnAM extends self::_MixinOnAM&A&M /*isMixinDeclaration*/  {
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "x"
+  #C3 = self::EnumSubtype {index:#C1, _name:#C2}
+  #C4 = <self::EnumSubtype*>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumSubtype. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumSubtype&_Enum&M. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)

pkg/front_end/testcases/class_modifiers/interface/outside_library/main_lib.dart

@@ -0,0 +1,7 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+interface class A {}
+
+interface mixin M {}

pkg/front_end/testcases/class_modifiers/interface/outside_library/test.options

@@ -0,0 +1 @@
+main_lib.dart

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart

@@ -0,0 +1,27 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'main_lib.dart';
+
+class ExtendsInterfaceClassTypedef extends ATypeDef {}
+
+class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+
+class MixInInterfaceMixinTypeDef with MTypeDef {}
+
+enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+
+class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+
+enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+
+typedef AOutsideTypedef = A;
+
+typedef MOutsideTypedef = M;
+
+class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+
+class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+
+enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.strong.expect

@@ -0,0 +1,174 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:7:44: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef extends ATypeDef {}
+//                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:9:45: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+//                                             ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:11:39: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef with MTypeDef {}
+//                                       ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:13:42: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+//                                          ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:15:40: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+//                                        ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:17:43: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+//                                           ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:23:51: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+//                                                   ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:25:46: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+//                                              ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:27:49: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+//                                                 ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+typedef AOutsideTypedef = mai::A;
+typedef MOutsideTypedef = mai::M;
+class ExtendsInterfaceClassTypedef extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef
+    : super mai::A::•()
+    ;
+}
+class ExtendsInterfaceClassTypedef2 extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef2
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDef&Object&MTypeDef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef&Object&MTypeDef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef extends self::_MixInInterfaceMixinTypeDef&Object&MTypeDef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef
+    : super self::_MixInInterfaceMixinTypeDef&Object&MTypeDef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef extends self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef> values = #C4;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef foo = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef
+    : super self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _MixInInterfaceMixinTypeDef2&Object&MTypeDef2 = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef2 extends self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2 {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef2
+    : super self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef2 extends self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef2> values = #C6;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef2 foo = #C5;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef2
+    : super self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef2.${this.{core::_Enum::_name}{core::String}}";
+}
+class ExtendsInterfaceClassTypedefOutside extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedefOutside
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDefOutside extends self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDefOutside
+    : super self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDefOutside extends self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDefOutside> values = #C8;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDefOutside foo = #C7;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDefOutside
+    : super self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDefOutside.${this.{core::_Enum::_name}{core::String}}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef ATypeDef = mai::A;
+typedef ATypeDef2 = mai::A;
+typedef MTypeDef = mai::M;
+typedef MTypeDef2 = mai::M;
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "foo"
+  #C3 = self::EnumMixInInterfaceMixinTypeDef {index:#C1, _name:#C2}
+  #C4 = <self::EnumMixInInterfaceMixinTypeDef>[#C3]
+  #C5 = self::EnumMixInInterfaceMixinTypeDef2 {index:#C1, _name:#C2}
+  #C6 = <self::EnumMixInInterfaceMixinTypeDef2>[#C5]
+  #C7 = self::EnumMixInInterfaceMixinTypeDefOutside {index:#C1, _name:#C2}
+  #C8 = <self::EnumMixInInterfaceMixinTypeDefOutside>[#C7]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumMixInInterfaceMixinTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- EnumMixInInterfaceMixinTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- EnumMixInInterfaceMixinTypeDefOutside. (from org-dartlang-testcase:///main.dart:27:6)
+- _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef. (from org-dartlang-testcase:///main.dart:27:6)

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.strong.transformed.expect

@@ -0,0 +1,174 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:7:44: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef extends ATypeDef {}
+//                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:9:45: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+//                                             ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:11:39: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef with MTypeDef {}
+//                                       ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:13:42: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+//                                          ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:15:40: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+//                                        ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:17:43: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+//                                           ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:23:51: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+//                                                   ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:25:46: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+//                                              ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:27:49: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+//                                                 ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+typedef AOutsideTypedef = mai::A;
+typedef MOutsideTypedef = mai::M;
+class ExtendsInterfaceClassTypedef extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef
+    : super mai::A::•()
+    ;
+}
+class ExtendsInterfaceClassTypedef2 extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef2
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDef&Object&MTypeDef extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef&Object&MTypeDef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef extends self::_MixInInterfaceMixinTypeDef&Object&MTypeDef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef
+    : super self::_MixInInterfaceMixinTypeDef&Object&MTypeDef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef extends self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef> values = #C4;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef foo = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef
+    : super self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _MixInInterfaceMixinTypeDef2&Object&MTypeDef2 extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef2 extends self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2 {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef2
+    : super self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef2 extends self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef2> values = #C6;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef2 foo = #C5;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef2
+    : super self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef2.${this.{core::_Enum::_name}{core::String}}";
+}
+class ExtendsInterfaceClassTypedefOutside extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedefOutside
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDefOutside extends self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDefOutside
+    : super self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDefOutside extends self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDefOutside> values = #C8;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDefOutside foo = #C7;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDefOutside
+    : super self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDefOutside.${this.{core::_Enum::_name}{core::String}}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef ATypeDef = mai::A;
+typedef ATypeDef2 = mai::A;
+typedef MTypeDef = mai::M;
+typedef MTypeDef2 = mai::M;
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "foo"
+  #C3 = self::EnumMixInInterfaceMixinTypeDef {index:#C1, _name:#C2}
+  #C4 = <self::EnumMixInInterfaceMixinTypeDef>[#C3]
+  #C5 = self::EnumMixInInterfaceMixinTypeDef2 {index:#C1, _name:#C2}
+  #C6 = <self::EnumMixInInterfaceMixinTypeDef2>[#C5]
+  #C7 = self::EnumMixInInterfaceMixinTypeDefOutside {index:#C1, _name:#C2}
+  #C8 = <self::EnumMixInInterfaceMixinTypeDefOutside>[#C7]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumMixInInterfaceMixinTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- EnumMixInInterfaceMixinTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- EnumMixInInterfaceMixinTypeDefOutside. (from org-dartlang-testcase:///main.dart:27:6)
+- _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef. (from org-dartlang-testcase:///main.dart:27:6)

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.textual_outline.expect

@@ -0,0 +1,22 @@
+import 'main_lib.dart';
+
+class ExtendsInterfaceClassTypedef extends ATypeDef {}
+
+class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+
+class MixInInterfaceMixinTypeDef with MTypeDef {}
+
+enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+
+class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+
+enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+
+typedef AOutsideTypedef = A;
+typedef MOutsideTypedef = M;
+
+class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+
+class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+
+enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.textual_outline_modelled.expect

@@ -0,0 +1,22 @@
+import 'main_lib.dart';
+
+class ExtendsInterfaceClassTypedef extends ATypeDef {}
+
+class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+
+class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+
+class MixInInterfaceMixinTypeDef with MTypeDef {}
+
+class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+
+class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+
+enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+
+enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+
+enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+
+typedef AOutsideTypedef = A;
+typedef MOutsideTypedef = M;

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.weak.expect

@@ -0,0 +1,174 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:7:44: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef extends ATypeDef {}
+//                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:9:45: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+//                                             ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:11:39: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef with MTypeDef {}
+//                                       ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:13:42: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+//                                          ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:15:40: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+//                                        ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:17:43: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+//                                           ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:23:51: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+//                                                   ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:25:46: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+//                                              ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:27:49: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+//                                                 ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+typedef AOutsideTypedef = mai::A;
+typedef MOutsideTypedef = mai::M;
+class ExtendsInterfaceClassTypedef extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef
+    : super mai::A::•()
+    ;
+}
+class ExtendsInterfaceClassTypedef2 extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef2
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDef&Object&MTypeDef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef&Object&MTypeDef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef extends self::_MixInInterfaceMixinTypeDef&Object&MTypeDef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef
+    : super self::_MixInInterfaceMixinTypeDef&Object&MTypeDef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef extends self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef> values = #C4;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef foo = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef
+    : super self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _MixInInterfaceMixinTypeDef2&Object&MTypeDef2 = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef2 extends self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2 {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef2
+    : super self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef2 extends self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef2> values = #C6;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef2 foo = #C5;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef2
+    : super self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef2.${this.{core::_Enum::_name}{core::String}}";
+}
+class ExtendsInterfaceClassTypedefOutside extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedefOutside
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDefOutside extends self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDefOutside
+    : super self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDefOutside extends self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDefOutside> values = #C8;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDefOutside foo = #C7;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDefOutside
+    : super self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDefOutside.${this.{core::_Enum::_name}{core::String}}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef ATypeDef = mai::A;
+typedef ATypeDef2 = mai::A;
+typedef MTypeDef = mai::M;
+typedef MTypeDef2 = mai::M;
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "foo"
+  #C3 = self::EnumMixInInterfaceMixinTypeDef {index:#C1, _name:#C2}
+  #C4 = <self::EnumMixInInterfaceMixinTypeDef*>[#C3]
+  #C5 = self::EnumMixInInterfaceMixinTypeDef2 {index:#C1, _name:#C2}
+  #C6 = <self::EnumMixInInterfaceMixinTypeDef2*>[#C5]
+  #C7 = self::EnumMixInInterfaceMixinTypeDefOutside {index:#C1, _name:#C2}
+  #C8 = <self::EnumMixInInterfaceMixinTypeDefOutside*>[#C7]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumMixInInterfaceMixinTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- EnumMixInInterfaceMixinTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- EnumMixInInterfaceMixinTypeDefOutside. (from org-dartlang-testcase:///main.dart:27:6)
+- _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef. (from org-dartlang-testcase:///main.dart:27:6)

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.weak.modular.expect

@@ -0,0 +1,158 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:7:44: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef extends ATypeDef {}
+//                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:9:45: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+//                                             ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:11:39: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef with MTypeDef {}
+//                                       ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:13:42: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+//                                          ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:15:40: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+//                                        ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:17:43: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+//                                           ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:23:51: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+//                                                   ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:25:46: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+//                                              ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:27:49: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+//                                                 ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+typedef AOutsideTypedef = mai::A;
+typedef MOutsideTypedef = mai::M;
+class ExtendsInterfaceClassTypedef extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef
+    : super mai::A::•()
+    ;
+}
+class ExtendsInterfaceClassTypedef2 extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef2
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDef&Object&MTypeDef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef&Object&MTypeDef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef extends self::_MixInInterfaceMixinTypeDef&Object&MTypeDef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef
+    : super self::_MixInInterfaceMixinTypeDef&Object&MTypeDef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef extends self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef> values = #C4;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef foo = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef
+    : super self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _MixInInterfaceMixinTypeDef2&Object&MTypeDef2 = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef2 extends self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2 {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef2
+    : super self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef2 extends self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef2> values = #C6;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef2 foo = #C5;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef2
+    : super self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef2.${this.{core::_Enum::_name}{core::String}}";
+}
+class ExtendsInterfaceClassTypedefOutside extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedefOutside
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDefOutside extends self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDefOutside
+    : super self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDefOutside extends self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDefOutside> values = #C8;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDefOutside foo = #C7;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDefOutside
+    : super self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDefOutside.${this.{core::_Enum::_name}{core::String}}";
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "foo"
+  #C3 = self::EnumMixInInterfaceMixinTypeDef {index:#C1, _name:#C2}
+  #C4 = <self::EnumMixInInterfaceMixinTypeDef*>[#C3]
+  #C5 = self::EnumMixInInterfaceMixinTypeDef2 {index:#C1, _name:#C2}
+  #C6 = <self::EnumMixInInterfaceMixinTypeDef2*>[#C5]
+  #C7 = self::EnumMixInInterfaceMixinTypeDefOutside {index:#C1, _name:#C2}
+  #C8 = <self::EnumMixInInterfaceMixinTypeDefOutside*>[#C7]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumMixInInterfaceMixinTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- EnumMixInInterfaceMixinTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- EnumMixInInterfaceMixinTypeDefOutside. (from org-dartlang-testcase:///main.dart:27:6)
+- _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef. (from org-dartlang-testcase:///main.dart:27:6)

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.weak.outline.expect

@@ -0,0 +1,151 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:7:44: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef extends ATypeDef {}
+//                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:9:45: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+//                                             ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:11:39: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef with MTypeDef {}
+//                                       ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:13:42: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+//                                          ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:15:40: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+//                                        ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:17:43: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+//                                           ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:23:51: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+//                                                   ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:25:46: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+//                                              ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:27:49: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+//                                                 ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+typedef AOutsideTypedef = mai::A;
+typedef MOutsideTypedef = mai::M;
+class ExtendsInterfaceClassTypedef extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef
+    ;
+}
+class ExtendsInterfaceClassTypedef2 extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef2
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDef&Object&MTypeDef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef&Object&MTypeDef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef extends self::_MixInInterfaceMixinTypeDef&Object&MTypeDef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef extends self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef> values = const <self::EnumMixInInterfaceMixinTypeDef>[self::EnumMixInInterfaceMixinTypeDef::foo];
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef foo = const self::EnumMixInInterfaceMixinTypeDef::•(0, "foo");
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _MixInInterfaceMixinTypeDef2&Object&MTypeDef2 = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef2 extends self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2 {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef2
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef2 extends self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef2> values = const <self::EnumMixInInterfaceMixinTypeDef2>[self::EnumMixInInterfaceMixinTypeDef2::foo];
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef2 foo = const self::EnumMixInInterfaceMixinTypeDef2::•(0, "foo");
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef2
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef2.${this.{core::_Enum::_name}{core::String}}";
+}
+class ExtendsInterfaceClassTypedefOutside extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedefOutside
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef = core::Object with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDefOutside extends self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDefOutside
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef = core::_Enum with mai::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDefOutside extends self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDefOutside> values = const <self::EnumMixInInterfaceMixinTypeDefOutside>[self::EnumMixInInterfaceMixinTypeDefOutside::foo];
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDefOutside foo = const self::EnumMixInInterfaceMixinTypeDefOutside::•(0, "foo");
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDefOutside
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDefOutside.${this.{core::_Enum::_name}{core::String}}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef ATypeDef = mai::A;
+typedef ATypeDef2 = mai::A;
+typedef MTypeDef = mai::M;
+typedef MTypeDef2 = mai::M;
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+
+Extra constant evaluation status:
+Evaluated: ListLiteral @ org-dartlang-testcase:///main.dart:13:6 -> ListConstant(const <EnumMixInInterfaceMixinTypeDef*>[const EnumMixInInterfaceMixinTypeDef{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///main.dart:13:53 -> InstanceConstant(const EnumMixInInterfaceMixinTypeDef{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///main.dart:17:6 -> ListConstant(const <EnumMixInInterfaceMixinTypeDef2*>[const EnumMixInInterfaceMixinTypeDef2{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///main.dart:17:55 -> InstanceConstant(const EnumMixInInterfaceMixinTypeDef2{})
+Evaluated: ListLiteral @ org-dartlang-testcase:///main.dart:27:6 -> ListConstant(const <EnumMixInInterfaceMixinTypeDefOutside*>[const EnumMixInInterfaceMixinTypeDefOutside{}])
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///main.dart:27:67 -> InstanceConstant(const EnumMixInInterfaceMixinTypeDefOutside{})
+Extra constant evaluation: evaluated: 21, effectively constant: 6

pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart.weak.transformed.expect

@@ -0,0 +1,174 @@
+library /*isNonNullableByDefault*/;
+//
+// Problems in library:
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:7:44: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef extends ATypeDef {}
+//                                            ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:9:45: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedef2 extends ATypeDef2 {}
+//                                             ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:11:39: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef with MTypeDef {}
+//                                       ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:13:42: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef with MTypeDef { foo }
+//                                          ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:15:40: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDef2 with MTypeDef2 {}
+//                                        ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:17:43: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDef2 with MTypeDef2 { foo }
+//                                           ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:23:51: Error: The class 'A' can't be extended outside of its library because it's an interface class.
+// class ExtendsInterfaceClassTypedefOutside extends AOutsideTypedef {}
+//                                                   ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:25:46: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// class MixInInterfaceMixinTypeDefOutside with MOutsideTypedef {}
+//                                              ^
+//
+// pkg/front_end/testcases/class_modifiers/interface/typedef/main.dart:27:49: Error: The mixin 'M' can't be mixed-in outside of its library because it's an interface mixin.
+// enum EnumMixInInterfaceMixinTypeDefOutside with MOutsideTypedef { foo }
+//                                                 ^
+//
+import self as self;
+import "main_lib.dart" as mai;
+import "dart:core" as core;
+
+import "org-dartlang-testcase:///main_lib.dart";
+
+typedef AOutsideTypedef = mai::A;
+typedef MOutsideTypedef = mai::M;
+class ExtendsInterfaceClassTypedef extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef
+    : super mai::A::•()
+    ;
+}
+class ExtendsInterfaceClassTypedef2 extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedef2
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDef&Object&MTypeDef extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef&Object&MTypeDef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef extends self::_MixInInterfaceMixinTypeDef&Object&MTypeDef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef
+    : super self::_MixInInterfaceMixinTypeDef&Object&MTypeDef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef extends self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef> values = #C4;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef foo = #C3;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef
+    : super self::_EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef.${this.{core::_Enum::_name}{core::String}}";
+}
+abstract class _MixInInterfaceMixinTypeDef2&Object&MTypeDef2 extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDef2 extends self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2 {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDef2
+    : super self::_MixInInterfaceMixinTypeDef2&Object&MTypeDef2::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDef2 extends self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2 /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDef2> values = #C6;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDef2 foo = #C5;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDef2
+    : super self::_EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDef2.${this.{core::_Enum::_name}{core::String}}";
+}
+class ExtendsInterfaceClassTypedefOutside extends mai::A {
+  synthetic constructor •() → self::ExtendsInterfaceClassTypedefOutside
+    : super mai::A::•()
+    ;
+}
+abstract class _MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef extends core::Object implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef
+    : super core::Object::•()
+    ;
+}
+class MixInInterfaceMixinTypeDefOutside extends self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef {
+  synthetic constructor •() → self::MixInInterfaceMixinTypeDefOutside
+    : super self::_MixInInterfaceMixinTypeDefOutside&Object&MOutsideTypedef::•()
+    ;
+}
+abstract class _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef extends core::_Enum implements mai::M /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
+  const synthetic constructor •(core::int index, core::String _name) → self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef
+    : super core::_Enum::•(index, _name)
+    ;
+}
+class EnumMixInInterfaceMixinTypeDefOutside extends self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef /*isEnum*/  {
+  static const field core::List<self::EnumMixInInterfaceMixinTypeDefOutside> values = #C8;
+  enum-element static const field self::EnumMixInInterfaceMixinTypeDefOutside foo = #C7;
+  const constructor •(core::int #index, core::String #name) → self::EnumMixInInterfaceMixinTypeDefOutside
+    : super self::_EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef::•(#index, #name)
+    ;
+  method _enumToString() → core::String
+    return "EnumMixInInterfaceMixinTypeDefOutside.${this.{core::_Enum::_name}{core::String}}";
+}
+
+library /*isNonNullableByDefault*/;
+import self as mai;
+import "dart:core" as core;
+
+typedef ATypeDef = mai::A;
+typedef ATypeDef2 = mai::A;
+typedef MTypeDef = mai::M;
+typedef MTypeDef2 = mai::M;
+interface class A extends core::Object {
+  synthetic constructor •() → mai::A
+    : super core::Object::•()
+    ;
+}
+abstract interface class M extends core::Object /*isMixinDeclaration*/  {
+}
+
+constants  {
+  #C1 = 0
+  #C2 = "foo"
+  #C3 = self::EnumMixInInterfaceMixinTypeDef {index:#C1, _name:#C2}
+  #C4 = <self::EnumMixInInterfaceMixinTypeDef*>[#C3]
+  #C5 = self::EnumMixInInterfaceMixinTypeDef2 {index:#C1, _name:#C2}
+  #C6 = <self::EnumMixInInterfaceMixinTypeDef2*>[#C5]
+  #C7 = self::EnumMixInInterfaceMixinTypeDefOutside {index:#C1, _name:#C2}
+  #C8 = <self::EnumMixInInterfaceMixinTypeDefOutside*>[#C7]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///main.dart:
+- EnumMixInInterfaceMixinTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _EnumMixInInterfaceMixinTypeDef&_Enum&MTypeDef. (from org-dartlang-testcase:///main.dart:13:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- EnumMixInInterfaceMixinTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- _EnumMixInInterfaceMixinTypeDef2&_Enum&MTypeDef2. (from org-dartlang-testcase:///main.dart:17:6)
+- EnumMixInInterfaceMixinTypeDefOutside. (from org-dartlang-testcase:///main.dart:27:6)
+- _EnumMixInInterfaceMixinTypeDefOutside&_Enum&MOutsideTypedef. (from org-dartlang-testcase:///main.dart:27:6)

pkg/front_end/testcases/class_modifiers/interface/typedef/main_lib.dart

@@ -0,0 +1,15 @@
+// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+interface class A {}
+
+typedef ATypeDef = A;
+
+typedef ATypeDef2 = ATypeDef;
+
+interface mixin M {}
+
+typedef MTypeDef = M;
+
+typedef MTypeDef2 = MTypeDef;

pkg/front_end/testcases/class_modifiers/interface/typedef/test.options

@@ -0,0 +1 @@
+main_lib.dart

tests/language/class_modifiers/interface/interface_class_extend_outside_error_test.dart

@@ -11,10 +11,10 @@ import 'interface_class_extend_lib.dart';
 abstract class AOutside extends InterfaceClass {}
 //                              ^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The class 'InterfaceClass' can't be extended outside of its library because it's an interface class.
 
 class BOutside extends InterfaceClass {
 //                     ^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The class 'InterfaceClass' can't be extended outside of its library because it's an interface class.
 }

tests/language/class_modifiers/interface/interface_class_typedef_extend_error_test.dart

@@ -12,4 +12,4 @@ import 'interface_class_typedef_lib.dart';
 class ATypeDef extends InterfaceClassTypeDef {}
 //                     ^^^^^^^^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The class 'InterfaceClass' can't be extended outside of its library because it's an interface class.

tests/language/class_modifiers/interface/interface_class_typedef_used_outside_error_test.dart

@@ -15,4 +15,4 @@ typedef ATypeDef = InterfaceClass;
 class A extends ATypeDef {}
 //              ^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The class 'InterfaceClass' can't be extended outside of its library because it's an interface class.

tests/language/class_modifiers/interface/interface_mixin_typedef_with_outside_error_test.dart

@@ -11,9 +11,9 @@ import 'interface_mixin_typedef_with_lib.dart';
 abstract class AOutside with InterfaceMixinTypeDef {}
 //                           ^^^^^^^^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The mixin 'InterfaceMixin' can't be mixed-in outside of its library because it's an interface mixin.
 
 class BOutside with InterfaceMixinTypeDef {}
 //                  ^^^^^^^^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The mixin 'InterfaceMixin' can't be mixed-in outside of its library because it's an interface mixin.

tests/language/class_modifiers/interface/interface_mixin_with_outside_error_test.dart

@@ -11,9 +11,9 @@ import 'interface_mixin_with_lib.dart';
 abstract class AOutside with InterfaceMixin {}
 //                           ^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The mixin 'InterfaceMixin' can't be mixed-in outside of its library because it's an interface mixin.
 
 class BOutside with InterfaceMixin {}
 //                  ^^^^^^^^^^^^^^
 // [analyzer] COMPILE_TIME_ERROR.INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY
-// [cfe] unspecified
+// [cfe] The mixin 'InterfaceMixin' can't be mixed-in outside of its library because it's an interface mixin.