blob: ae7be562b94d0a0e5c87d6c92e2e1ff4d99681a0 [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'; @NoInline() @AssumeDynamic() confuse(f) => f; typedef F0 = int Function(int x0, {int x}); typedef F1 = Function Function(int x0, {List x}); typedef F2 = core.List Function({core.List x}); typedef F3 = Function(int x, [List x2]); typedef F4 = List Function(Function x); typedef F5 = int Function(Function x) Function(int x); typedef F6 = int Function(int y, [core.List x]) Function(int x); typedef F7 = Function Function([int x1]) Function(int x); typedef F8 = Function Function({List x}) Function(int x); typedef F9 = Function Function() Function(int x); typedef F10 = List Function(int x1, [List x]) Function( int x); typedef F11 = List Function([List x1]) Function(int x); typedef F12 = core.List Function(int x, [Function x1]) Function( int x); typedef F13 = core.List Function(int y, {core.List x}) Function(int x); typedef F14 = List Function([Function x]) Function(int x); typedef F15 = List Function(core.List x1) Function(int x); typedef F16 = Function(int x2, [int x3]) Function(int x); typedef F17 = Function(int x1, {List x}) Function(int x); typedef F18 = void Function(int x) Function(int x); typedef F19 = void Function(int y, [List x]) Function(int x); typedef F20 = void Function(int x2, [List x3]) Function(int x); typedef F21 = List Function(core.List x) Function( int x); typedef F22 = Function(List x) Function(int x); typedef F23 = void Function() Function(int x); int f0(int x0, {int x}) => null; Function f1(int x0, {List x}) => null; core.List f2({core.List x}) => null; f3(int x, [List x0]) => null; List f4(Function x) => null; int Function(Function x) f5(int x) => null; int Function(int y, [core.List x]) f6(int x) => null; Function Function([int x0]) f7(int x) => null; Function Function({List x}) f8(int x) => null; Function Function() f9(int x) => null; List Function(int x0, [List x]) f10(int x) => null; List Function([List x0]) f11(int x) => null; core.List Function(int x, [Function x0]) f12(int x) => null; core.List Function(int y, {core.List x}) f13(int x) => null; List Function([Function x]) f14(int x) => null; List Function(core.List x0) f15(int x) => null; Function(int x0, [int x1]) f16(int x) => null; Function(int x0, {List x}) f17(int x) => null; void Function(int x) f18(int x) => null; void Function(int y, [List x]) f19(int x) => null; void Function(int x0, [List x1]) f20(int x) => null; List Function(core.List x) f21(int x) => null; Function(List x) f22(int x) => null; void Function() f23(int x) => null; class U9 { final bool tIsBool; final bool tIsInt; final bool tIsDynamic; int Function(int x0, {int x}) x0; Function Function(int x0, {List x}) x1; core.List Function({core.List x}) x2; Function(int x, [List x2]) x3; List Function(Function x) x4; int Function(Function x) Function(int x) x5; int Function(int y, [core.List x]) Function(int x) x6; Function Function([int x1]) Function(int x) x7; Function Function({List x}) Function(int x) x8; Function Function() Function(int x) x9; List Function(int x1, [List x]) Function(int x) x10; List Function([List x1]) Function(int x) x11; core.List Function(int x, [Function x1]) Function(int x) x12; core.List Function(int y, {core.List x}) Function(int x) x13; List Function([Function x]) Function(int x) x14; List Function(core.List x1) Function(int x) x15; Function(int x2, [int x3]) Function(int x) x16; Function(int x1, {List x}) Function(int x) x17; void Function(int x) Function(int x) x18; void Function(int y, [List x]) Function(int x) x19; void Function(int x2, [List x3]) Function(int x) x20; List Function(core.List x) Function(int x) x21; Function(List x) Function(int x) x22; void Function() Function(int x) x23; U9({this.tIsBool: false, this.tIsInt: false}) : tIsDynamic = !tIsBool && !tIsInt; int m0(int x0, {int x}) => null; Function m1(int x0, {List x}) => null; core.List m2({core.List x}) => null; m3(int x, [List x0]) => null; List m4(Function x) => null; int Function(Function x) m5(int x) => null; int Function(int y, [core.List x]) m6(int x) => null; Function Function([int x0]) m7(int x) => null; Function Function({List x}) m8(int x) => null; Function Function() m9(int x) => null; List Function(int x0, [List x]) m10(int x) => null; List Function([List x0]) m11(int x) => null; core.List Function(int x, [Function x0]) m12(int x) => null; core.List Function(int y, {core.List x}) m13(int x) => null; List Function([Function x]) m14(int x) => null; List Function(core.List x0) m15(int x) => null; Function(int x0, [int x1]) m16(int x) => null; Function(int x0, {List x}) m17(int x) => null; void Function(int x) m18(int x) => null; void Function(int y, [List x]) m19(int x) => null; void Function(int x0, [List x1]) m20(int x) => null; List Function(core.List x) m21(int x) => null; Function(List x) m22(int x) => null; void Function() m23(int x) => null; runTests() { testF0(); testF1(); testF2(); testF3(); testF4(); testF5(); testF6(); testF7(); testF8(); testF9(); testF10(); testF11(); testF12(); testF13(); testF14(); testF15(); testF16(); testF17(); testF18(); testF19(); testF20(); testF21(); testF22(); testF23(); } /// int Function(int x0, {int x}) void testF0() { Expect.isTrue(f0 is F0); Expect.isTrue(confuse(f0) is F0); // In checked mode, verifies the type. int Function(int x0, {int 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 int Function(int x0, {int x})); Expect.isTrue(confuse(m0) is F0); // In checked mode, verifies the type. x0 = m0; l0 = m0; x0 = confuse(m0); l0 = confuse(m0); } /// Function Function(int x0, {List x}) void testF1() { Expect.isTrue(f1 is F1); Expect.isTrue(confuse(f1) is F1); // In checked mode, verifies the type. Function Function(int x0, {List x}) 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 Function Function(int x0, {List x})); Expect.isTrue(confuse(m1) is F1); // In checked mode, verifies the type. x1 = m1; l1 = m1; x1 = confuse(m1); l1 = confuse(m1); // The static function has its T always set to int. Expect.isTrue(f1 is F1); Expect.isFalse(f1 is F1); Expect.isTrue(confuse(f1) is F1); Expect.isFalse(confuse(f1) is F1); if (tIsBool) { Expect.throws(() { x1 = (f1 as dynamic); }); Expect.throws(() { x1 = confuse(f1); }); Expect.throws(() { l1 = (f1 as dynamic); }); Expect.throws(() { l1 = confuse(f1); }); } if (tIsInt || tIsBool) { Expect.equals(true, m1 is F1); Expect.equals(true, m1 is F1); Expect.equals(true, confuse(m1) is F1); Expect.equals(true, confuse(m1) is F1); } } /// core.List Function({core.List x}) void testF2() { Expect.isTrue(f2 is F2); Expect.isTrue(confuse(f2) is F2); // In checked mode, verifies the type. core.List Function({core.List x}) 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 core.List Function({core.List x})); Expect.isTrue(confuse(m2) is F2); // In checked mode, verifies the type. x2 = m2; l2 = m2; x2 = confuse(m2); l2 = confuse(m2); } /// Function(int x, [List x2]) void testF3() { Expect.isTrue(f3 is F3); Expect.isTrue(confuse(f3) is F3); // In checked mode, verifies the type. Function(int x, [List x2]) 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 Function(int x, [List x2])); Expect.isTrue(confuse(m3) is F3); // In checked mode, verifies the type. x3 = m3; l3 = m3; x3 = confuse(m3); l3 = confuse(m3); } /// List Function(Function x) void testF4() { Expect.isTrue(f4 is F4); Expect.isTrue(confuse(f4) is F4); // In checked mode, verifies the type. List Function(Function 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 List Function(Function 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(Function 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(Function 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(Function 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); } /// int Function(int y, [core.List x]) Function(int x) void testF6() { Expect.isTrue(f6 is F6); Expect.isTrue(confuse(f6) is F6); // In checked mode, verifies the type. int Function(int y, [core.List 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 int Function(int y, [core.List 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([int x1]) Function(int x) void testF7() { Expect.isTrue(f7 is F7); Expect.isTrue(confuse(f7) is F7); // In checked mode, verifies the type. Function Function([int x1]) 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([int x1]) 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); } /// Function Function() Function(int x) void testF9() { Expect.isTrue(f9 is F9); Expect.isTrue(confuse(f9) is F9); // In checked mode, verifies the type. Function Function() 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 Function Function() 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 x1, [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 x1, [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 x1, [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); } /// List Function([List x1]) Function(int x) void testF11() { Expect.isTrue(f11 is F11); Expect.isTrue(confuse(f11) is F11); // In checked mode, verifies the type. List Function([List x1]) 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 List Function([List x1]) 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); // The static function has its T always set to int. Expect.isTrue(f11 is F11); Expect.isFalse(f11 is F11); Expect.isTrue(confuse(f11) is F11); Expect.isFalse(confuse(f11) is F11); if (tIsBool) { Expect.throws(() { x11 = (f11 as dynamic); }); Expect.throws(() { x11 = confuse(f11); }); Expect.throws(() { l11 = (f11 as dynamic); }); Expect.throws(() { l11 = confuse(f11); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m11 is F11); Expect.equals(tIsBool, m11 is F11); Expect.equals(tIsInt, confuse(m11) is F11); Expect.equals(tIsBool, confuse(m11) is F11); } } /// core.List Function(int x, [Function x1]) 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, [Function x1]) 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, [Function x1]) 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); } /// core.List Function(int y, {core.List x}) Function(int x) void testF13() { Expect.isTrue(f13 is F13); Expect.isTrue(confuse(f13) is F13); // In checked mode, verifies the type. core.List Function(int y, {core.List 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 core.List Function(int y, {core.List 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); } /// List Function([Function 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([Function 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([Function 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); } } /// List Function(core.List x1) Function(int x) void testF15() { Expect.isTrue(f15 is F15); Expect.isTrue(confuse(f15) is F15); // In checked mode, verifies the type. List Function(core.List x1) 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 List Function(core.List x1) 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); // The static function has its T always set to int. Expect.isTrue(f15 is F15); Expect.isFalse(f15 is F15); Expect.isTrue(confuse(f15) is F15); Expect.isFalse(confuse(f15) is F15); if (tIsBool) { Expect.throws(() { x15 = (f15 as dynamic); }); Expect.throws(() { x15 = confuse(f15); }); Expect.throws(() { l15 = (f15 as dynamic); }); Expect.throws(() { l15 = confuse(f15); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m15 is F15); Expect.equals(tIsBool, m15 is F15); Expect.equals(tIsInt, confuse(m15) is F15); Expect.equals(tIsBool, confuse(m15) is F15); } } /// Function(int x2, [int x3]) Function(int x) void testF16() { Expect.isTrue(f16 is F16); Expect.isTrue(confuse(f16) is F16); // In checked mode, verifies the type. Function(int x2, [int x3]) 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 x2, [int x3]) 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 x1, {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 x1, {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 x1, {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); } /// void Function(int 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(int 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(int 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); } /// void Function(int x2, [List x3]) Function(int x) void testF20() { Expect.isTrue(f20 is F20); Expect.isTrue(confuse(f20) is F20); // In checked mode, verifies the type. void Function(int x2, [List x3]) 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 void Function(int x2, [List x3]) 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); // The static function has its T always set to int. Expect.isTrue(f20 is F20); Expect.isFalse(f20 is F20); Expect.isTrue(confuse(f20) is F20); Expect.isFalse(confuse(f20) is F20); if (tIsBool) { Expect.throws(() { x20 = (f20 as dynamic); }); Expect.throws(() { x20 = confuse(f20); }); Expect.throws(() { l20 = (f20 as dynamic); }); Expect.throws(() { l20 = confuse(f20); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m20 is F20); Expect.equals(tIsBool, m20 is F20); Expect.equals(tIsInt, confuse(m20) is F20); Expect.equals(tIsBool, confuse(m20) is F20); } } /// List Function(core.List x) Function(int x) void testF21() { Expect.isTrue(f21 is F21); Expect.isTrue(confuse(f21) is F21); // In checked mode, verifies the type. List Function(core.List 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 List Function(core.List 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); } /// 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. 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 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); // The static function has its T always set to int. Expect.isTrue(f22 is F22); Expect.isFalse(f22 is F22); Expect.isTrue(confuse(f22) is F22); Expect.isFalse(confuse(f22) is F22); if (tIsBool) { Expect.throws(() { x22 = (f22 as dynamic); }); Expect.throws(() { x22 = confuse(f22); }); Expect.throws(() { l22 = (f22 as dynamic); }); Expect.throws(() { l22 = confuse(f22); }); } if (tIsInt || tIsBool) { Expect.equals(tIsInt, m22 is F22); Expect.equals(tIsBool, m22 is F22); Expect.equals(tIsInt, confuse(m22) is F22); Expect.equals(tIsBool, confuse(m22) is F22); } } /// void Function() Function(int x) void testF23() { Expect.isTrue(f23 is F23); Expect.isTrue(confuse(f23) is F23); // In checked mode, verifies the type. void Function() Function(int x) l23; // The static function f23 sets `T` to `int`. if (tIsInt) { x23 = f23 as dynamic; l23 = f23 as dynamic; x23 = confuse(f23); l23 = confuse(f23); } Expect.isTrue(m23 is F23); Expect.isTrue(m23 is void Function() Function(int x)); Expect.isTrue(confuse(m23) is F23); // In checked mode, verifies the type. x23 = m23; l23 = m23; x23 = confuse(m23); l23 = confuse(m23); } } void main() { new U9().runTests(); new U9(tIsInt: true).runTests(); new U9(tIsBool: true).runTests(); }