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