blob: 061794ab73c871b9d3a67d0a06cb2ffd553b1e4a [file] [log] [blame]
 // Copyright (c) 2016, 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. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. // GENERATED - DON'T EDIT. import 'dart:core'; import 'dart:core' as core; import 'package:expect/expect.dart'; @pragma('dart2js:noInline') @pragma('dart2js:assumeDynamic') confuse(f) => f; void _voidFunction() {} typedef F0 = Function Function({core.List x}); typedef F1 = core.List Function(int x, [List]); typedef F2 = Function(int, [Function]); typedef F3 = int Function(); typedef F4 = int Function({int x}) Function(int x); typedef F5 = int Function(core.List x) Function(int x); typedef F6 = Function Function(int, [int x]) Function(int x); typedef F7 = Function Function([List]) Function(int x); typedef F8 = Function Function({List x}) Function(int x); typedef F9 = List Function(int y, {Function x}) Function(int x); typedef F10 = List Function(int, [List x]) Function(int x); typedef F11 = core.List Function(Function) Function(int x); typedef F12 = core.List Function(int x, [core.List]) Function(int x); typedef F13 = List Function(int, {int x}) Function(int x); typedef F14 = List Function([core.List x]) Function(int x); typedef F15 = Function(int y, [int x]) Function(int x); typedef F16 = Function(int, [List]) Function(int x); typedef F17 = Function(int, {List x}) Function(int x); typedef F18 = void Function(List x) Function(int x); typedef F19 = void Function(int y, [List x]) Function(int x); typedef F20 = List Function(int x) Function(int x); typedef F21 = Function(Function x) Function(int x); typedef F22 = void Function(List x) Function(int x); Function f0({core.List x = const []}) => throw 'uncalled'; core.List f1(int x, [List x0 = const []]) => throw 'uncalled'; f2(int x0, [Function x1 = _voidFunction]) => throw 'uncalled'; int f3() => throw 'uncalled'; int Function({int x}) f4(int x) => throw 'uncalled'; int Function(core.List x) f5(int x) => throw 'uncalled'; Function Function(int, [int x]) f6(int x) => throw 'uncalled'; Function Function([List]) f7(int x) => throw 'uncalled'; Function Function({List x}) f8(int x) => throw 'uncalled'; List Function(int y, {Function x}) f9(int x) => throw 'uncalled'; List Function(int, [List x]) f10(int x) => throw 'uncalled'; core.List Function(Function) f11(int x) => throw 'uncalled'; core.List Function(int x, [core.List]) f12(int x) => throw 'uncalled'; List Function(int, {int x}) f13(int x) => throw 'uncalled'; List Function([core.List x]) f14(int x) => throw 'uncalled'; Function(int y, [int x]) f15(int x) => throw 'uncalled'; Function(int, [List]) f16(int x) => throw 'uncalled'; Function(int, {List x}) f17(int x) => throw 'uncalled'; void Function(List x) f18(int x) => throw 'uncalled'; void Function(int y, [List x]) f19(int x) => throw 'uncalled'; List Function(int x) f20(int x) => throw 'uncalled'; Function(Function x) f21(int x) => throw 'uncalled'; void Function(List x) f22(int x) => throw 'uncalled'; class U97 { final bool tIsBool; final bool tIsInt; final bool tIsDynamic; late Function Function({core.List x}) x0; late core.List Function(int x, [List]) x1; late Function(int, [Function]) x2; late int Function() x3; late int Function({int x}) Function(int x) x4; late int Function(core.List x) Function(int x) x5; late Function Function(int, [int x]) Function(int x) x6; late Function Function([List]) Function(int x) x7; late Function Function({List x}) Function(int x) x8; late List Function(int y, {Function x}) Function(int x) x9; late List Function(int, [List x]) Function(int x) x10; late core.List Function(Function) Function(int x) x11; late core.List Function(int x, [core.List]) Function( int x) x12; late List Function(int, {int x}) Function(int x) x13; late List Function([core.List x]) Function(int x) x14; late Function(int y, [int x]) Function(int x) x15; late Function(int, [List]) Function(int x) x16; late Function(int, {List x}) Function(int x) x17; late void Function(List x) Function(int x) x18; late void Function(int y, [List x]) Function(int x) x19; late List Function(int x) Function(int x) x20; late Function(Function x) Function(int x) x21; late void Function(List x) Function(int x) x22; U97({this.tIsBool: false, this.tIsInt: false}) : tIsDynamic = !tIsBool && !tIsInt; Function m0({core.List x = const []}) => throw 'uncalled'; core.List m1(int x, [List x0 = const []]) => throw 'uncalled'; m2(int x0, [Function x1 = _voidFunction]) => throw 'uncalled'; int m3() => throw 'uncalled'; int Function({int x}) m4(int x) => throw 'uncalled'; int Function(core.List x) m5(int x) => throw 'uncalled'; Function Function(int, [int x]) m6(int x) => throw 'uncalled'; Function Function([List]) m7(int x) => throw 'uncalled'; Function Function({List x}) m8(int x) => throw 'uncalled'; List Function(int y, {Function x}) m9(int x) => throw 'uncalled'; List Function(int, [List x]) m10(int x) => throw 'uncalled'; core.List Function(Function) m11(int x) => throw 'uncalled'; core.List Function(int x, [core.List]) m12(int x) => throw 'uncalled'; List Function(int, {int x}) m13(int x) => throw 'uncalled'; List Function([core.List x]) m14(int x) => throw 'uncalled'; Function(int y, [int x]) m15(int x) => throw 'uncalled'; Function(int, [List]) m16(int x) => throw 'uncalled'; Function(int, {List x}) m17(int x) => throw 'uncalled'; void Function(List x) m18(int x) => throw 'uncalled'; void Function(int y, [List x]) m19(int x) => throw 'uncalled'; List Function(int x) m20(int x) => throw 'uncalled'; Function(Function x) m21(int x) => throw 'uncalled'; void Function(List x) m22(int x) => throw 'uncalled'; runTests() { testF0(); testF1(); testF2(); testF3(); testF4(); testF5(); testF6(); testF7(); testF8(); testF9(); testF10(); testF11(); testF12(); testF13(); testF14(); testF15(); testF16(); testF17(); testF18(); testF19(); testF20(); testF21(); testF22(); } /// Function Function({core.List x}) void testF0() { Expect.isTrue(f0 is F0); Expect.isTrue(confuse(f0) is F0); // In checked mode, verifies the type. Function Function({core.List x}) l0; // The static function f0 sets `T` to `int`. if (tIsInt) { x0 = f0 as dynamic; l0 = f0 as dynamic; x0 = confuse(f0); l0 = confuse(f0); } Expect.isTrue(m0 is F0); Expect.isTrue(m0 is Function Function({core.List x})); Expect.isTrue(confuse(m0) is F0); // In checked mode, verifies the type. x0 = m0; l0 = m0; x0 = confuse(m0); l0 = confuse(m0); } /// core.List Function(int x, [List]) void testF1() { Expect.isTrue(f1 is F1); Expect.isTrue(confuse(f1) is F1); // In checked mode, verifies the type. core.List Function(int x, [List]) l1; // The static function f1 sets `T` to `int`. if (tIsInt) { x1 = f1 as dynamic; l1 = f1 as dynamic; x1 = confuse(f1); l1 = confuse(f1); } Expect.isTrue(m1 is F1); Expect.isTrue(m1 is core.List Function(int x, [List])); Expect.isTrue(confuse(m1) is F1); // In checked mode, verifies the type. x1 = m1; l1 = m1; x1 = confuse(m1); l1 = confuse(m1); } /// Function(int, [Function]) void testF2() { Expect.isTrue(f2 is F2); Expect.isTrue(confuse(f2) is F2); // In checked mode, verifies the type. Function(int, [Function]) l2; // The static function f2 sets `T` to `int`. if (tIsInt) { x2 = f2 as dynamic; l2 = f2 as dynamic; x2 = confuse(f2); l2 = confuse(f2); } Expect.isTrue(m2 is F2); Expect.isTrue(m2 is Function(int, [Function])); Expect.isTrue(confuse(m2) is F2); // In checked mode, verifies the type. x2 = m2; l2 = m2; x2 = confuse(m2); l2 = confuse(m2); } /// int Function() void testF3() { Expect.isTrue(f3 is F3); Expect.isTrue(confuse(f3) is F3); // In checked mode, verifies the type. int Function() l3; // The static function f3 sets `T` to `int`. if (tIsInt) { x3 = f3 as dynamic; l3 = f3 as dynamic; x3 = confuse(f3); l3 = confuse(f3); } Expect.isTrue(m3 is F3); Expect.isTrue(m3 is int Function()); Expect.isTrue(confuse(m3) is F3); // In checked mode, verifies the type. x3 = m3; l3 = m3; x3 = confuse(m3); l3 = confuse(m3); } /// int Function({int x}) Function(int x) void testF4() { Expect.isTrue(f4 is F4); Expect.isTrue(confuse(f4) is F4); // In checked mode, verifies the type. int Function({int x}) Function(int x) l4; // The static function f4 sets `T` to `int`. if (tIsInt) { x4 = f4 as dynamic; l4 = f4 as dynamic; x4 = confuse(f4); l4 = confuse(f4); } Expect.isTrue(m4 is F4); Expect.isTrue(m4 is int Function({int x}) Function(int x)); Expect.isTrue(confuse(m4) is F4); // In checked mode, verifies the type. x4 = m4; l4 = m4; x4 = confuse(m4); l4 = confuse(m4); } /// int Function(core.List x) Function(int x) void testF5() { Expect.isTrue(f5 is F5); Expect.isTrue(confuse(f5) is F5); // In checked mode, verifies the type. int Function(core.List x) Function(int x) l5; // The static function f5 sets `T` to `int`. if (tIsInt) { x5 = f5 as dynamic; l5 = f5 as dynamic; x5 = confuse(f5); l5 = confuse(f5); } Expect.isTrue(m5 is F5); Expect.isTrue(m5 is int Function(core.List x) Function(int x)); Expect.isTrue(confuse(m5) is F5); // In checked mode, verifies the type. x5 = m5; l5 = m5; x5 = confuse(m5); l5 = confuse(m5); } /// Function Function(int, [int x]) Function(int x) void testF6() { Expect.isTrue(f6 is F6); Expect.isTrue(confuse(f6) is F6); // In checked mode, verifies the type. Function Function(int, [int x]) Function(int x) l6; // The static function f6 sets `T` to `int`. if (tIsInt) { x6 = f6 as dynamic; l6 = f6 as dynamic; x6 = confuse(f6); l6 = confuse(f6); } Expect.isTrue(m6 is F6); Expect.isTrue(m6 is Function Function(int, [int x]) Function(int x)); Expect.isTrue(confuse(m6) is F6); // In checked mode, verifies the type. x6 = m6; l6 = m6; x6 = confuse(m6); l6 = confuse(m6); } /// Function Function([List]) Function(int x) void testF7() { Expect.isTrue(f7 is F7); Expect.isTrue(confuse(f7) is F7); // In checked mode, verifies the type. Function Function([List]) Function(int x) l7; // The static function f7 sets `T` to `int`. if (tIsInt) { x7 = f7 as dynamic; l7 = f7 as dynamic; x7 = confuse(f7); l7 = confuse(f7); } Expect.isTrue(m7 is F7); Expect.isTrue(m7 is Function Function([List]) Function(int x)); Expect.isTrue(confuse(m7) is F7); // In checked mode, verifies the type. x7 = m7; l7 = m7; x7 = confuse(m7); l7 = confuse(m7); } /// Function Function({List x}) Function(int x) void testF8() { Expect.isTrue(f8 is F8); Expect.isTrue(confuse(f8) is F8); // In checked mode, verifies the type. Function Function({List x}) Function(int x) l8; // The static function f8 sets `T` to `int`. if (tIsInt) { x8 = f8 as dynamic; l8 = f8 as dynamic; x8 = confuse(f8); l8 = confuse(f8); } Expect.isTrue(m8 is F8); Expect.isTrue(m8 is Function Function({List x}) Function(int x)); Expect.isTrue(confuse(m8) is F8); // In checked mode, verifies the type. x8 = m8; l8 = m8; x8 = confuse(m8); l8 = confuse(m8); // The static function has its T always set to int. Expect.isTrue(f8 is F8); Expect.isFalse(f8 is F8); Expect.isTrue(confuse(f8) is F8); Expect.isFalse(confuse(f8) is F8); if (tIsBool) { Expect.throws(() { x8 = (f8 as dynamic); }); Expect.throws(() { x8 = confuse(f8); }); Expect.throws(() { l8 = (f8 as dynamic); }); Expect.throws(() { l8 = confuse(f8); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m8 is F8); Expect.equals(tIsBool, m8 is F8); Expect.equals(tIsInt, confuse(m8) is F8); Expect.equals(tIsBool, confuse(m8) is F8); } } /// List Function(int y, {Function x}) Function(int x) void testF9() { Expect.isTrue(f9 is F9); Expect.isTrue(confuse(f9) is F9); // In checked mode, verifies the type. List Function(int y, {Function x}) Function(int x) l9; // The static function f9 sets `T` to `int`. if (tIsInt) { x9 = f9 as dynamic; l9 = f9 as dynamic; x9 = confuse(f9); l9 = confuse(f9); } Expect.isTrue(m9 is F9); Expect.isTrue( m9 is List Function(int y, {Function x}) Function(int x)); Expect.isTrue(confuse(m9) is F9); // In checked mode, verifies the type. x9 = m9; l9 = m9; x9 = confuse(m9); l9 = confuse(m9); } /// List Function(int, [List x]) Function(int x) void testF10() { Expect.isTrue(f10 is F10); Expect.isTrue(confuse(f10) is F10); // In checked mode, verifies the type. List Function(int, [List x]) Function(int x) l10; // The static function f10 sets `T` to `int`. if (tIsInt) { x10 = f10 as dynamic; l10 = f10 as dynamic; x10 = confuse(f10); l10 = confuse(f10); } Expect.isTrue(m10 is F10); Expect.isTrue( m10 is List Function(int, [List x]) Function(int x)); Expect.isTrue(confuse(m10) is F10); // In checked mode, verifies the type. x10 = m10; l10 = m10; x10 = confuse(m10); l10 = confuse(m10); // The static function has its T always set to int. Expect.isTrue(f10 is F10); Expect.isFalse(f10 is F10); Expect.isTrue(confuse(f10) is F10); Expect.isFalse(confuse(f10) is F10); if (tIsBool) { Expect.throws(() { x10 = (f10 as dynamic); }); Expect.throws(() { x10 = confuse(f10); }); Expect.throws(() { l10 = (f10 as dynamic); }); Expect.throws(() { l10 = confuse(f10); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m10 is F10); Expect.equals(tIsBool, m10 is F10); Expect.equals(tIsInt, confuse(m10) is F10); Expect.equals(tIsBool, confuse(m10) is F10); } } /// core.List Function(Function) Function(int x) void testF11() { Expect.isTrue(f11 is F11); Expect.isTrue(confuse(f11) is F11); // In checked mode, verifies the type. core.List Function(Function) Function(int x) l11; // The static function f11 sets `T` to `int`. if (tIsInt) { x11 = f11 as dynamic; l11 = f11 as dynamic; x11 = confuse(f11); l11 = confuse(f11); } Expect.isTrue(m11 is F11); Expect.isTrue( m11 is core.List Function(Function) Function(int x)); Expect.isTrue(confuse(m11) is F11); // In checked mode, verifies the type. x11 = m11; l11 = m11; x11 = confuse(m11); l11 = confuse(m11); } /// core.List Function(int x, [core.List]) Function(int x) void testF12() { Expect.isTrue(f12 is F12); Expect.isTrue(confuse(f12) is F12); // In checked mode, verifies the type. core.List Function(int x, [core.List]) Function(int x) l12; // The static function f12 sets `T` to `int`. if (tIsInt) { x12 = f12 as dynamic; l12 = f12 as dynamic; x12 = confuse(f12); l12 = confuse(f12); } Expect.isTrue(m12 is F12); Expect.isTrue(m12 is core.List Function(int x, [core.List]) Function(int x)); Expect.isTrue(confuse(m12) is F12); // In checked mode, verifies the type. x12 = m12; l12 = m12; x12 = confuse(m12); l12 = confuse(m12); } /// List Function(int, {int x}) Function(int x) void testF13() { Expect.isTrue(f13 is F13); Expect.isTrue(confuse(f13) is F13); // In checked mode, verifies the type. List Function(int, {int x}) Function(int x) l13; // The static function f13 sets `T` to `int`. if (tIsInt) { x13 = f13 as dynamic; l13 = f13 as dynamic; x13 = confuse(f13); l13 = confuse(f13); } Expect.isTrue(m13 is F13); Expect.isTrue(m13 is List Function(int, {int x}) Function(int x)); Expect.isTrue(confuse(m13) is F13); // In checked mode, verifies the type. x13 = m13; l13 = m13; x13 = confuse(m13); l13 = confuse(m13); // The static function has its T always set to int. Expect.isTrue(f13 is F13); Expect.isFalse(f13 is F13); Expect.isTrue(confuse(f13) is F13); Expect.isFalse(confuse(f13) is F13); if (tIsBool) { Expect.throws(() { x13 = (f13 as dynamic); }); Expect.throws(() { x13 = confuse(f13); }); Expect.throws(() { l13 = (f13 as dynamic); }); Expect.throws(() { l13 = confuse(f13); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m13 is F13); Expect.equals(tIsBool, m13 is F13); Expect.equals(tIsInt, confuse(m13) is F13); Expect.equals(tIsBool, confuse(m13) is F13); } } /// List Function([core.List x]) Function(int x) void testF14() { Expect.isTrue(f14 is F14); Expect.isTrue(confuse(f14) is F14); // In checked mode, verifies the type. List Function([core.List x]) Function(int x) l14; // The static function f14 sets `T` to `int`. if (tIsInt) { x14 = f14 as dynamic; l14 = f14 as dynamic; x14 = confuse(f14); l14 = confuse(f14); } Expect.isTrue(m14 is F14); Expect.isTrue( m14 is List Function([core.List x]) Function(int x)); Expect.isTrue(confuse(m14) is F14); // In checked mode, verifies the type. x14 = m14; l14 = m14; x14 = confuse(m14); l14 = confuse(m14); // The static function has its T always set to int. Expect.isTrue(f14 is F14); Expect.isFalse(f14 is F14); Expect.isTrue(confuse(f14) is F14); Expect.isFalse(confuse(f14) is F14); if (tIsBool) { Expect.throws(() { x14 = (f14 as dynamic); }); Expect.throws(() { x14 = confuse(f14); }); Expect.throws(() { l14 = (f14 as dynamic); }); Expect.throws(() { l14 = confuse(f14); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m14 is F14); Expect.equals(tIsBool, m14 is F14); Expect.equals(tIsInt, confuse(m14) is F14); Expect.equals(tIsBool, confuse(m14) is F14); } } /// Function(int y, [int x]) Function(int x) void testF15() { Expect.isTrue(f15 is F15); Expect.isTrue(confuse(f15) is F15); // In checked mode, verifies the type. Function(int y, [int x]) Function(int x) l15; // The static function f15 sets `T` to `int`. if (tIsInt) { x15 = f15 as dynamic; l15 = f15 as dynamic; x15 = confuse(f15); l15 = confuse(f15); } Expect.isTrue(m15 is F15); Expect.isTrue(m15 is Function(int y, [int x]) Function(int x)); Expect.isTrue(confuse(m15) is F15); // In checked mode, verifies the type. x15 = m15; l15 = m15; x15 = confuse(m15); l15 = confuse(m15); } /// Function(int, [List]) Function(int x) void testF16() { Expect.isTrue(f16 is F16); Expect.isTrue(confuse(f16) is F16); // In checked mode, verifies the type. Function(int, [List]) Function(int x) l16; // The static function f16 sets `T` to `int`. if (tIsInt) { x16 = f16 as dynamic; l16 = f16 as dynamic; x16 = confuse(f16); l16 = confuse(f16); } Expect.isTrue(m16 is F16); Expect.isTrue(m16 is Function(int, [List]) Function(int x)); Expect.isTrue(confuse(m16) is F16); // In checked mode, verifies the type. x16 = m16; l16 = m16; x16 = confuse(m16); l16 = confuse(m16); } /// Function(int, {List x}) Function(int x) void testF17() { Expect.isTrue(f17 is F17); Expect.isTrue(confuse(f17) is F17); // In checked mode, verifies the type. Function(int, {List x}) Function(int x) l17; // The static function f17 sets `T` to `int`. if (tIsInt) { x17 = f17 as dynamic; l17 = f17 as dynamic; x17 = confuse(f17); l17 = confuse(f17); } Expect.isTrue(m17 is F17); Expect.isTrue(m17 is Function(int, {List x}) Function(int x)); Expect.isTrue(confuse(m17) is F17); // In checked mode, verifies the type. x17 = m17; l17 = m17; x17 = confuse(m17); l17 = confuse(m17); // The static function has its T always set to int. Expect.isTrue(f17 is F17); Expect.isFalse(f17 is F17); Expect.isTrue(confuse(f17) is F17); Expect.isFalse(confuse(f17) is F17); if (tIsBool) { Expect.throws(() { x17 = (f17 as dynamic); }); Expect.throws(() { x17 = confuse(f17); }); Expect.throws(() { l17 = (f17 as dynamic); }); Expect.throws(() { l17 = confuse(f17); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m17 is F17); Expect.equals(tIsBool, m17 is F17); Expect.equals(tIsInt, confuse(m17) is F17); Expect.equals(tIsBool, confuse(m17) is F17); } } /// void Function(List x) Function(int x) void testF18() { Expect.isTrue(f18 is F18); Expect.isTrue(confuse(f18) is F18); // In checked mode, verifies the type. void Function(List x) Function(int x) l18; // The static function f18 sets `T` to `int`. if (tIsInt) { x18 = f18 as dynamic; l18 = f18 as dynamic; x18 = confuse(f18); l18 = confuse(f18); } Expect.isTrue(m18 is F18); Expect.isTrue(m18 is void Function(List x) Function(int x)); Expect.isTrue(confuse(m18) is F18); // In checked mode, verifies the type. x18 = m18; l18 = m18; x18 = confuse(m18); l18 = confuse(m18); } /// void Function(int y, [List x]) Function(int x) void testF19() { Expect.isTrue(f19 is F19); Expect.isTrue(confuse(f19) is F19); // In checked mode, verifies the type. void Function(int y, [List x]) Function(int x) l19; // The static function f19 sets `T` to `int`. if (tIsInt) { x19 = f19 as dynamic; l19 = f19 as dynamic; x19 = confuse(f19); l19 = confuse(f19); } Expect.isTrue(m19 is F19); Expect.isTrue(m19 is void Function(int y, [List x]) Function(int x)); Expect.isTrue(confuse(m19) is F19); // In checked mode, verifies the type. x19 = m19; l19 = m19; x19 = confuse(m19); l19 = confuse(m19); // The static function has its T always set to int. Expect.isTrue(f19 is F19); Expect.isFalse(f19 is F19); Expect.isTrue(confuse(f19) is F19); Expect.isFalse(confuse(f19) is F19); if (tIsBool) { Expect.throws(() { x19 = (f19 as dynamic); }); Expect.throws(() { x19 = confuse(f19); }); Expect.throws(() { l19 = (f19 as dynamic); }); Expect.throws(() { l19 = confuse(f19); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m19 is F19); Expect.equals(tIsBool, m19 is F19); Expect.equals(tIsInt, confuse(m19) is F19); Expect.equals(tIsBool, confuse(m19) is F19); } } /// List Function(int x) Function(int x) void testF20() { Expect.isTrue(f20 is F20); Expect.isTrue(confuse(f20) is F20); // In checked mode, verifies the type. List Function(int x) Function(int x) l20; // The static function f20 sets `T` to `int`. if (tIsInt) { x20 = f20 as dynamic; l20 = f20 as dynamic; x20 = confuse(f20); l20 = confuse(f20); } Expect.isTrue(m20 is F20); Expect.isTrue(m20 is List Function(int x) Function(int x)); Expect.isTrue(confuse(m20) is F20); // In checked mode, verifies the type. x20 = m20; l20 = m20; x20 = confuse(m20); l20 = confuse(m20); } /// Function(Function x) Function(int x) void testF21() { Expect.isTrue(f21 is F21); Expect.isTrue(confuse(f21) is F21); // In checked mode, verifies the type. Function(Function x) Function(int x) l21; // The static function f21 sets `T` to `int`. if (tIsInt) { x21 = f21 as dynamic; l21 = f21 as dynamic; x21 = confuse(f21); l21 = confuse(f21); } Expect.isTrue(m21 is F21); Expect.isTrue(m21 is Function(Function x) Function(int x)); Expect.isTrue(confuse(m21) is F21); // In checked mode, verifies the type. x21 = m21; l21 = m21; x21 = confuse(m21); l21 = confuse(m21); } /// void Function(List x) Function(int x) void testF22() { Expect.isTrue(f22 is F22); Expect.isTrue(confuse(f22) is F22); // In checked mode, verifies the type. void Function(List x) Function(int x) l22; // The static function f22 sets `T` to `int`. if (tIsInt) { x22 = f22 as dynamic; l22 = f22 as dynamic; x22 = confuse(f22); l22 = confuse(f22); } Expect.isTrue(m22 is F22); Expect.isTrue(m22 is void Function(List x) Function(int x)); Expect.isTrue(confuse(m22) is F22); // In checked mode, verifies the type. x22 = m22; l22 = m22; x22 = confuse(m22); l22 = confuse(m22); } } void main() { new U97().runTests(); new U97(tIsInt: true).runTests(); new U97(tIsBool: true).runTests(); }