pkg/compiler/test/model/no_such_method_forwarders_test.dart

// Copyright (c) 2018, 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 'package:compiler/src/compiler.dart';
import 'package:compiler/src/elements/entities.dart';
import 'package:compiler/src/elements/types.dart';
import 'package:compiler/src/js_model/js_world.dart' show JClosedWorld;
import 'package:expect/async_helper.dart';
import 'package:expect/expect.dart';
import '../helpers/element_lookup.dart';
import 'package:compiler/src/util/memory_compiler.dart';

const String source = '''
abstract class I<T> {
  T? method();
}

class A<T> implements I<T> {
  noSuchMethod(_) => null;
}

class B<T> extends I<T> {
  noSuchMethod(_) => null;
}

abstract class C1<T> implements I<T> {
}

class C2<T> extends C1<T> {
  noSuchMethod(_) => null;
}

abstract class D1<T> implements I<T> {
}

abstract class D2<T> extends D1<T> {
  noSuchMethod(_) => null;
}

class D3<T> extends D2<T> {
}

class E1<T> {
  T? method() => null;
}

mixin E2<T> implements I<T> {
  noSuchMethod(_) => null;
}

class E3<T> extends E1<T> with E2<T> {
}

class F1<T> {
  T? method() => null;
}

mixin class F2<T> implements I<T> {
  noSuchMethod(_) => null;
}

class F3<T> extends F1<T> with F2<T> {
}

abstract class G1<T> {
  T? method();
}

mixin G2<T> implements I<T> {
  noSuchMethod(_) => null;
}

class G3<T> extends G1<T> with G2<T> {
}

abstract class H1<T> {
  T? method();
}

mixin H2<T> implements I<T> {
  noSuchMethod(_) => null;
}

class H3<T> extends H1<T> with H2<T> {
  method() => null;
}

main() {
  A();
  B();
  C2();
  D3();
  E1();
  E3();
  F1();
  F2();
  F3();
  G3();
  H3();
  dynamic d;
  d.method();
}
''';

main() {
  asyncTest(() async {
    CompilationResult result = await runCompiler(
      memorySourceFiles: {'main.dart': source},
    );
    Expect.isTrue(result.isSuccess);
    Compiler compiler = result.compiler!;
    JClosedWorld closedWorld = compiler.backendClosedWorldForTesting!;

    void check(
      String className, {
      required bool hasMethod,
      bool isAbstract = false,
      String? declaringClass,
    }) {
      assert(
        !hasMethod || declaringClass != null,
        'declaringClass must be provided if hasMethod = true',
      );
      MemberEntity? member = findClassMemberOrNull(
        closedWorld,
        className,
        'method',
      );
      if (hasMethod) {
        Expect.isNotNull(
          member,
          "Missing member 'method' in class '$className'.",
        );
        Expect.equals(
          isAbstract,
          member!.isAbstract,
          "Unexpected abstract-ness on method $member.",
        );
        ClassEntity cls = findClass(closedWorld, declaringClass!);
        if (cls != member.enclosingClass) {
          print(
            "Unexpected declaring class $member. "
            "Found ${member.enclosingClass}, expected $cls.",
          );
        }
        Expect.equals(
          cls,
          member.enclosingClass,
          "Unexpected declaring class $member. "
          "Found ${member.enclosingClass}, expected $cls.",
        );
        late DartType type;
        if (member.isFunction) {
          type = closedWorld.elementEnvironment
              .getFunctionType(member as FunctionEntity)
              .returnType;
        } else if (member.isGetter) {
          type = closedWorld.elementEnvironment
              .getFunctionType(member as FunctionEntity)
              .returnType;
        } else if (member.isSetter) {
          type = closedWorld.elementEnvironment
              .getFunctionType(member as FunctionEntity)
              .parameterTypes
              .first;
        }
        type = type.withoutNullability;
        Expect.isTrue(
          type is TypeVariableType,
          "Unexpected member type for $member: $type",
        );
        TypeVariableType typeVariable = type as TypeVariableType;
        Expect.equals(
          cls,
          typeVariable.element.typeDeclaration,
          "Unexpected type declaration for $typeVariable for $member. "
          "Expected $cls, found ${typeVariable.element.typeDeclaration}.",
        );
      } else {
        Expect.isNull(
          member,
          "Unexpected member 'method' in class '$className': $member.",
        );
      }
    }

    check('I', hasMethod: true, isAbstract: true, declaringClass: 'I');
    check('A', hasMethod: true, declaringClass: 'A');
    check('B', hasMethod: true, declaringClass: 'B');
    check('C1', hasMethod: false);
    check('C2', hasMethod: true, declaringClass: 'C2');
    check('D1', hasMethod: false);
    check('D2', hasMethod: false);
    check('D3', hasMethod: true, declaringClass: 'D3');
    check('E1', hasMethod: true, declaringClass: 'E1');
    check('E2', hasMethod: false);
    check('E3', hasMethod: true, declaringClass: 'E1');
    check('F1', hasMethod: true, declaringClass: 'F1');
    check('F2', hasMethod: true, declaringClass: 'F2');
    check('F3', hasMethod: true, declaringClass: 'F1');
    check('G1', hasMethod: true, isAbstract: true, declaringClass: 'G1');
    check('G2', hasMethod: false);
    check('G3', hasMethod: true, declaringClass: 'G3');
    check('H1', hasMethod: true, isAbstract: true, declaringClass: 'H1');
    check('H2', hasMethod: false);
    check('H3', hasMethod: true, declaringClass: 'H3');
  });
}