library /*isNonNullableByDefault*/;
//
// Problems in library:
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:44:8: Error: Too few positional arguments: 1 required, 0 given.
//     f3a(); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:45:8: Error: Too many positional arguments: 1 allowed, but 2 found.
// Try removing the extra positional arguments.
//     f3a(42, 87); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:62:8: Error: Expected 1 type arguments.
//     f4a<int, String>(); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:70:8: Error: Expected 0 type arguments.
//     f4b<int>(); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:87:8: Error: Expected 1 type arguments.
//     f4d<int, String>(); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:95:8: Error: Expected 0 type arguments.
//     f4e<int>(); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:112:8: Error: Type argument 'String' doesn't conform to the bound 'num' of the type variable 'T' on 'call'.
// Try changing type arguments so that they conform to the bounds.
//     f5a<String>(); // error
//        ^
//
// pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:113:8: Error: Expected 1 type arguments.
//     f5a<int, String>(); // error
//        ^
//
import self as self;
import "main_lib.dart" as mai;
import "dart:core" as core;

import "org-dartlang-testcase:///main_lib.dart";

static final field core::bool inSoundMode = !(<core::int?>[] is{ForNonNullableByDefault} core::List<core::int>);
static method main() → dynamic {
  () → mai::Class1 f1a = #C1;
  mai::Class1 c1a = f1a(){() → mai::Class1};
  self::expect(true, c1a is{ForNonNullableByDefault} mai::Class1);
  dynamic f1b = #C1;
  dynamic c1b = f1b{dynamic}.call();
  self::expect(true, c1b is{ForNonNullableByDefault} mai::Class1);
  self::expect(true, core::identical(f1a, f1b));
  () → mai::Class2 f2a = #C2;
  mai::Class2 c2a = f2a(){() → mai::Class2};
  self::expect(true, c2a is{ForNonNullableByDefault} mai::Class2);
  dynamic f2b = #C2;
  dynamic c2b = f2b{dynamic}.call();
  self::expect(true, c2b is{ForNonNullableByDefault} mai::Class2);
  self::expect(true, core::identical(f2a, f2b));
  () → mai::Class2 f2c = #C3;
  mai::Class2 c2c = f2c(){() → mai::Class2};
  self::expect(true, c2c is{ForNonNullableByDefault} mai::Class2);
  dynamic f2d = #C3;
  dynamic c2d = f2d{dynamic}.call();
  self::expect(true, c2d is{ForNonNullableByDefault} mai::Class2);
  self::expect(true, core::identical(f2c, f2d));
  (core::int) → mai::Class3 f3a = #C4;
  mai::Class3 c3a = f3a(42){(core::int) → mai::Class3};
  self::expect(42, c3a.{mai::Class3::field}{core::int});
  () → Null {
    let final Never #t1 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:44:8: Error: Too few positional arguments: 1 required, 0 given.
    f3a(); // error
       ^" in f3a{<inapplicable>}.();
    let final Never #t2 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:45:8: Error: Too many positional arguments: 1 allowed, but 2 found.
Try removing the extra positional arguments.
    f3a(42, 87); // error
       ^" in f3a{<inapplicable>}.(42, 87);
  };
  dynamic f3b = #C4;
  dynamic c3b = f3b{dynamic}.call(87);
  self::expect(87, c3b{dynamic}.field);
  self::throws(() → dynamic => f3b{dynamic}.call());
  self::throws(() → dynamic => f3b{dynamic}.call(42, 87));
  <T extends core::Object? = dynamic>() → mai::Class4<T%> f4a = #C5;
  mai::Class4<dynamic> c4a = f4a<dynamic>(){() → mai::Class4<dynamic>};
  self::expect(true, c4a is{ForNonNullableByDefault} mai::Class4<dynamic>);
  self::expect(false, c4a is{ForNonNullableByDefault} mai::Class4<core::int>);
  mai::Class4<core::int> c4b = f4a<core::int>(){() → mai::Class4<core::int>};
  self::expect(true, c4b is{ForNonNullableByDefault} mai::Class4<core::int>);
  self::expect(false, c4b is{ForNonNullableByDefault} mai::Class4<core::String>);
  () → Null {
    let final Never #t3 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:62:8: Error: Expected 1 type arguments.
    f4a<int, String>(); // error
       ^" in f4a{<inapplicable>}.<core::int, core::String>();
  };
  () → mai::Class4<core::int> f4b = f4a<core::int>;
  mai::Class4<core::int> c4c = f4b(){() → mai::Class4<core::int>};
  self::expect(true, c4c is{ForNonNullableByDefault} mai::Class4<core::int>);
  self::expect(false, c4c is{ForNonNullableByDefault} mai::Class4<core::String>);
  () → Null {
    let final Never #t4 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:70:8: Error: Expected 0 type arguments.
    f4b<int>(); // error
       ^" in f4b{<inapplicable>}.<core::int>();
  };
  dynamic f4c = #C5;
  dynamic c4d = f4c{dynamic}.call();
  self::expect(true, c4d is{ForNonNullableByDefault} mai::Class4<dynamic>);
  self::expect(false, c4d is{ForNonNullableByDefault} mai::Class4<core::int>);
  self::throws(() → dynamic => f4c{dynamic}.call<core::int, core::String>());
  <T extends core::Object? = dynamic>() → mai::Class4<T%> f4d = #C6;
  mai::Class4<dynamic> c4e = f4d<dynamic>(){() → mai::Class4<dynamic>};
  self::expect(true, c4e is{ForNonNullableByDefault} mai::Class4<dynamic>);
  self::expect(false, c4e is{ForNonNullableByDefault} mai::Class4<core::int>);
  mai::Class4<core::int> c4f = f4d<core::int>(){() → mai::Class4<core::int>};
  self::expect(true, c4f is{ForNonNullableByDefault} mai::Class4<core::int>);
  self::expect(false, c4f is{ForNonNullableByDefault} mai::Class4<core::String>);
  () → Null {
    let final Never #t5 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:87:8: Error: Expected 1 type arguments.
    f4d<int, String>(); // error
       ^" in f4d{<inapplicable>}.<core::int, core::String>();
  };
  () → mai::Class4<core::int> f4e = f4d<core::int>;
  mai::Class4<core::int> c4g = f4e(){() → mai::Class4<core::int>};
  self::expect(true, c4g is{ForNonNullableByDefault} mai::Class4<core::int>);
  self::expect(false, c4g is{ForNonNullableByDefault} mai::Class4<core::String>);
  () → Null {
    let final Never #t6 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:95:8: Error: Expected 0 type arguments.
    f4e<int>(); // error
       ^" in f4e{<inapplicable>}.<core::int>();
  };
  dynamic f4f = #C6;
  dynamic c4h = f4f{dynamic}.call();
  self::expect(true, c4h is{ForNonNullableByDefault} mai::Class4<dynamic>);
  self::expect(false, c4h is{ForNonNullableByDefault} mai::Class4<core::int>);
  self::throws(() → dynamic => f4f{dynamic}.call<core::int, core::String>());
  <T extends core::num>() → mai::Class5<T> f5a = #C7;
  mai::Class5<core::num> c5a = f5a<core::num>(){() → mai::Class5<core::num>};
  self::expect(true, c5a is{ForNonNullableByDefault} mai::Class5<core::num>);
  self::expect(false, c5a is{ForNonNullableByDefault} mai::Class5<core::int>);
  mai::Class5<core::int> c5b = f5a<core::int>(){() → mai::Class5<core::int>};
  self::expect(true, c5b is{ForNonNullableByDefault} mai::Class5<core::int>);
  self::expect(false, c5b is{ForNonNullableByDefault} mai::Class5<core::double>);
  () → Null {
    f5a<core::String>(){() → mai::Class5<core::String>};
    let final Never #t7 = invalid-expression "pkg/front_end/testcases/constructor_tearoffs/lowering/from_dill/main.dart:113:8: Error: Expected 1 type arguments.
    f5a<int, String>(); // error
       ^" in f5a{<inapplicable>}.<core::int, core::String>();
  };
  dynamic f5b = #C7;
  dynamic c5c = f5b{dynamic}.call();
  self::expect(true, c5c is{ForNonNullableByDefault} mai::Class5<core::num>);
  self::expect(false, c5c is{ForNonNullableByDefault} mai::Class5<core::int>);
  dynamic c5d = f5b{dynamic}.call<core::int>();
  self::expect(true, c5d is{ForNonNullableByDefault} mai::Class5<core::int>);
  self::expect(false, c5d is{ForNonNullableByDefault} mai::Class5<core::double>);
  self::throws(() → dynamic => f5b{dynamic}.call<core::String>());
  self::throws(() → dynamic => f5b{dynamic}.call<core::int, core::String>());
}
static method expect(dynamic expected, dynamic actual) → dynamic {
  if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual))
    throw "Expected ${expected}, actual ${actual}";
}
static method throws(() → dynamic f, {core::bool inSoundModeOnly = #C8}) → dynamic {
  try {
    f(){() → dynamic};
  }
  on core::Object catch(final core::Object e) {
    core::print("Thrown: ${e}");
    return;
  }
  if(!self::inSoundMode && inSoundModeOnly) {
    return;
  }
  throw "Expected exception";
}

library /*isNonNullableByDefault*/;
import self as mai;
import "dart:core" as core;

class Class1 extends core::Object {
  synthetic constructor •() → mai::Class1
    : super core::Object::•()
    ;
  static method _#new#tearOff() → mai::Class1
    return new mai::Class1::•();
}
class Class2 extends core::Object {
  static final field dynamic _redirecting# = <dynamic>[mai::Class2::redirect]/*isLegacy*/;
  constructor named() → mai::Class2
    : super core::Object::•()
    ;
  static method _#named#tearOff() → mai::Class2
    return new mai::Class2::named();
  static factory redirect() → mai::Class2
    let dynamic #redirecting_factory = mai::Class2::named in invalid-expression;
  static method _#redirect#tearOff() → mai::Class2
    return new mai::Class2::named();
}
class Class3 extends core::Object {
  final field core::int field;
  constructor •(core::int field) → mai::Class3
    : mai::Class3::field = field, super core::Object::•()
    ;
  static method _#new#tearOff(core::int field) → mai::Class3
    return new mai::Class3::•(field);
}
class Class4<T extends core::Object? = dynamic> extends core::Object {
  static final field dynamic _redirecting# = <dynamic>[mai::Class4::redirect]/*isLegacy*/;
  constructor _() → mai::Class4<mai::Class4::T%>
    : super core::Object::•()
    ;
  static method _#_#tearOff<T extends core::Object? = dynamic>() → mai::Class4<mai::Class4::_#_#tearOff::T%>
    return new mai::Class4::_<mai::Class4::_#_#tearOff::T%>();
  static factory •<T extends core::Object? = dynamic>() → mai::Class4<mai::Class4::•::T%>
    return new mai::Class4::_<mai::Class4::•::T%>();
  static method _#new#tearOff<T extends core::Object? = dynamic>() → mai::Class4<mai::Class4::_#new#tearOff::T%>
    return mai::Class4::•<mai::Class4::_#new#tearOff::T%>();
  static factory redirect<T extends core::Object? = dynamic>() → mai::Class4<mai::Class4::redirect::T%>
    let dynamic #redirecting_factory = mai::Class4::_ in let mai::Class4::redirect::T% #typeArg0 = null in invalid-expression;
  static method _#redirect#tearOff<T extends core::Object? = dynamic>() → mai::Class4<mai::Class4::_#redirect#tearOff::T%>
    return new mai::Class4::_<mai::Class4::_#redirect#tearOff::T%>();
}
class Class5<T extends core::num> extends core::Object {
  constructor _() → mai::Class5<mai::Class5::T>
    : super core::Object::•()
    ;
  static method _#_#tearOff<T extends core::num>() → mai::Class5<mai::Class5::_#_#tearOff::T>
    return new mai::Class5::_<mai::Class5::_#_#tearOff::T>();
  static factory •<T extends core::num>() → mai::Class5<mai::Class5::•::T>
    return new mai::Class5::_<mai::Class5::•::T>();
  static method _#new#tearOff<T extends core::num>() → mai::Class5<mai::Class5::_#new#tearOff::T>
    return mai::Class5::•<mai::Class5::_#new#tearOff::T>();
}

constants  {
  #C1 = static-tearoff mai::Class1::_#new#tearOff
  #C2 = static-tearoff mai::Class2::_#named#tearOff
  #C3 = static-tearoff mai::Class2::_#redirect#tearOff
  #C4 = static-tearoff mai::Class3::_#new#tearOff
  #C5 = static-tearoff mai::Class4::_#new#tearOff
  #C6 = static-tearoff mai::Class4::_#redirect#tearOff
  #C7 = static-tearoff mai::Class5::_#new#tearOff
  #C8 = false
}