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