[cfe] Enable static extension methods on enums
The error about unknown constructor invocation on an enum was reported
prematurely. This CL ensures that the unresolved member status is
passed down the pipeline for the static extension method resolution to
handle it.
Additionally, this CL adds simple tests for static members on mixins
and extension types.
Part of https://github.com/dart-lang/sdk/issues/61484
Part of https://github.com/dart-lang/sdk/issues/61486
Change-Id: I3ad12a1bfc057d6a838d8edfe7e53eb0a2092a70
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/459220
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Chloe Stefantsova <cstefantsova@google.com>
diff --git a/pkg/front_end/lib/src/kernel/body_builder.dart b/pkg/front_end/lib/src/kernel/body_builder.dart
index 2c3368e..33910a0 100644
--- a/pkg/front_end/lib/src/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/kernel/body_builder.dart
@@ -6980,18 +6980,26 @@
} else {
target = constructorBuilder.invokeTarget;
}
- if (typeDeclarationBuilder.isEnum &&
- !(libraryFeatures.enhancedEnums.isEnabled &&
- target is Procedure &&
- target.kind == ProcedureKind.Factory)) {
- return new ErroneousConstructorResolutionResult(
- errorExpression: buildProblem(
- message: cfe.codeEnumInstantiation,
- fileUri: uri,
- fileOffset: nameToken.charOffset,
- length: nameToken.length,
- ),
- );
+ if (typeDeclarationBuilder.isEnum) {
+ if (libraryFeatures.staticExtensions.isEnabled && target == null) {
+ return new UnresolvedConstructorResolutionResult(
+ errorName: debugName(typeDeclarationBuilder.name, name),
+ charOffset: nameLastToken.charOffset,
+ helper: this,
+ );
+ }
+ if (!(libraryFeatures.enhancedEnums.isEnabled &&
+ target is Procedure &&
+ target.kind == ProcedureKind.Factory)) {
+ return new ErroneousConstructorResolutionResult(
+ errorExpression: buildProblem(
+ message: cfe.codeEnumInstantiation,
+ fileUri: uri,
+ fileOffset: nameToken.charOffset,
+ length: nameToken.length,
+ ),
+ );
+ }
}
if (target is Constructor ||
(target is Procedure && target.kind == ProcedureKind.Factory)) {
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.expect b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.expect
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.expect
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.expect
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.modular.expect b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.modular.expect
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.modular.expect
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.modular.expect
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.outline.expect
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.outline.expect
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.outline.expect
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.transformed.expect b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.transformed.expect
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart.strong.transformed.expect
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart.strong.transformed.expect
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart.textual_outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart.textual_outline.expect
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart.textual_outline.expect
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart.textual_outline.expect
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/static_extensions/simple_positive_class.dart.textual_outline_modelled.expect
similarity index 100%
rename from pkg/front_end/testcases/static_extensions/simple_positive.dart.textual_outline_modelled.expect
rename to pkg/front_end/testcases/static_extensions/simple_positive_class.dart.textual_outline_modelled.expect
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart
new file mode 100644
index 0000000..bedd756
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart
@@ -0,0 +1,65 @@
+// Copyright (c) 2025, 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.
+
+enum A {
+ element;
+
+ static String get enumGetter => "A.enumGetter";
+ static void set enumSetter(num value) {
+ throw "A.enumSetter=";
+ }
+
+ static String enumMethod() => "A.enumMethod";
+}
+
+extension E on A {
+ static String get enumGetter => "E.enumGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set enumSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+ static String enumMethod() => "E.enumMethod";
+ static String extensionMethod() => "E.extensionMethod";
+}
+
+main() {
+ expectEqual(A.enumGetter, "A.enumGetter");
+ expectEqual(A.extensionGetter, "E.extensionGetter");
+ expectThrows(() {
+ A.enumSetter = 0;
+ });
+ expectDoesntThrow(() {
+ A.extensionSetter = false;
+ });
+ expectEqual(A.enumMethod(), "A.enumMethod");
+ expectEqual(A.extensionMethod(), "E.extensionMethod");
+}
+
+expectEqual(a, b) {
+ if (a != b) {
+ throw "Expected the values to be equal.";
+ }
+}
+
+expectThrows(Function() f) {
+ bool hasThrown = false;
+ try {
+ f();
+ } on dynamic {
+ hasThrown = true;
+ }
+ if (!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+
+expectDoesntThrow(Function() f) {
+ bool hasThrown = true;
+ try {
+ f();
+ hasThrown = false;
+ } on dynamic {}
+ if (hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.expect b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.expect
new file mode 100644
index 0000000..2eb3b21
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.expect
@@ -0,0 +1,93 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::_Enum /*isEnum*/ {
+ enum-element static const field self::A element = #C3;
+ static const field core::List<self::A> values = #C4;
+ const synthetic constructor •(core::int #index, core::String #name) → self::A
+ : super core::_Enum::•(#index, #name)
+ ;
+ method core::_enumToString() → core::String
+ return "A.${this.{core::_Enum::_name}{core::String}}";
+ static get enumGetter() → core::String
+ return "A.enumGetter";
+ static set enumSetter(core::num value) → void {
+ throw "A.enumSetter=";
+ }
+ static method enumMethod() → core::String
+ return "A.enumMethod";
+}
+extension E on self::A {
+ static get enumGetter = get self::E|enumGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set enumSetter = set self::E|enumSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method enumMethod = self::E|enumMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|enumGetter() → core::String
+ return "E.enumGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|enumSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|enumMethod() → core::String
+ return "E.enumMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A::enumGetter, "A.enumGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A::enumSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A::enumMethod(), "A.enumMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
+
+constants {
+ #C1 = 0
+ #C2 = "element"
+ #C3 = self::A {index:#C1, _name:#C2}
+ #C4 = <self::A>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///simple_positive_enum.dart:
+- A. (from org-dartlang-testcase:///simple_positive_enum.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.modular.expect b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.modular.expect
new file mode 100644
index 0000000..2eb3b21
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.modular.expect
@@ -0,0 +1,93 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::_Enum /*isEnum*/ {
+ enum-element static const field self::A element = #C3;
+ static const field core::List<self::A> values = #C4;
+ const synthetic constructor •(core::int #index, core::String #name) → self::A
+ : super core::_Enum::•(#index, #name)
+ ;
+ method core::_enumToString() → core::String
+ return "A.${this.{core::_Enum::_name}{core::String}}";
+ static get enumGetter() → core::String
+ return "A.enumGetter";
+ static set enumSetter(core::num value) → void {
+ throw "A.enumSetter=";
+ }
+ static method enumMethod() → core::String
+ return "A.enumMethod";
+}
+extension E on self::A {
+ static get enumGetter = get self::E|enumGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set enumSetter = set self::E|enumSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method enumMethod = self::E|enumMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|enumGetter() → core::String
+ return "E.enumGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|enumSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|enumMethod() → core::String
+ return "E.enumMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A::enumGetter, "A.enumGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A::enumSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A::enumMethod(), "A.enumMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
+
+constants {
+ #C1 = 0
+ #C2 = "element"
+ #C3 = self::A {index:#C1, _name:#C2}
+ #C4 = <self::A>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///simple_positive_enum.dart:
+- A. (from org-dartlang-testcase:///simple_positive_enum.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.outline.expect
new file mode 100644
index 0000000..6607e1a
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.outline.expect
@@ -0,0 +1,53 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::_Enum /*isEnum*/ {
+ enum-element static const field self::A element = const self::A::•(0, "element");
+ static const field core::List<self::A> values = const <self::A>[self::A::element];
+ const synthetic constructor •(core::int #index, core::String #name) → self::A
+ : super core::_Enum::•(#index, #name)
+ ;
+ method core::_enumToString() → core::String
+ return "A.${this.{core::_Enum::_name}{core::String}}";
+ static get enumGetter() → core::String
+ ;
+ static set enumSetter(core::num value) → void
+ ;
+ static method enumMethod() → core::String
+ ;
+}
+extension E on self::A {
+ static get enumGetter = get self::E|enumGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set enumSetter = set self::E|enumSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method enumMethod = self::E|enumMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|enumGetter() → core::String
+ ;
+static extension-member get E|extensionGetter() → core::String
+ ;
+static extension-member set E|enumSetter(core::num value) → void
+ ;
+static extension-member set E|extensionSetter(core::bool value) → void
+ ;
+static extension-member method E|enumMethod() → core::String
+ ;
+static extension-member method E|extensionMethod() → core::String
+ ;
+static method main() → dynamic
+ ;
+static method expectEqual(dynamic a, dynamic b) → dynamic
+ ;
+static method expectThrows(() → dynamic f) → dynamic
+ ;
+static method expectDoesntThrow(() → dynamic f) → dynamic
+ ;
+
+
+Extra constant evaluation status:
+Evaluated: ConstructorInvocation @ org-dartlang-testcase:///simple_positive_enum.dart:6:3 -> InstanceConstant(const A{_Enum.index: 0, _Enum._name: "element"})
+Evaluated: ListLiteral @ org-dartlang-testcase:///simple_positive_enum.dart:5:6 -> ListConstant(const <A>[const A{_Enum.index: 0, _Enum._name: "element"}])
+Extra constant evaluation: evaluated: 7, effectively constant: 2
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.transformed.expect b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.transformed.expect
new file mode 100644
index 0000000..2eb3b21
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.strong.transformed.expect
@@ -0,0 +1,93 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::_Enum /*isEnum*/ {
+ enum-element static const field self::A element = #C3;
+ static const field core::List<self::A> values = #C4;
+ const synthetic constructor •(core::int #index, core::String #name) → self::A
+ : super core::_Enum::•(#index, #name)
+ ;
+ method core::_enumToString() → core::String
+ return "A.${this.{core::_Enum::_name}{core::String}}";
+ static get enumGetter() → core::String
+ return "A.enumGetter";
+ static set enumSetter(core::num value) → void {
+ throw "A.enumSetter=";
+ }
+ static method enumMethod() → core::String
+ return "A.enumMethod";
+}
+extension E on self::A {
+ static get enumGetter = get self::E|enumGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set enumSetter = set self::E|enumSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method enumMethod = self::E|enumMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|enumGetter() → core::String
+ return "E.enumGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|enumSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|enumMethod() → core::String
+ return "E.enumMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A::enumGetter, "A.enumGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A::enumSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A::enumMethod(), "A.enumMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
+
+constants {
+ #C1 = 0
+ #C2 = "element"
+ #C3 = self::A {index:#C1, _name:#C2}
+ #C4 = <self::A>[#C3]
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///simple_positive_enum.dart:
+- A. (from org-dartlang-testcase:///simple_positive_enum.dart:5:6)
+- _Enum. (from org-dartlang-sdk:///sdk/lib/core/enum.dart)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.textual_outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.textual_outline.expect
new file mode 100644
index 0000000..2ad5f6a
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.textual_outline.expect
@@ -0,0 +1,27 @@
+enum A {
+ element;
+
+ static String get enumGetter => "A.enumGetter";
+ static void set enumSetter(num value) {
+ throw "A.enumSetter=";
+ }
+
+ static String enumMethod() => "A.enumMethod";
+}
+
+extension E on A {
+ static String get enumGetter => "E.enumGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set enumSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+ static String enumMethod() => "E.enumMethod";
+ static String extensionMethod() => "E.extensionMethod";
+}
+
+main() {}
+
+expectEqual(a, b) {}
+
+expectThrows(Function() f) {}
+
+expectDoesntThrow(Function() f) {}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..e8aba7e
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_enum.dart.textual_outline_modelled.expect
@@ -0,0 +1,27 @@
+enum A {
+ element;
+
+ static String get enumGetter => "A.enumGetter";
+ static void set enumSetter(num value) {
+ throw "A.enumSetter=";
+ }
+
+ static String enumMethod() => "A.enumMethod";
+}
+
+expectDoesntThrow(Function() f) {}
+
+expectEqual(a, b) {}
+
+expectThrows(Function() f) {}
+
+extension E on A {
+ static String enumMethod() => "E.enumMethod";
+ static String extensionMethod() => "E.extensionMethod";
+ static String get enumGetter => "E.enumGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set enumSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart
new file mode 100644
index 0000000..53cb9b4
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart
@@ -0,0 +1,63 @@
+// Copyright (c) 2025, 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.
+
+extension type A(Object? it) {
+ static String get extensionTypeGetter => "A.extensionTypeGetter";
+ static void set extensionTypeSetter(num value) {
+ throw "A.extensionTypeSetter=";
+ }
+
+ static String extensionTypeMethod() => "A.extensionTypeMethod";
+}
+
+extension E on A {
+ static String get extensionTypeGetter => "E.extensionTypeGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set extensionTypeSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+ static String extensionTypeMethod() => "E.extensionTypeMethod";
+ static String extensionMethod() => "E.extensionMethod";
+}
+
+main() {
+ expectEqual(A.extensionTypeGetter, "A.extensionTypeGetter");
+ expectEqual(A.extensionGetter, "E.extensionGetter");
+ expectThrows(() {
+ A.extensionTypeSetter = 0;
+ });
+ expectDoesntThrow(() {
+ A.extensionSetter = false;
+ });
+ expectEqual(A.extensionTypeMethod(), "A.extensionTypeMethod");
+ expectEqual(A.extensionMethod(), "E.extensionMethod");
+}
+
+expectEqual(a, b) {
+ if (a != b) {
+ throw "Expected the values to be equal.";
+ }
+}
+
+expectThrows(Function() f) {
+ bool hasThrown = false;
+ try {
+ f();
+ } on dynamic {
+ hasThrown = true;
+ }
+ if (!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+
+expectDoesntThrow(Function() f) {
+ bool hasThrown = true;
+ try {
+ f();
+ hasThrown = false;
+ } on dynamic {}
+ if (hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.expect b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.expect
new file mode 100644
index 0000000..24076e36
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.expect
@@ -0,0 +1,84 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+extension E on self::A% /* erasure=core::Object?, declared=! */ {
+ static get extensionTypeGetter = get self::E|extensionTypeGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set extensionTypeSetter = set self::E|extensionTypeSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method extensionTypeMethod = self::E|extensionTypeMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+extension type A(core::Object? it) {
+ abstract extension-type-member representation-field get it() → core::Object?;
+ static get extensionTypeGetter = get self::A|extensionTypeGetter;
+ static set extensionTypeSetter = set self::A|extensionTypeSetter;
+ static method extensionTypeMethod = self::A|extensionTypeMethod;
+ constructor • = self::A|constructor#;
+ constructor tearoff • = self::A|constructor#_#new#tearOff;
+}
+static extension-type-member method A|constructor#(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */ {
+ lowered final self::A% /* erasure=core::Object?, declared=! */ #this = it;
+ return #this;
+}
+static extension-type-member synthetic method A|constructor#_#new#tearOff(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */
+ return self::A|constructor#(it);
+static extension-type-member get A|extensionTypeGetter() → core::String
+ return "A.extensionTypeGetter";
+static extension-type-member set A|extensionTypeSetter(core::num value) → void {
+ throw "A.extensionTypeSetter=";
+}
+static extension-type-member method A|extensionTypeMethod() → core::String
+ return "A.extensionTypeMethod";
+static extension-member get E|extensionTypeGetter() → core::String
+ return "E.extensionTypeGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|extensionTypeSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|extensionTypeMethod() → core::String
+ return "E.extensionTypeMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A|extensionTypeGetter, "A.extensionTypeGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A|extensionTypeSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A|extensionTypeMethod(), "A.extensionTypeMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.modular.expect b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.modular.expect
new file mode 100644
index 0000000..24076e36
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.modular.expect
@@ -0,0 +1,84 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+extension E on self::A% /* erasure=core::Object?, declared=! */ {
+ static get extensionTypeGetter = get self::E|extensionTypeGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set extensionTypeSetter = set self::E|extensionTypeSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method extensionTypeMethod = self::E|extensionTypeMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+extension type A(core::Object? it) {
+ abstract extension-type-member representation-field get it() → core::Object?;
+ static get extensionTypeGetter = get self::A|extensionTypeGetter;
+ static set extensionTypeSetter = set self::A|extensionTypeSetter;
+ static method extensionTypeMethod = self::A|extensionTypeMethod;
+ constructor • = self::A|constructor#;
+ constructor tearoff • = self::A|constructor#_#new#tearOff;
+}
+static extension-type-member method A|constructor#(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */ {
+ lowered final self::A% /* erasure=core::Object?, declared=! */ #this = it;
+ return #this;
+}
+static extension-type-member synthetic method A|constructor#_#new#tearOff(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */
+ return self::A|constructor#(it);
+static extension-type-member get A|extensionTypeGetter() → core::String
+ return "A.extensionTypeGetter";
+static extension-type-member set A|extensionTypeSetter(core::num value) → void {
+ throw "A.extensionTypeSetter=";
+}
+static extension-type-member method A|extensionTypeMethod() → core::String
+ return "A.extensionTypeMethod";
+static extension-member get E|extensionTypeGetter() → core::String
+ return "E.extensionTypeGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|extensionTypeSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|extensionTypeMethod() → core::String
+ return "E.extensionTypeMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A|extensionTypeGetter, "A.extensionTypeGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A|extensionTypeSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A|extensionTypeMethod(), "A.extensionTypeMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.outline.expect
new file mode 100644
index 0000000..5664555
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.outline.expect
@@ -0,0 +1,50 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+extension E on self::A% /* erasure=core::Object?, declared=! */ {
+ static get extensionTypeGetter = get self::E|extensionTypeGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set extensionTypeSetter = set self::E|extensionTypeSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method extensionTypeMethod = self::E|extensionTypeMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+extension type A(core::Object? it) {
+ abstract extension-type-member representation-field get it() → core::Object?;
+ static get extensionTypeGetter = get self::A|extensionTypeGetter;
+ static set extensionTypeSetter = set self::A|extensionTypeSetter;
+ static method extensionTypeMethod = self::A|extensionTypeMethod;
+ constructor • = self::A|constructor#;
+ constructor tearoff • = self::A|constructor#_#new#tearOff;
+}
+static extension-type-member method A|constructor#(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */
+ ;
+static extension-type-member synthetic method A|constructor#_#new#tearOff(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */
+ return self::A|constructor#(it);
+static extension-type-member get A|extensionTypeGetter() → core::String
+ ;
+static extension-type-member set A|extensionTypeSetter(core::num value) → void
+ ;
+static extension-type-member method A|extensionTypeMethod() → core::String
+ ;
+static extension-member get E|extensionTypeGetter() → core::String
+ ;
+static extension-member get E|extensionGetter() → core::String
+ ;
+static extension-member set E|extensionTypeSetter(core::num value) → void
+ ;
+static extension-member set E|extensionSetter(core::bool value) → void
+ ;
+static extension-member method E|extensionTypeMethod() → core::String
+ ;
+static extension-member method E|extensionMethod() → core::String
+ ;
+static method main() → dynamic
+ ;
+static method expectEqual(dynamic a, dynamic b) → dynamic
+ ;
+static method expectThrows(() → dynamic f) → dynamic
+ ;
+static method expectDoesntThrow(() → dynamic f) → dynamic
+ ;
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.transformed.expect b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.transformed.expect
new file mode 100644
index 0000000..24076e36
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.strong.transformed.expect
@@ -0,0 +1,84 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+extension E on self::A% /* erasure=core::Object?, declared=! */ {
+ static get extensionTypeGetter = get self::E|extensionTypeGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set extensionTypeSetter = set self::E|extensionTypeSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method extensionTypeMethod = self::E|extensionTypeMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+extension type A(core::Object? it) {
+ abstract extension-type-member representation-field get it() → core::Object?;
+ static get extensionTypeGetter = get self::A|extensionTypeGetter;
+ static set extensionTypeSetter = set self::A|extensionTypeSetter;
+ static method extensionTypeMethod = self::A|extensionTypeMethod;
+ constructor • = self::A|constructor#;
+ constructor tearoff • = self::A|constructor#_#new#tearOff;
+}
+static extension-type-member method A|constructor#(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */ {
+ lowered final self::A% /* erasure=core::Object?, declared=! */ #this = it;
+ return #this;
+}
+static extension-type-member synthetic method A|constructor#_#new#tearOff(core::Object? it) → self::A% /* erasure=core::Object?, declared=! */
+ return self::A|constructor#(it);
+static extension-type-member get A|extensionTypeGetter() → core::String
+ return "A.extensionTypeGetter";
+static extension-type-member set A|extensionTypeSetter(core::num value) → void {
+ throw "A.extensionTypeSetter=";
+}
+static extension-type-member method A|extensionTypeMethod() → core::String
+ return "A.extensionTypeMethod";
+static extension-member get E|extensionTypeGetter() → core::String
+ return "E.extensionTypeGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|extensionTypeSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|extensionTypeMethod() → core::String
+ return "E.extensionTypeMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A|extensionTypeGetter, "A.extensionTypeGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A|extensionTypeSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A|extensionTypeMethod(), "A.extensionTypeMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.textual_outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.textual_outline.expect
new file mode 100644
index 0000000..5b35283
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.textual_outline.expect
@@ -0,0 +1,22 @@
+extension type A(Object? it) {
+ static String get extensionTypeGetter => "A.extensionTypeGetter";
+ static void set extensionTypeSetter(num value) {}
+ static String extensionTypeMethod() => "A.extensionTypeMethod";
+}
+
+extension E on A {
+ static String get extensionTypeGetter => "E.extensionTypeGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set extensionTypeSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+ static String extensionTypeMethod() => "E.extensionTypeMethod";
+ static String extensionMethod() => "E.extensionMethod";
+}
+
+main() {}
+
+expectEqual(a, b) {}
+
+expectThrows(Function() f) {}
+
+expectDoesntThrow(Function() f) {}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..23baa26
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_extension_type.dart.textual_outline_modelled.expect
@@ -0,0 +1,22 @@
+expectDoesntThrow(Function() f) {}
+
+expectEqual(a, b) {}
+
+expectThrows(Function() f) {}
+
+extension E on A {
+ static String extensionMethod() => "E.extensionMethod";
+ static String extensionTypeMethod() => "E.extensionTypeMethod";
+ static String get extensionGetter => "E.extensionGetter";
+ static String get extensionTypeGetter => "E.extensionTypeGetter";
+ static void set extensionSetter(bool value) {}
+ static void set extensionTypeSetter(num value) {}
+}
+
+extension type A(Object? it) {
+ static String extensionTypeMethod() => "A.extensionTypeMethod";
+ static String get extensionTypeGetter => "A.extensionTypeGetter";
+ static void set extensionTypeSetter(num value) {}
+}
+
+main() {}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart
new file mode 100644
index 0000000..4577db1
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart
@@ -0,0 +1,63 @@
+// Copyright (c) 2025, 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.
+
+mixin A {
+ static String get mixinGetter => "A.mixinGetter";
+ static void set mixinSetter(num value) {
+ throw "A.mixinSetter=";
+ }
+
+ static String mixinMethod() => "A.mixinMethod";
+}
+
+extension E on A {
+ static String get mixinGetter => "E.mixinGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set mixinSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+ static String mixinMethod() => "E.mixinMethod";
+ static String extensionMethod() => "E.extensionMethod";
+}
+
+main() {
+ expectEqual(A.mixinGetter, "A.mixinGetter");
+ expectEqual(A.extensionGetter, "E.extensionGetter");
+ expectThrows(() {
+ A.mixinSetter = 0;
+ });
+ expectDoesntThrow(() {
+ A.extensionSetter = false;
+ });
+ expectEqual(A.mixinMethod(), "A.mixinMethod");
+ expectEqual(A.extensionMethod(), "E.extensionMethod");
+}
+
+expectEqual(a, b) {
+ if (a != b) {
+ throw "Expected the values to be equal.";
+ }
+}
+
+expectThrows(Function() f) {
+ bool hasThrown = false;
+ try {
+ f();
+ } on dynamic {
+ hasThrown = true;
+ }
+ if (!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+
+expectDoesntThrow(Function() f) {
+ bool hasThrown = true;
+ try {
+ f();
+ hasThrown = false;
+ } on dynamic {}
+ if (hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.expect b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.expect
new file mode 100644
index 0000000..bd644f5
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.expect
@@ -0,0 +1,72 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object /*isMixinDeclaration*/ {
+ static get mixinGetter() → core::String
+ return "A.mixinGetter";
+ static set mixinSetter(core::num value) → void {
+ throw "A.mixinSetter=";
+ }
+ static method mixinMethod() → core::String
+ return "A.mixinMethod";
+}
+extension E on self::A {
+ static get mixinGetter = get self::E|mixinGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set mixinSetter = set self::E|mixinSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method mixinMethod = self::E|mixinMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|mixinGetter() → core::String
+ return "E.mixinGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|mixinSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|mixinMethod() → core::String
+ return "E.mixinMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A::mixinGetter, "A.mixinGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A::mixinSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A::mixinMethod(), "A.mixinMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.modular.expect b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.modular.expect
new file mode 100644
index 0000000..bd644f5
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.modular.expect
@@ -0,0 +1,72 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object /*isMixinDeclaration*/ {
+ static get mixinGetter() → core::String
+ return "A.mixinGetter";
+ static set mixinSetter(core::num value) → void {
+ throw "A.mixinSetter=";
+ }
+ static method mixinMethod() → core::String
+ return "A.mixinMethod";
+}
+extension E on self::A {
+ static get mixinGetter = get self::E|mixinGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set mixinSetter = set self::E|mixinSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method mixinMethod = self::E|mixinMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|mixinGetter() → core::String
+ return "E.mixinGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|mixinSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|mixinMethod() → core::String
+ return "E.mixinMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A::mixinGetter, "A.mixinGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A::mixinSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A::mixinMethod(), "A.mixinMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.outline.expect
new file mode 100644
index 0000000..26fac58
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.outline.expect
@@ -0,0 +1,40 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object /*isMixinDeclaration*/ {
+ static get mixinGetter() → core::String
+ ;
+ static set mixinSetter(core::num value) → void
+ ;
+ static method mixinMethod() → core::String
+ ;
+}
+extension E on self::A {
+ static get mixinGetter = get self::E|mixinGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set mixinSetter = set self::E|mixinSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method mixinMethod = self::E|mixinMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|mixinGetter() → core::String
+ ;
+static extension-member get E|extensionGetter() → core::String
+ ;
+static extension-member set E|mixinSetter(core::num value) → void
+ ;
+static extension-member set E|extensionSetter(core::bool value) → void
+ ;
+static extension-member method E|mixinMethod() → core::String
+ ;
+static extension-member method E|extensionMethod() → core::String
+ ;
+static method main() → dynamic
+ ;
+static method expectEqual(dynamic a, dynamic b) → dynamic
+ ;
+static method expectThrows(() → dynamic f) → dynamic
+ ;
+static method expectDoesntThrow(() → dynamic f) → dynamic
+ ;
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.transformed.expect b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.transformed.expect
new file mode 100644
index 0000000..bd644f5
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.strong.transformed.expect
@@ -0,0 +1,72 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+abstract class A extends core::Object /*isMixinDeclaration*/ {
+ static get mixinGetter() → core::String
+ return "A.mixinGetter";
+ static set mixinSetter(core::num value) → void {
+ throw "A.mixinSetter=";
+ }
+ static method mixinMethod() → core::String
+ return "A.mixinMethod";
+}
+extension E on self::A {
+ static get mixinGetter = get self::E|mixinGetter;
+ static get extensionGetter = get self::E|extensionGetter;
+ static set mixinSetter = set self::E|mixinSetter;
+ static set extensionSetter = set self::E|extensionSetter;
+ static method mixinMethod = self::E|mixinMethod;
+ static method extensionMethod = self::E|extensionMethod;
+}
+static extension-member get E|mixinGetter() → core::String
+ return "E.mixinGetter";
+static extension-member get E|extensionGetter() → core::String
+ return "E.extensionGetter";
+static extension-member set E|mixinSetter(core::num value) → void {}
+static extension-member set E|extensionSetter(core::bool value) → void {}
+static extension-member method E|mixinMethod() → core::String
+ return "E.mixinMethod";
+static extension-member method E|extensionMethod() → core::String
+ return "E.extensionMethod";
+static method main() → dynamic {
+ self::expectEqual(self::A::mixinGetter, "A.mixinGetter");
+ self::expectEqual(self::E|extensionGetter, "E.extensionGetter");
+ self::expectThrows(() → Null {
+ self::A::mixinSetter = 0;
+ });
+ self::expectDoesntThrow(() → Null {
+ self::E|extensionSetter = false;
+ });
+ self::expectEqual(self::A::mixinMethod(), "A.mixinMethod");
+ self::expectEqual(self::E|extensionMethod(), "E.extensionMethod");
+}
+static method expectEqual(dynamic a, dynamic b) → dynamic {
+ if(!(a =={core::Object::==}{(core::Object) → core::bool} b)) {
+ throw "Expected the values to be equal.";
+ }
+}
+static method expectThrows(() → dynamic f) → dynamic {
+ core::bool hasThrown = false;
+ try {
+ f(){() → dynamic};
+ }
+ on dynamic catch(no-exception-var) {
+ hasThrown = true;
+ }
+ if(!hasThrown) {
+ throw "Expected the function to throw an exception.";
+ }
+}
+static method expectDoesntThrow(() → dynamic f) → dynamic {
+ core::bool hasThrown = true;
+ try {
+ f(){() → dynamic};
+ hasThrown = false;
+ }
+ on dynamic catch(no-exception-var) {
+ }
+ if(hasThrown) {
+ throw "Expected the function not to throw exceptions.";
+ }
+}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.textual_outline.expect b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.textual_outline.expect
new file mode 100644
index 0000000..7e23a8a
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.textual_outline.expect
@@ -0,0 +1,22 @@
+mixin A {
+ static String get mixinGetter => "A.mixinGetter";
+ static void set mixinSetter(num value) {}
+ static String mixinMethod() => "A.mixinMethod";
+}
+
+extension E on A {
+ static String get mixinGetter => "E.mixinGetter";
+ static String get extensionGetter => "E.extensionGetter";
+ static void set mixinSetter(num value) {}
+ static void set extensionSetter(bool value) {}
+ static String mixinMethod() => "E.mixinMethod";
+ static String extensionMethod() => "E.extensionMethod";
+}
+
+main() {}
+
+expectEqual(a, b) {}
+
+expectThrows(Function() f) {}
+
+expectDoesntThrow(Function() f) {}
diff --git a/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.textual_outline_modelled.expect
new file mode 100644
index 0000000..9eaf81e
--- /dev/null
+++ b/pkg/front_end/testcases/static_extensions/simple_positive_mixin.dart.textual_outline_modelled.expect
@@ -0,0 +1,22 @@
+expectDoesntThrow(Function() f) {}
+
+expectEqual(a, b) {}
+
+expectThrows(Function() f) {}
+
+extension E on A {
+ static String extensionMethod() => "E.extensionMethod";
+ static String get extensionGetter => "E.extensionGetter";
+ static String get mixinGetter => "E.mixinGetter";
+ static String mixinMethod() => "E.mixinMethod";
+ static void set extensionSetter(bool value) {}
+ static void set mixinSetter(num value) {}
+}
+
+main() {}
+
+mixin A {
+ static String get mixinGetter => "A.mixinGetter";
+ static String mixinMethod() => "A.mixinMethod";
+ static void set mixinSetter(num value) {}
+}
