[cfe] Include dill in propagating errors in redirecting factories

Redirecting factory chains may include a mix of source- and dill-
factory builders. The error propagation should work in that case too.

This is a follow-up to
https://dart-review.googlesource.com/c/sdk/+/332403/comment/14b70a92_c6e1a91e/

Part of #49731

Change-Id: I74be2a47260c2c24c2fc871b7f1521546f056a03
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/333162
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

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

@@ -15,6 +15,7 @@ import '../builder/function_builder.dart';
 import '../builder/metadata_builder.dart';
 import '../builder/type_builder.dart';
 import '../dill/dill_member_builder.dart';
+import '../dill/dill_extension_type_member_builder.dart';
 import '../fasta_codes.dart';
 import '../identifiers.dart';
 import '../kernel/body_builder_context.dart';
@@ -610,14 +611,16 @@ class RedirectingFactoryBuilder extends SourceFactoryBuilder {
     if (targetBuilder == null) return null;
     if (targetBuilder is FunctionBuilder) {
       targetNode = targetBuilder.function;
+    } else if (targetBuilder is DillExtensionTypeFactoryBuilder) {
+      targetNode = targetBuilder.member.function!;
     } else if (targetBuilder is AmbiguousBuilder) {
       // Multiple definitions with the same name: An error has already been
       // issued.
       // TODO(http://dartbug.com/35294): Unfortunate error; see also
       // https://dart-review.googlesource.com/c/sdk/+/85390/.
       return null;
     } else {
-      unhandled("${redirectionTarget.target}", "computeRedirecteeType",
+      unhandled("${targetBuilder.runtimeType}", "computeRedirecteeType",
           charOffset, fileUri);
     }
 

pkg/front_end/testcases/extension_types/redirecting_factory_from_class.dart

@@ -0,0 +1,54 @@
+// 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.
+
+class A1 {
+  final int foo;
+  const A1(this.foo);
+  const factory A1.redir(A1 it) = E1.redir;
+}
+
+extension type const E1(A1 it) implements A1 {
+  const factory E1.redir(A1 it) = E1;
+}
+
+test1() {
+  const A1 a1 = const A1(0);
+  expectIdentical(const A1.redir(a1), a1);
+}
+
+class A2 {
+  final int foo;
+  const A2(this.foo);
+  const factory A2.redir(bool b) = E2.pick;
+}
+
+class B2 extends A2 {
+  static const B2 element = const B2(0);
+  const B2(super.foo);
+}
+
+class C2 extends A2 {
+  static const C2 element = const C2(0);
+  const C2(super.foo);
+}
+
+extension type const E2(A2 it) implements A2 {
+  const E2.pick(bool b) : this(b ? B2.element : C2.element);
+}
+
+test2() {
+  expectIdentical(const A2.redir(true), B2.element);
+  expectIdentical(const A2.redir(false), C2.element);
+}
+
+expectIdentical(expected, actual) {
+  if (!identical(expected, actual)) {
+    throw "Expected '${expected}', actual '${actual}'.";
+  }
+}
+
+main() {
+  test1();
+  test2();
+}

pkg/front_end/testcases/extension_types/redirecting_factory_from_class.dart.strong.expect

@@ -0,0 +1,101 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A1 extends core::Object /*hasConstConstructor*/  {
+  final field core::int foo;
+  const constructor •(core::int foo) → self::A1
+    : self::A1::foo = foo, super core::Object::•()
+    ;
+  static factory redir(self::A1 it) → self::A1 /* redirection-target: self::E1|constructor#redir */
+    return self::E1|constructor#redir(it);
+}
+class A2 extends core::Object /*hasConstConstructor*/  {
+  final field core::int foo;
+  const constructor •(core::int foo) → self::A2
+    : self::A2::foo = foo, super core::Object::•()
+    ;
+  static factory redir(core::bool b) → self::A2 /* redirection-target: self::E2|constructor#pick */
+    return self::E2|constructor#pick(b);
+}
+class B2 extends self::A2 /*hasConstConstructor*/  {
+  static const field self::B2 element = #C2;
+  const constructor •(core::int foo) → self::B2
+    : super self::A2::•(foo)
+    ;
+}
+class C2 extends self::A2 /*hasConstConstructor*/  {
+  static const field self::C2 element = #C3;
+  const constructor •(core::int foo) → self::C2
+    : super self::A2::•(foo)
+    ;
+}
+extension type E1(self::A1 it) implements self::A1 {
+  abstract inline-class-member representation-field get it() → self::A1;
+  constructor • = self::E1|constructor#;
+  constructor tearoff • = self::E1|constructor#_#new#tearOff;
+  static redirecting-factory redir = self::E1|constructor#redir;
+  static redirecting-factory tearoff redir = self::E1|constructor#_#redir#tearOff;
+}
+extension type E2(self::A2 it) implements self::A2 {
+  abstract inline-class-member representation-field get it() → self::A2;
+  constructor • = self::E2|constructor#;
+  constructor tearoff • = self::E2|constructor#_#new#tearOff;
+  constructor pick = self::E2|constructor#pick;
+  constructor tearoff pick = self::E2|constructor#_#pick#tearOff;
+}
+static inline-class-member method E1|constructor#(self::A1 it) → self::E1 /* = self::A1 */ {
+  lowered final self::E1 /* = self::A1 */ #this = it;
+  return #this;
+}
+static inline-class-member method E1|constructor#_#new#tearOff(self::A1 it) → self::E1 /* = self::A1 */
+  return self::E1|constructor#(it);
+static inline-class-member method E1|constructor#redir(self::A1 it) → self::E1 /* = self::A1 */ /* redirection-target: self::E1|constructor# */
+  return self::E1|constructor#(it);
+static inline-class-member method E1|constructor#_#redir#tearOff(self::A1 it) → self::E1 /* = self::A1 */
+  return self::E1|constructor#(it);
+static method test1() → dynamic {
+  self::expectIdentical(#C4, #C4);
+}
+static inline-class-member method E2|constructor#(self::A2 it) → self::E2 /* = self::A2 */ {
+  lowered final self::E2 /* = self::A2 */ #this = it;
+  return #this;
+}
+static inline-class-member method E2|constructor#_#new#tearOff(self::A2 it) → self::E2 /* = self::A2 */
+  return self::E2|constructor#(it);
+static inline-class-member method E2|constructor#pick(core::bool b) → self::E2 /* = self::A2 */ {
+  lowered final self::E2 /* = self::A2 */ #this;
+  #this = self::E2|constructor#(b ?{self::A2} #C2 : #C3);
+  return #this;
+}
+static inline-class-member method E2|constructor#_#pick#tearOff(core::bool b) → self::E2 /* = self::A2 */
+  return self::E2|constructor#pick(b);
+static method test2() → dynamic {
+  self::expectIdentical(#C2, #C2);
+  self::expectIdentical(#C3, #C3);
+}
+static method expectIdentical(dynamic expected, dynamic actual) → dynamic {
+  if(!core::identical(expected, actual)) {
+    throw "Expected '${expected}', actual '${actual}'.";
+  }
+}
+static method main() → dynamic {
+  self::test1();
+  self::test2();
+}
+
+constants  {
+  #C1 = 0
+  #C2 = self::B2 {foo:#C1}
+  #C3 = self::C2 {foo:#C1}
+  #C4 = self::A1 {foo:#C1}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///redirecting_factory_from_class.dart:
+- B2. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:28:9)
+- A2. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:22:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- C2. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:33:9)
+- A1. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:7:9)

pkg/front_end/testcases/extension_types/redirecting_factory_from_class.dart.strong.transformed.expect

@@ -0,0 +1,101 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A1 extends core::Object /*hasConstConstructor*/  {
+  final field core::int foo;
+  const constructor •(core::int foo) → self::A1
+    : self::A1::foo = foo, super core::Object::•()
+    ;
+  static factory redir(self::A1 it) → self::A1 /* redirection-target: self::E1|constructor#redir */
+    return self::E1|constructor#redir(it);
+}
+class A2 extends core::Object /*hasConstConstructor*/  {
+  final field core::int foo;
+  const constructor •(core::int foo) → self::A2
+    : self::A2::foo = foo, super core::Object::•()
+    ;
+  static factory redir(core::bool b) → self::A2 /* redirection-target: self::E2|constructor#pick */
+    return self::E2|constructor#pick(b);
+}
+class B2 extends self::A2 /*hasConstConstructor*/  {
+  static const field self::B2 element = #C2;
+  const constructor •(core::int foo) → self::B2
+    : super self::A2::•(foo)
+    ;
+}
+class C2 extends self::A2 /*hasConstConstructor*/  {
+  static const field self::C2 element = #C3;
+  const constructor •(core::int foo) → self::C2
+    : super self::A2::•(foo)
+    ;
+}
+extension type E1(self::A1 it) implements self::A1 {
+  abstract inline-class-member representation-field get it() → self::A1;
+  constructor • = self::E1|constructor#;
+  constructor tearoff • = self::E1|constructor#_#new#tearOff;
+  static redirecting-factory redir = self::E1|constructor#redir;
+  static redirecting-factory tearoff redir = self::E1|constructor#_#redir#tearOff;
+}
+extension type E2(self::A2 it) implements self::A2 {
+  abstract inline-class-member representation-field get it() → self::A2;
+  constructor • = self::E2|constructor#;
+  constructor tearoff • = self::E2|constructor#_#new#tearOff;
+  constructor pick = self::E2|constructor#pick;
+  constructor tearoff pick = self::E2|constructor#_#pick#tearOff;
+}
+static inline-class-member method E1|constructor#(self::A1 it) → self::E1 /* = self::A1 */ {
+  lowered final self::E1 /* = self::A1 */ #this = it;
+  return #this;
+}
+static inline-class-member method E1|constructor#_#new#tearOff(self::A1 it) → self::E1 /* = self::A1 */
+  return self::E1|constructor#(it);
+static inline-class-member method E1|constructor#redir(self::A1 it) → self::E1 /* = self::A1 */ /* redirection-target: self::E1|constructor# */
+  return self::E1|constructor#(it);
+static inline-class-member method E1|constructor#_#redir#tearOff(self::A1 it) → self::E1 /* = self::A1 */
+  return self::E1|constructor#(it);
+static method test1() → dynamic {
+  self::expectIdentical(#C4, #C4);
+}
+static inline-class-member method E2|constructor#(self::A2 it) → self::E2 /* = self::A2 */ {
+  lowered final self::E2 /* = self::A2 */ #this = it;
+  return #this;
+}
+static inline-class-member method E2|constructor#_#new#tearOff(self::A2 it) → self::E2 /* = self::A2 */
+  return self::E2|constructor#(it);
+static inline-class-member method E2|constructor#pick(core::bool b) → self::E2 /* = self::A2 */ {
+  lowered final self::E2 /* = self::A2 */ #this;
+  #this = self::E2|constructor#(b ?{self::A2} #C2 : #C3);
+  return #this;
+}
+static inline-class-member method E2|constructor#_#pick#tearOff(core::bool b) → self::E2 /* = self::A2 */
+  return self::E2|constructor#pick(b);
+static method test2() → dynamic {
+  self::expectIdentical(#C2, #C2);
+  self::expectIdentical(#C3, #C3);
+}
+static method expectIdentical(dynamic expected, dynamic actual) → dynamic {
+  if(!core::identical(expected, actual)) {
+    throw "Expected '${expected}', actual '${actual}'.";
+  }
+}
+static method main() → dynamic {
+  self::test1();
+  self::test2();
+}
+
+constants  {
+  #C1 = 0
+  #C2 = self::B2 {foo:#C1}
+  #C3 = self::C2 {foo:#C1}
+  #C4 = self::A1 {foo:#C1}
+}
+
+
+Constructor coverage from constants:
+org-dartlang-testcase:///redirecting_factory_from_class.dart:
+- B2. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:28:9)
+- A2. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:22:9)
+- Object. (from org-dartlang-sdk:///sdk/lib/core/object.dart)
+- C2. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:33:9)
+- A1. (from org-dartlang-testcase:///redirecting_factory_from_class.dart:7:9)

pkg/front_end/testcases/extension_types/redirecting_factory_from_class.dart.textual_outline.expect

@@ -0,0 +1,28 @@
+class A1 {
+  final int foo;
+  const A1(this.foo);
+  const factory A1.redir(A1 it) = E1.redir;
+}
+extension type const E1(A1 it) implements A1 {
+  const factory E1.redir(A1 it) = E1;
+}
+test1() {}
+class A2 {
+  final int foo;
+  const A2(this.foo);
+  const factory A2.redir(bool b) = E2.pick;
+}
+class B2 extends A2 {
+  static const B2 element = const B2(0);
+  const B2(super.foo);
+}
+class C2 extends A2 {
+  static const C2 element = const C2(0);
+  const C2(super.foo);
+}
+extension type const E2(A2 it) implements A2 {
+  const E2.pick(bool b) : this(b ? B2.element : C2.element);
+}
+test2() {}
+expectIdentical(expected, actual) {}
+main() {}

pkg/front_end/testcases/extension_types/redirecting_factory_from_class.dart.textual_outline_modelled.expect

@@ -0,0 +1,28 @@
+class A1 {
+  const A1(this.foo);
+  const factory A1.redir(A1 it) = E1.redir;
+  final int foo;
+}
+class A2 {
+  const A2(this.foo);
+  const factory A2.redir(bool b) = E2.pick;
+  final int foo;
+}
+class B2 extends A2 {
+  const B2(super.foo);
+  static const B2 element = const B2(0);
+}
+class C2 extends A2 {
+  const C2(super.foo);
+  static const C2 element = const C2(0);
+}
+expectIdentical(expected, actual) {}
+extension type const E1(A1 it) implements A1 {
+  const factory E1.redir(A1 it) = E1;
+}
+extension type const E2(A2 it) implements A2 {
+  const E2.pick(bool b) : this(b ? B2.element : C2.element);
+}
+main() {}
+test1() {}
+test2() {}