Version 1.22.0-dev.8.0
Merge f0fcb8129251f8291286ca3e20695143017c35f3 into dev
diff --git a/BUILD.gn b/BUILD.gn
index 7b7946c..60a0dbd 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -54,22 +54,6 @@
]
}
-group("runtime_and_noopt") {
- if (defined(is_fuchsia) && (is_fuchsia || is_fuchsia_host)) {
- testonly = true
- }
- deps = [
- "runtime/bin:dart",
- "runtime/bin:dart_bootstrap($host_toolchain)",
- "runtime/bin:dart_noopt",
- "runtime/bin:process_test",
- "runtime/bin:run_vm_tests",
- "runtime/bin:sample_extension",
- "runtime/bin:test_extension",
- "runtime/vm:patched_sdk",
- ]
-}
-
action("create_sdk") {
deps = [
"runtime/bin:dart",
@@ -86,7 +70,10 @@
]
sdk_lib_files = exec_script("tools/list_dart_files.py",
- [ "absolute", rebase_path("sdk/lib") ],
+ [
+ "absolute",
+ rebase_path("sdk/lib"),
+ ],
"list lines")
preamble_files =
@@ -106,8 +93,7 @@
],
"list lines")
- inputs = sdk_lib_files + preamble_files + sdk_bin_files +
- [
+ inputs = sdk_lib_files + preamble_files + sdk_bin_files + [
"sdk/lib/dart_client.platform",
"sdk/lib/dart_server.platform",
"sdk/lib/dart_shared.platform",
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13b2450..04f6877 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,7 +22,7 @@
```
Unhandled exception:
- 'file:///Users/mit/tmp/tool/bin/main.dart': Failed assertion: line 9 pos 10:
+ 'file:///Users/mit/tmp/tool/bin/main.dart': Failed assertion: line 9 pos 10:
'configFile != null': Tool config missing. Please see https://goo.gl/k8iAi for details.
#0 _AssertionError._doThrowNew (dart:core-patch/errors_patch.dart:33)
#1 _AssertionError._throwNew (dart:core-patch/errors_patch.dart:29)
@@ -43,7 +43,7 @@
globally-activated executables to consistently use the
`Isolate.resolvePackageUri()` API.
- * On POSIX systems, always ignore packages' original file owners and
+ * On Linux systems, always ignore packages' original file owners and
permissions when extracting those packages. This was already the default
under most circumstances.
@@ -54,6 +54,8 @@
pubspec can't be parsed will now be ignored by `pub get --offline` and
deleted by `pub cache repair`.
+ * Make `pub run` run executables in spawned isolates. This lets them handle
+ signals and use standard IO reliably.
## 1.21.0 - 2016-12-07
diff --git a/DEPS b/DEPS
index c896280..caf046e 100644
--- a/DEPS
+++ b/DEPS
@@ -92,7 +92,7 @@
"ply_rev": "@604b32590ffad5cbb82e4afef1d305512d06ae93",
"pool_tag": "@1.2.4",
"protobuf_tag": "@0.5.3",
- "pub_rev": "@d7649be15213c43669a40c33af516d8eb210e876",
+ "pub_rev": "@9000daf329445d06e2404d4bb9020cf742b7308a",
"pub_semver_tag": "@1.3.0",
"quiver_tag": "@0.22.0",
"resource_rev":"@a49101ba2deb29c728acba6fb86000a8f730f4b1",
diff --git a/dart.gyp b/dart.gyp
index 5e1508d..70fd7162 100644
--- a/dart.gyp
+++ b/dart.gyp
@@ -46,23 +46,6 @@
'runtime/dart-runtime.gyp:generate_patched_sdk#host',
],
},
- {
- # This is the target that is built on the VM build bots. It
- # must depend on anything that is required by the VM test
- # suites.
- 'target_name': 'runtime_and_noopt',
- 'type': 'none',
- 'dependencies': [
- 'runtime/dart-runtime.gyp:dart',
- 'runtime/dart-runtime.gyp:dart_noopt',
- 'runtime/dart-runtime.gyp:dart_bootstrap#host',
- 'runtime/dart-runtime.gyp:run_vm_tests',
- 'runtime/dart-runtime.gyp:process_test',
- 'runtime/dart-runtime.gyp:test_extension',
- 'runtime/dart-runtime.gyp:sample_extension',
- 'runtime/dart-runtime.gyp:generate_patched_sdk#host',
- ],
- },
{
'target_name': 'create_sdk',
diff --git a/pkg/analysis_server/lib/src/status/get_handler.dart b/pkg/analysis_server/lib/src/status/get_handler.dart
index 17d6229..087b658 100644
--- a/pkg/analysis_server/lib/src/status/get_handler.dart
+++ b/pkg/analysis_server/lib/src/status/get_handler.dart
@@ -552,6 +552,7 @@
results.add(LINTS);
results.add(INFERABLE_STATIC_VARIABLES_IN_UNIT);
results.add(LIBRARY_UNIT_ERRORS);
+ results.add(RESOLVE_DIRECTIVES_ERRORS);
results.add(RESOLVE_TYPE_NAMES_ERRORS);
results.add(RESOLVE_TYPE_BOUNDS_ERRORS);
results.add(RESOLVE_UNIT_ERRORS);
diff --git a/pkg/analysis_server/test/completion_test.dart b/pkg/analysis_server/test/completion_test.dart
index 93483ce..46a33fc 100644
--- a/pkg/analysis_server/test/completion_test.dart
+++ b/pkg/analysis_server/test/completion_test.dart
@@ -867,13 +867,6 @@
failingTests: '1');
buildTests(
- 'testCommentSnippets084',
- '''
-class List{}class Map{}typedef X = !1Lis!2t with !3Ma!4p;''',
- <String>["1+Map", "2+List", "2-Map", "3+List", "4+Map", "4-List"],
- failingTests: '1234');
-
- buildTests(
'testCommentSnippets085',
'''
class List{}class Map{}class Z extends List with !1Ma!2p {}''',
@@ -2436,10 +2429,8 @@
'''
!1class Aclass {}
class Bclass !2extends!3 !4Aclass {}
-!5typedef Ctype = !6Bclass with !7Aclass;
-class Dclass extends !8Ctype {}
-!9abstract class Eclass implements Dclass,!C Ctype, Bclass {}
-class Fclass extends Bclass !Awith !B Eclass {}''',
+!5abstract class Eclass implements Aclass, Bclass {}
+class Fclass extends Bclass !6with !7 Eclass {}''',
<String>[
"1+class",
"1-implements",
@@ -2449,21 +2440,13 @@
"3+extends",
"4+Aclass",
"4-Bclass",
- "5+typedef",
- "6+Bclass",
- "6-Ctype",
- "7+Aclass",
- "7-Bclass",
- "8+Ctype",
- "9+abstract",
- "A+with",
- "B+Eclass",
- "B-Dclass",
- "B-Ctype",
- "C+Bclass",
- "C-Eclass"
+ "5+abstract",
+ "6+with",
+ "7+Eclass",
+ "7-Dclass",
+ "7-Ctype",
],
- failingTests: '23467ABC');
+ failingTests: '23467');
// keywords
buildTests(
diff --git a/pkg/analysis_server/test/context_manager_driver_test.dart b/pkg/analysis_server/test/context_manager_driver_test.dart
new file mode 100644
index 0000000..c48c98c
--- /dev/null
+++ b/pkg/analysis_server/test/context_manager_driver_test.dart
@@ -0,0 +1,121 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'context_manager_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(AbstractContextManagerTest_Driver);
+ defineReflectiveTests(ContextManagerWithNewOptionsTest_Driver);
+ defineReflectiveTests(ContextManagerWithOldOptionsTest_Driver);
+ });
+}
+
+@reflectiveTest
+class AbstractContextManagerTest_Driver extends AbstractContextManagerTest {
+ bool get enableAnalysisDriver => true;
+
+ @failingTest
+ test_embedder_added() {
+ // NoSuchMethodError: The getter 'apiSignature' was called on null.
+ // Receiver: null
+ // Tried calling: apiSignature
+ // dart:core Object.noSuchMethod
+ // package:analyzer/src/dart/analysis/driver.dart 460:20 AnalysisDriver.configure
+ // package:analysis_server/src/context_manager.dart 1043:16 ContextManagerImpl._checkForPackagespecUpdate
+ // package:analysis_server/src/context_manager.dart 1553:5 ContextManagerImpl._handleWatchEvent
+ //return super.test_embedder_added();
+ fail('NoSuchMethodError');
+ }
+
+ @failingTest
+ test_embedder_packagespec() async {
+ // NoSuchMethodError: The getter 'apiSignature' was called on null.
+ // Receiver: null
+ // Tried calling: apiSignature
+ // dart:core Object.noSuchMethod
+ // package:analyzer/src/dart/analysis/driver.dart 248:20 AnalysisDriver.AnalysisDriver
+ // test/context_manager_test.dart 2698:25 TestContextManagerCallbacks.addAnalysisDriver
+ // package:analysis_server/src/context_manager.dart 1186:39 ContextManagerImpl._createContext
+ // package:analysis_server/src/context_manager.dart 1247:16 ContextManagerImpl._createContexts
+ // package:analysis_server/src/context_manager.dart 886:9 ContextManagerImpl.setRoots
+ // test/context_manager_test.dart 154:13 AbstractContextManagerTest.test_embedder_packagespec.<async>
+ return super.test_embedder_packagespec();
+ }
+}
+
+@reflectiveTest
+class ContextManagerWithNewOptionsTest_Driver
+ extends ContextManagerWithNewOptionsTest {
+ bool get enableAnalysisDriver => true;
+
+ @failingTest
+ test_analysis_options_file_delete_with_embedder() async {
+ // This fails because the ContextBuilder doesn't pick up the strongMode
+ // flag from the embedder.yaml file.
+ return super.test_analysis_options_file_delete_with_embedder();
+ }
+
+ @failingTest
+ test_embedder_options() async {
+ // This fails because the ContextBuilder doesn't pick up the strongMode
+ // flag from the embedder.yaml file.
+ return super.test_embedder_options();
+ }
+
+ @failingTest
+ test_optionsFile_update_strongMode() async {
+ // It appears that this fails because we are not correctly updating the
+ // analysis options in the driver when the file is modified.
+ //return super.test_optionsFile_update_strongMode();
+ // After a few other changes, the test now times out on my machine, so I'm
+ // disabling it in order to prevent it from being flaky.
+ fail('Test times out');
+ }
+
+ @failingTest
+ test_path_filter_analysis_option() async {
+ // This fails because we're not analyzing the analyis options file.
+ return super.test_path_filter_analysis_option();
+ }
+}
+
+@reflectiveTest
+class ContextManagerWithOldOptionsTest_Driver
+ extends ContextManagerWithOldOptionsTest {
+ bool get enableAnalysisDriver => true;
+
+ @failingTest
+ test_analysis_options_file_delete_with_embedder() async {
+ // This fails because the ContextBuilder doesn't pick up the strongMode
+ // flag from the embedder.yaml file.
+ return super.test_analysis_options_file_delete_with_embedder();
+ }
+
+ @failingTest
+ test_embedder_options() async {
+ // This fails because the ContextBuilder doesn't pick up the strongMode
+ // flag from the embedder.yaml file.
+ return super.test_embedder_options();
+ }
+
+ @failingTest
+ test_optionsFile_update_strongMode() async {
+ // It appears that this fails because we are not correctly updating the
+ // analysis options in the driver when the file is modified.
+ //return super.test_optionsFile_update_strongMode();
+ // After a few other changes, the test now times out on my machine, so I'm
+ // disabling it in order to prevent it from being flaky.
+ fail('Test times out');
+ }
+
+ @failingTest
+ test_path_filter_analysis_option() async {
+ // This fails because we're not analyzing the analyis options file.
+ return super.test_path_filter_analysis_option();
+ }
+}
diff --git a/pkg/analysis_server/test/context_manager_test.dart b/pkg/analysis_server/test/context_manager_test.dart
index ded3532..c539149 100644
--- a/pkg/analysis_server/test/context_manager_test.dart
+++ b/pkg/analysis_server/test/context_manager_test.dart
@@ -39,11 +39,8 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(AbstractContextManagerTest);
- defineReflectiveTests(AbstractContextManagerTest_Driver);
defineReflectiveTests(ContextManagerWithNewOptionsTest);
- defineReflectiveTests(ContextManagerWithNewOptionsTest_Driver);
defineReflectiveTests(ContextManagerWithOldOptionsTest);
- defineReflectiveTests(ContextManagerWithOldOptionsTest_Driver);
});
}
@@ -1711,39 +1708,6 @@
}
}
-@reflectiveTest
-class AbstractContextManagerTest_Driver extends AbstractContextManagerTest {
- bool get enableAnalysisDriver => true;
-
- @failingTest
- test_embedder_added() {
- // NoSuchMethodError: The getter 'apiSignature' was called on null.
- // Receiver: null
- // Tried calling: apiSignature
- // dart:core Object.noSuchMethod
- // package:analyzer/src/dart/analysis/driver.dart 460:20 AnalysisDriver.configure
- // package:analysis_server/src/context_manager.dart 1043:16 ContextManagerImpl._checkForPackagespecUpdate
- // package:analysis_server/src/context_manager.dart 1553:5 ContextManagerImpl._handleWatchEvent
- //return super.test_embedder_added();
- fail('NoSuchMethodError');
- }
-
- @failingTest
- test_embedder_packagespec() async {
- // NoSuchMethodError: The getter 'apiSignature' was called on null.
- // Receiver: null
- // Tried calling: apiSignature
- // dart:core Object.noSuchMethod
- // package:analyzer/src/dart/analysis/driver.dart 248:20 AnalysisDriver.AnalysisDriver
- // test/context_manager_test.dart 2698:25 TestContextManagerCallbacks.addAnalysisDriver
- // package:analysis_server/src/context_manager.dart 1186:39 ContextManagerImpl._createContext
- // package:analysis_server/src/context_manager.dart 1247:16 ContextManagerImpl._createContexts
- // package:analysis_server/src/context_manager.dart 886:9 ContextManagerImpl.setRoots
- // test/context_manager_test.dart 154:13 AbstractContextManagerTest.test_embedder_packagespec.<async>
- return super.test_embedder_packagespec();
- }
-}
-
abstract class ContextManagerTest {
/**
* The name of the 'bin' directory.
@@ -1928,82 +1892,10 @@
}
@reflectiveTest
-class ContextManagerWithNewOptionsTest_Driver
- extends ContextManagerWithNewOptionsTest {
- bool get enableAnalysisDriver => true;
-
- @failingTest
- test_analysis_options_file_delete_with_embedder() async {
- // This fails because the ContextBuilder doesn't pick up the strongMode
- // flag from the embedder.yaml file.
- return super.test_analysis_options_file_delete_with_embedder();
- }
-
- @failingTest
- test_embedder_options() async {
- // This fails because the ContextBuilder doesn't pick up the strongMode
- // flag from the embedder.yaml file.
- return super.test_embedder_options();
- }
-
- @failingTest
- test_optionsFile_update_strongMode() async {
- // It appears that this fails because we are not correctly updating the
- // analysis options in the driver when the file is modified.
- //return super.test_optionsFile_update_strongMode();
- // After a few other changes, the test now times out on my machine, so I'm
- // disabling it in order to prevent it from being flaky.
- fail('Test times out');
- }
-
- @failingTest
- test_path_filter_analysis_option() async {
- // This fails because we're not analyzing the analyis options file.
- return super.test_path_filter_analysis_option();
- }
-}
-
-@reflectiveTest
class ContextManagerWithOldOptionsTest extends ContextManagerWithOptionsTest {
String get optionsFileName => AnalysisEngine.ANALYSIS_OPTIONS_FILE;
}
-@reflectiveTest
-class ContextManagerWithOldOptionsTest_Driver
- extends ContextManagerWithOldOptionsTest {
- bool get enableAnalysisDriver => true;
-
- @failingTest
- test_analysis_options_file_delete_with_embedder() async {
- // This fails because the ContextBuilder doesn't pick up the strongMode
- // flag from the embedder.yaml file.
- return super.test_analysis_options_file_delete_with_embedder();
- }
-
- @failingTest
- test_embedder_options() async {
- // This fails because the ContextBuilder doesn't pick up the strongMode
- // flag from the embedder.yaml file.
- return super.test_embedder_options();
- }
-
- @failingTest
- test_optionsFile_update_strongMode() async {
- // It appears that this fails because we are not correctly updating the
- // analysis options in the driver when the file is modified.
- //return super.test_optionsFile_update_strongMode();
- // After a few other changes, the test now times out on my machine, so I'm
- // disabling it in order to prevent it from being flaky.
- fail('Test times out');
- }
-
- @failingTest
- test_path_filter_analysis_option() async {
- // This fails because we're not analyzing the analyis options file.
- return super.test_path_filter_analysis_option();
- }
-}
-
abstract class ContextManagerWithOptionsTest extends ContextManagerTest {
String get optionsFileName;
diff --git a/pkg/analysis_server/test/integration/analysis/error_driver_test.dart b/pkg/analysis_server/test/integration/analysis/error_driver_test.dart
new file mode 100644
index 0000000..9f18a12
--- /dev/null
+++ b/pkg/analysis_server/test/integration/analysis/error_driver_test.dart
@@ -0,0 +1,30 @@
+// Copyright (c) 2014, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'error_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(AnalysisErrorIntegrationTest_Driver);
+ });
+}
+
+@reflectiveTest
+class AnalysisErrorIntegrationTest_Driver
+ extends AbstractAnalysisErrorIntegrationTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+
+ @failingTest
+ test_super_mixins_enabled() async {
+ // Expected: empty
+ // Actual: [
+ // AnalysisError:{"severity":"ERROR","type":"COMPILE_TIME_ERROR","location":{"file":"/var/folders/00/0w95r000h01000cxqpysvccm003j4q/T/analysisServerfbuOQb/test.dart","offset":31,"length":1,"startLine":1,"startColumn":32},"message":"The class 'C' can't be used as a mixin because it extends a class other than Object.","correction":"","code":"mixin_inherits_from_not_object","hasFix":false},
+ // AnalysisError:{"severity":"ERROR","type":"COMPILE_TIME_ERROR","location":{"file":"/var/folders/00/0w95r000h01000cxqpysvccm003j4q/T/analysisServerfbuOQb/test.dart","offset":31,"length":1,"startLine":1,"startColumn":32},"message":"The class 'C' can't be used as a mixin because it references 'super'.","correction":"","code":"mixin_references_super","hasFix":false}
+ // ]
+ return super.test_super_mixins_enabled();
+ }
+}
diff --git a/pkg/analysis_server/test/integration/analysis/error_test.dart b/pkg/analysis_server/test/integration/analysis/error_test.dart
index 2a86499..5c4bea4 100644
--- a/pkg/analysis_server/test/integration/analysis/error_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/error_test.dart
@@ -11,7 +11,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(AnalysisErrorIntegrationTest);
- defineReflectiveTests(AnalysisErrorIntegrationTest_Driver);
});
}
@@ -98,20 +97,3 @@
@reflectiveTest
class AnalysisErrorIntegrationTest
extends AbstractAnalysisErrorIntegrationTest {}
-
-@reflectiveTest
-class AnalysisErrorIntegrationTest_Driver
- extends AbstractAnalysisErrorIntegrationTest {
- @override
- bool get enableNewAnalysisDriver => true;
-
- @failingTest
- test_super_mixins_enabled() async {
- // Expected: empty
- // Actual: [
- // AnalysisError:{"severity":"ERROR","type":"COMPILE_TIME_ERROR","location":{"file":"/var/folders/00/0w95r000h01000cxqpysvccm003j4q/T/analysisServerfbuOQb/test.dart","offset":31,"length":1,"startLine":1,"startColumn":32},"message":"The class 'C' can't be used as a mixin because it extends a class other than Object.","correction":"","code":"mixin_inherits_from_not_object","hasFix":false},
- // AnalysisError:{"severity":"ERROR","type":"COMPILE_TIME_ERROR","location":{"file":"/var/folders/00/0w95r000h01000cxqpysvccm003j4q/T/analysisServerfbuOQb/test.dart","offset":31,"length":1,"startLine":1,"startColumn":32},"message":"The class 'C' can't be used as a mixin because it references 'super'.","correction":"","code":"mixin_references_super","hasFix":false}
- // ]
- return super.test_super_mixins_enabled();
- }
-}
diff --git a/pkg/analysis_server/test/integration/analysis/lint_driver_test.dart b/pkg/analysis_server/test/integration/analysis/lint_driver_test.dart
new file mode 100644
index 0000000..80d2255
--- /dev/null
+++ b/pkg/analysis_server/test/integration/analysis/lint_driver_test.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'lint_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(LintIntegrationTest_Driver);
+ });
+}
+
+@reflectiveTest
+class LintIntegrationTest_Driver extends AbstractLintIntegrationTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analysis_server/test/integration/analysis/lint_test.dart b/pkg/analysis_server/test/integration/analysis/lint_test.dart
index 0a41fbf..8a76f0f 100644
--- a/pkg/analysis_server/test/integration/analysis/lint_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/lint_test.dart
@@ -12,7 +12,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(LintIntegrationTest);
- defineReflectiveTests(LintIntegrationTest_Driver);
});
}
@@ -95,9 +94,3 @@
@reflectiveTest
class LintIntegrationTest extends AbstractLintIntegrationTest {}
-
-@reflectiveTest
-class LintIntegrationTest_Driver extends AbstractLintIntegrationTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analysis_server/test/integration/analysis/test_all.dart b/pkg/analysis_server/test/integration/analysis/test_all.dart
index dcdc7c8..9937146 100644
--- a/pkg/analysis_server/test/integration/analysis/test_all.dart
+++ b/pkg/analysis_server/test/integration/analysis/test_all.dart
@@ -7,6 +7,7 @@
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'analysis_options_test.dart' as analysis_options_test;
+import 'error_driver_test.dart' as error_driver_test;
import 'error_test.dart' as error_test;
import 'get_errors_after_analysis_test.dart' as get_errors_after_analysis_test;
import 'get_errors_before_analysis_test.dart'
@@ -15,6 +16,7 @@
import 'get_hover_test.dart' as get_hover_test;
import 'highlights_test.dart' as highlights_test;
import 'highlights_test2.dart' as highlights_test2;
+import 'lint_driver_test.dart' as lint_driver_test;
import 'lint_test.dart' as lint_test;
import 'navigation_test.dart' as navigation_test;
import 'occurrences_test.dart' as occurrences_test;
@@ -23,6 +25,7 @@
import 'package_root_test.dart' as package_root_test;
import 'reanalyze_concurrent_test.dart' as reanalyze_concurrent_test;
import 'reanalyze_test.dart' as reanalyze_test;
+import 'update_content_driver_test.dart' as update_content_driver_test;
import 'update_content_list_test.dart' as update_content_list_test;
import 'update_content_test.dart' as update_content_test;
@@ -32,6 +35,7 @@
main() {
defineReflectiveSuite(() {
analysis_options_test.main();
+ error_driver_test.main();
error_test.main();
get_errors_after_analysis_test.main();
get_errors_before_analysis_test.main();
@@ -39,6 +43,7 @@
get_hover_test.main();
highlights_test.main();
highlights_test2.main();
+ lint_driver_test.main();
lint_test.main();
navigation_test.main();
occurrences_test.main();
@@ -47,6 +52,7 @@
package_root_test.main();
reanalyze_concurrent_test.main();
reanalyze_test.main();
+ update_content_driver_test.main();
update_content_test.main();
update_content_list_test.main();
}, name: 'analysis');
diff --git a/pkg/analysis_server/test/integration/analysis/update_content_driver_test.dart b/pkg/analysis_server/test/integration/analysis/update_content_driver_test.dart
new file mode 100644
index 0000000..1542356
--- /dev/null
+++ b/pkg/analysis_server/test/integration/analysis/update_content_driver_test.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'update_content_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(UpdateContentTest_Driver);
+ });
+}
+
+@reflectiveTest
+class UpdateContentTest_Driver extends AbstractUpdateContentTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analysis_server/test/integration/analysis/update_content_test.dart b/pkg/analysis_server/test/integration/analysis/update_content_test.dart
index e92bccc..b853209 100644
--- a/pkg/analysis_server/test/integration/analysis/update_content_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/update_content_test.dart
@@ -11,7 +11,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(UpdateContentTest);
- defineReflectiveTests(UpdateContentTest_Driver);
});
}
@@ -110,9 +109,3 @@
@reflectiveTest
class UpdateContentTest extends AbstractUpdateContentTest {}
-
-@reflectiveTest
-class UpdateContentTest_Driver extends AbstractUpdateContentTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analysis_server/test/integration/completion/get_suggestions_driver_test.dart b/pkg/analysis_server/test/integration/completion/get_suggestions_driver_test.dart
new file mode 100644
index 0000000..0e77363
--- /dev/null
+++ b/pkg/analysis_server/test/integration/completion/get_suggestions_driver_test.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'get_suggestions_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(GetSuggestionsTest_Driver);
+ });
+}
+
+@reflectiveTest
+class GetSuggestionsTest_Driver extends AbstractGetSuggestionsTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart b/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart
index 6376aa5..8c1c4a2 100644
--- a/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart
+++ b/pkg/analysis_server/test/integration/completion/get_suggestions_test.dart
@@ -11,7 +11,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(GetSuggestionsTest);
- defineReflectiveTests(GetSuggestionsTest_Driver);
});
}
@@ -124,9 +123,3 @@
@reflectiveTest
class GetSuggestionsTest extends AbstractGetSuggestionsTest {}
-
-@reflectiveTest
-class GetSuggestionsTest_Driver extends AbstractGetSuggestionsTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analysis_server/test/integration/completion/test_all.dart b/pkg/analysis_server/test/integration/completion/test_all.dart
index 580ffca..0da4272 100644
--- a/pkg/analysis_server/test/integration/completion/test_all.dart
+++ b/pkg/analysis_server/test/integration/completion/test_all.dart
@@ -6,6 +6,7 @@
import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'get_suggestions_driver_test.dart' as get_suggestions_driver_test;
import 'get_suggestions_test.dart' as get_suggestions_test;
/**
@@ -13,6 +14,7 @@
*/
main() {
defineReflectiveSuite(() {
+ get_suggestions_driver_test.main();
get_suggestions_test.main();
}, name: 'completion');
}
diff --git a/pkg/analysis_server/test/test_all.dart b/pkg/analysis_server/test/test_all.dart
index 3e7b635..0f7942f 100644
--- a/pkg/analysis_server/test/test_all.dart
+++ b/pkg/analysis_server/test/test_all.dart
@@ -8,6 +8,7 @@
import 'analysis_server_test.dart' as analysis_server_test;
import 'channel/test_all.dart' as channel_test;
import 'completion_test.dart' as completion_test;
+import 'context_manager_driver_test.dart' as context_manager_driver_test;
import 'context_manager_test.dart' as context_manager_test;
import 'domain_analysis_test.dart' as domain_analysis_test;
import 'domain_completion_test.dart' as domain_completion_test;
@@ -36,6 +37,7 @@
analysis_server_test.main();
channel_test.main();
completion_test.main();
+ context_manager_driver_test.main();
context_manager_test.main();
domain_analysis_test.main();
domain_completion_test.main();
diff --git a/pkg/analyzer/doc/tasks.html b/pkg/analyzer/doc/tasks.html
index df31e7a..344f26d 100644
--- a/pkg/analyzer/doc/tasks.html
+++ b/pkg/analyzer/doc/tasks.html
@@ -90,6 +90,7 @@
EXPORTED_LIBRARIES -> ReadyLibraryElement2Task
EXPORTED_LIBRARIES -> ReadyLibraryElement5Task
EXPORTED_LIBRARIES -> ReadyLibraryElement7Task
+ EXPORTED_LIBRARIES -> ResolveDirectiveElementsTask
EXPORTED_LIBRARIES -> ResolveTopLevelLibraryTypeBoundsTask
EXPORTED_LIBRARIES [shape=box]
EXPORT_SOURCE_CLOSURE -> BuildExportNamespaceTask
@@ -109,6 +110,7 @@
IMPORTED_LIBRARIES -> ReadyLibraryElement2Task
IMPORTED_LIBRARIES -> ReadyLibraryElement5Task
IMPORTED_LIBRARIES -> ReadyLibraryElement7Task
+ IMPORTED_LIBRARIES -> ResolveDirectiveElementsTask
IMPORTED_LIBRARIES -> ResolveTopLevelLibraryTypeBoundsTask
IMPORTED_LIBRARIES -> ResolveTopLevelUnitTypeBoundsTask
IMPORTED_LIBRARIES [shape=box]
@@ -194,6 +196,7 @@
MODIFICATION_TIME -> BuildDirectiveElementsTask
MODIFICATION_TIME -> BuildLibraryElementTask
MODIFICATION_TIME -> ParseDartTask
+ MODIFICATION_TIME -> ResolveDirectiveElementsTask
MODIFICATION_TIME -> ScanDartTask
MODIFICATION_TIME -> VerifyUnitTask
MODIFICATION_TIME [shape=box]
@@ -231,6 +234,7 @@
READY_RESOLVED_UNIT [shape=box]
REFERENCED_NAMES [shape=box]
REFERENCED_SOURCES -> BuildDirectiveElementsTask
+ REFERENCED_SOURCES -> ResolveDirectiveElementsTask
REFERENCED_SOURCES -> VerifyUnitTask
REFERENCED_SOURCES [shape=box]
REQUIRED_CONSTANTS -> VerifyUnitTask
@@ -275,6 +279,8 @@
RESOLVED_UNIT8 [shape=box]
RESOLVED_UNIT9 -> InferInstanceMembersInUnitTask
RESOLVED_UNIT9 [shape=box]
+ RESOLVE_DIRECTIVES_ERRORS -> LibraryUnitErrorsTask
+ RESOLVE_DIRECTIVES_ERRORS [shape=box]
RESOLVE_TYPE_BOUNDS_ERRORS -> LibraryUnitErrorsTask
RESOLVE_TYPE_BOUNDS_ERRORS [shape=box]
RESOLVE_TYPE_NAMES_ERRORS -> LibraryUnitErrorsTask
@@ -288,6 +294,7 @@
ResolveConstantExpressionTask -> CONSTANT_EXPRESSION_RESOLVED
ResolveDirectiveElementsTask -> CREATED_RESOLVED_UNIT2
ResolveDirectiveElementsTask -> RESOLVED_UNIT2
+ ResolveDirectiveElementsTask -> RESOLVE_DIRECTIVES_ERRORS
ResolveInstanceFieldsInUnitTask -> CREATED_RESOLVED_UNIT9
ResolveInstanceFieldsInUnitTask -> RESOLVED_UNIT9
ResolveLibraryReferencesTask -> LIBRARY_ELEMENT9
@@ -312,6 +319,7 @@
SCAN_ERRORS -> dartErrorsForSource
SCAN_ERRORS [shape=box]
SOURCE_KIND -> BuildDirectiveElementsTask
+ SOURCE_KIND -> ResolveDirectiveElementsTask
SOURCE_KIND [shape=box]
STATIC_VARIABLE_RESOLUTION_ERRORS -> InferStaticVariableTypesInUnitTask
STATIC_VARIABLE_RESOLUTION_ERRORS [shape=box]
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index f1917aa..43d6bd1 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -306,7 +306,7 @@
ParserErrorCode.CONST_TYPEDEF,
ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP,
ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE,
- ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS,
+ ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE,
ParserErrorCode.DIRECTIVE_AFTER_DECLARATION,
ParserErrorCode.DUPLICATED_MODIFIER,
ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT,
@@ -373,12 +373,14 @@
ParserErrorCode.MISSING_EXPRESSION_IN_INITIALIZER,
ParserErrorCode.MISSING_EXPRESSION_IN_THROW,
ParserErrorCode.MISSING_FUNCTION_BODY,
+ ParserErrorCode.MISSING_FUNCTION_KEYWORD,
ParserErrorCode.MISSING_FUNCTION_PARAMETERS,
ParserErrorCode.MISSING_GET,
ParserErrorCode.MISSING_IDENTIFIER,
ParserErrorCode.MISSING_INITIALIZER,
ParserErrorCode.MISSING_KEYWORD_OPERATOR,
ParserErrorCode.MISSING_METHOD_PARAMETERS,
+ ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER,
ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE,
ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE,
ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT,
@@ -397,6 +399,7 @@
ParserErrorCode.MULTIPLE_VARIABLES_IN_FOR_EACH,
ParserErrorCode.MULTIPLE_WITH_CLAUSES,
ParserErrorCode.NAMED_FUNCTION_EXPRESSION,
+ ParserErrorCode.NAMED_FUNCTION_TYPE,
ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP,
ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE,
ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE,
diff --git a/pkg/analyzer/lib/src/context/context.dart b/pkg/analyzer/lib/src/context/context.dart
index c2c2ec0..52a64b7 100644
--- a/pkg/analyzer/lib/src/context/context.dart
+++ b/pkg/analyzer/lib/src/context/context.dart
@@ -1247,6 +1247,7 @@
setValue(HINTS, AnalysisError.NO_ERRORS);
setValue(LINTS, AnalysisError.NO_ERRORS);
setValue(LIBRARY_UNIT_ERRORS, AnalysisError.NO_ERRORS);
+ setValue(RESOLVE_DIRECTIVES_ERRORS, AnalysisError.NO_ERRORS);
setValue(RESOLVE_TYPE_NAMES_ERRORS, AnalysisError.NO_ERRORS);
setValue(RESOLVE_UNIT_ERRORS, AnalysisError.NO_ERRORS);
entry.setState(RESOLVED_UNIT, CacheState.FLUSHED);
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 4f1234e..c24183c 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -73,7 +73,7 @@
/**
* The version of data format, should be incremented on every format change.
*/
- static const int DATA_VERSION = 10;
+ static const int DATA_VERSION = 11;
/**
* The name of the driver, e.g. the name of the folder.
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_state.dart b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
index 1608c33..ba54b8b 100644
--- a/pkg/analyzer/lib/src/dart/analysis/file_state.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
@@ -340,6 +340,7 @@
LineInfo lineInfo = new LineInfo(scanner.lineStarts);
Parser parser = new Parser(source, errorListener);
+ parser.enableAssertInitializer = analysisOptions.enableAssertInitializer;
parser.parseGenericMethodComments = analysisOptions.strongMode;
CompilationUnit unit = parser.parseCompilationUnit(token);
unit.lineInfo = lineInfo;
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 218284d..607946a 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -2239,6 +2239,9 @@
.buildExpression(this, serialized.expression));
initializer.fieldName.staticElement = enclosingElement.getField(name);
return initializer;
+ case UnlinkedConstructorInitializerKind.assertInvocation:
+ return AstTestFactory.assertInitializer(
+ arguments[0], arguments.length > 1 ? arguments[1] : null);
case UnlinkedConstructorInitializerKind.superInvocation:
SuperConstructorInvocation initializer =
AstTestFactory.superConstructorInvocation2(
diff --git a/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart b/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
index 594ba19..18fef4c 100644
--- a/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
+++ b/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
@@ -142,11 +142,11 @@
"A continue statement in a switch statement must have a label as a target.",
"Try adding a label associated with one of the case clauses to the continue statement.");
- static const ParserErrorCode DEPRECATED_CLASS_TYPE_ALIAS =
+ static const ParserErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPE =
const ParserErrorCode(
- 'DEPRECATED_CLASS_TYPE_ALIAS',
- "The 'typedef' mixin application was replaced with 'class'.",
- "Try re-writing the typedef as 'class C = S with M'.");
+ 'DEFAULT_VALUE_IN_FUNCTION_TYPE',
+ "Parameters in a function type cannot have default values",
+ "Try removing the default value.");
static const ParserErrorCode DIRECTIVE_AFTER_DECLARATION =
const ParserErrorCode(
@@ -523,18 +523,17 @@
"A function body must be provided.",
"Try adding a function body.");
+ static const ParserErrorCode MISSING_FUNCTION_KEYWORD = const ParserErrorCode(
+ 'MISSING_FUNCTION_KEYWORD',
+ "Function types must have the keyword 'Function' before the parameter list.",
+ "Try adding the keyword 'Function'.");
+
static const ParserErrorCode MISSING_FUNCTION_PARAMETERS =
const ParserErrorCode(
'MISSING_FUNCTION_PARAMETERS',
"Functions must have an explicit list of parameters.",
"Try adding a parameter list.");
- static const ParserErrorCode MISSING_METHOD_PARAMETERS =
- const ParserErrorCode(
- 'MISSING_METHOD_PARAMETERS',
- "Methods must have an explicit list of parameters.",
- "Try adding a parameter list.");
-
static const ParserErrorCode MISSING_GET = const ParserErrorCode(
'MISSING_GET',
"Getters must have the keyword 'get' before the getter name.",
@@ -551,6 +550,18 @@
"Operator declarations must be preceeded by the keyword 'operator'.",
"Try adding the keyword 'operator'.");
+ static const ParserErrorCode MISSING_METHOD_PARAMETERS =
+ const ParserErrorCode(
+ 'MISSING_METHOD_PARAMETERS',
+ "Methods must have an explicit list of parameters.",
+ "Try adding a parameter list.");
+
+ static const ParserErrorCode MISSING_NAME_FOR_NAMED_PARAMETER =
+ const ParserErrorCode(
+ 'MISSING_NAME_FOR_NAMED_PARAMETER',
+ "Named parameters in a function type must have a name",
+ "Try providing a name for the parameter or removing the curly braces.");
+
static const ParserErrorCode MISSING_NAME_IN_LIBRARY_DIRECTIVE =
const ParserErrorCode(
'MISSING_NAME_IN_LIBRARY_DIRECTIVE',
@@ -661,6 +672,11 @@
"Try removing the name, or "
"moving the function expression to a function declaration statement.");
+ static const ParserErrorCode NAMED_FUNCTION_TYPE = const ParserErrorCode(
+ 'NAMED_FUNCTION_TYPE',
+ "Function types can't be named.",
+ "Try replacing the name with the keyword 'Function'.");
+
static const ParserErrorCode NAMED_PARAMETER_OUTSIDE_GROUP =
const ParserErrorCode(
'NAMED_PARAMETER_OUTSIDE_GROUP',
diff --git a/pkg/analyzer/lib/src/dart/sdk/sdk.dart b/pkg/analyzer/lib/src/dart/sdk/sdk.dart
index 1163413..d66526e 100644
--- a/pkg/analyzer/lib/src/dart/sdk/sdk.dart
+++ b/pkg/analyzer/lib/src/dart/sdk/sdk.dart
@@ -273,15 +273,14 @@
static const String _EMBEDDED_LIB_MAP_KEY = 'embedded_libs';
final Map<String, String> _urlMappings = new HashMap<String, String>();
- PackageBundle _embedderBundle;
+ Folder _embedderYamlLibFolder;
EmbedderSdk(
ResourceProvider resourceProvider, Map<Folder, YamlMap> embedderYamls) {
this.resourceProvider = resourceProvider;
embedderYamls?.forEach(_processEmbedderYaml);
if (embedderYamls?.length == 1) {
- Folder libFolder = embedderYamls.keys.first;
- _loadEmbedderBundle(libFolder);
+ _embedderYamlLibFolder = embedderYamls.keys.first;
}
}
@@ -299,8 +298,17 @@
@override
PackageBundle getSummarySdkBundle(bool strongMode) {
- if (strongMode) {
- return _embedderBundle;
+ String name = strongMode ? 'strong.sum' : 'spec.sum';
+ File file = _embedderYamlLibFolder.parent.getChildAssumingFile(name);
+ try {
+ if (file.exists) {
+ List<int> bytes = file.readAsBytesSync();
+ return new PackageBundle.fromBuffer(bytes);
+ }
+ } catch (exception, stackTrace) {
+ AnalysisEngine.instance.logger.logError(
+ 'Failed to load SDK analysis summary from $file',
+ new CaughtException(exception, stackTrace));
}
return null;
}
@@ -345,16 +353,6 @@
}
}
- void _loadEmbedderBundle(Folder libFolder) {
- File bundleFile = libFolder.parent.getChildAssumingFile('sdk.ds');
- if (bundleFile.exists) {
- try {
- List<int> bytes = bundleFile.readAsBytesSync();
- _embedderBundle = new PackageBundle.fromBuffer(bytes);
- } on FileSystemException {}
- }
- }
-
/**
* Install the mapping from [name] to [libDir]/[file].
*/
diff --git a/pkg/analyzer/lib/src/generated/constant.dart b/pkg/analyzer/lib/src/generated/constant.dart
index 5233b48..dfa5310 100644
--- a/pkg/analyzer/lib/src/generated/constant.dart
+++ b/pkg/analyzer/lib/src/generated/constant.dart
@@ -118,8 +118,10 @@
* [source]. The [typeProvider] is the type provider used to access known
* types.
*/
- ConstantEvaluator(this._source, this._typeProvider, {TypeSystem typeSystem})
- : _typeSystem = typeSystem ?? new TypeSystemImpl(_typeProvider);
+ ConstantEvaluator(this._source, TypeProvider typeProvider,
+ {TypeSystem typeSystem})
+ : _typeSystem = typeSystem ?? new TypeSystemImpl(typeProvider),
+ _typeProvider = typeProvider;
EvaluationResult evaluate(Expression expression) {
RecordingErrorListener errorListener = new RecordingErrorListener();
diff --git a/pkg/analyzer/lib/src/generated/parser.dart b/pkg/analyzer/lib/src/generated/parser.dart
index c16281e..e878afd 100644
--- a/pkg/analyzer/lib/src/generated/parser.dart
+++ b/pkg/analyzer/lib/src/generated/parser.dart
@@ -1535,32 +1535,6 @@
}
/**
- * Parse a class type alias. The [commentAndMetadata] is the metadata to be
- * associated with the member. The [abstractKeyword] is the token representing
- * the 'abstract' keyword. The [classKeyword] is the token representing the
- * 'class' keyword. Return the class type alias that was parsed.
- *
- * This method assumes that the current token matches an identifier.
- *
- * classTypeAlias ::=
- * identifier typeParameters? '=' 'abstract'? mixinApplication
- *
- * mixinApplication ::=
- * type withClause implementsClause? ';'
- */
- ClassTypeAlias parseClassTypeAlias(CommentAndMetadata commentAndMetadata,
- Token abstractKeyword, Token classKeyword) {
- SimpleIdentifier className =
- _parseSimpleIdentifierUnchecked(isDeclaration: true);
- TypeParameterList typeParameters = null;
- if (_matches(TokenType.LT)) {
- typeParameters = parseTypeParameterList();
- }
- return _parseClassTypeAliasAfterName(commentAndMetadata, abstractKeyword,
- classKeyword, className, typeParameters);
- }
-
- /**
* Parse a single combinator. Return the combinator that was parsed, or `null`
* if no combinator is found.
*
@@ -2780,7 +2754,8 @@
* | 'var'
* | type
*/
- FinalConstVarOrType parseFinalConstVarOrType(bool optional) {
+ FinalConstVarOrType parseFinalConstVarOrType(bool optional,
+ {bool inFunctionType: false}) {
Token keywordToken = null;
TypeName type = null;
Keyword keyword = _currentToken.keyword;
@@ -2802,6 +2777,8 @@
}
} else if (_isTypedIdentifier(_currentToken)) {
type = parseReturnType();
+ } else if (inFunctionType && _matchesIdentifier()) {
+ type = parseTypeAnnotation();
} else if (!optional) {
_reportErrorForCurrentToken(
ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
@@ -2826,34 +2803,60 @@
* normalFormalParameter ('=' expression)?
* normalFormalParameter (':' expression)?
*/
- FormalParameter parseFormalParameter(ParameterKind kind) {
- NormalFormalParameter parameter = parseNormalFormalParameter();
+ FormalParameter parseFormalParameter(ParameterKind kind,
+ {bool inFunctionType: false}) {
+ NormalFormalParameter parameter =
+ parseNormalFormalParameter(inFunctionType: inFunctionType);
TokenType type = _currentToken.type;
if (type == TokenType.EQ) {
+ if (inFunctionType) {
+ _reportErrorForCurrentToken(
+ ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE);
+ }
Token separator = getAndAdvance();
Expression defaultValue = parseExpression2();
if (kind == ParameterKind.REQUIRED) {
_reportErrorForNode(
ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP, parameter);
kind = ParameterKind.POSITIONAL;
+ } else if (kind == ParameterKind.NAMED &&
+ inFunctionType &&
+ parameter.identifier == null) {
+ _reportErrorForCurrentToken(
+ ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER);
}
return astFactory.defaultFormalParameter(
parameter, kind, separator, defaultValue);
} else if (type == TokenType.COLON) {
+ if (inFunctionType) {
+ _reportErrorForCurrentToken(
+ ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE);
+ }
Token separator = getAndAdvance();
Expression defaultValue = parseExpression2();
- if (kind == ParameterKind.POSITIONAL) {
- _reportErrorForToken(
- ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
- separator);
- } else if (kind == ParameterKind.REQUIRED) {
+ if (kind == ParameterKind.REQUIRED) {
_reportErrorForNode(
ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, parameter);
kind = ParameterKind.NAMED;
+ } else if (kind == ParameterKind.POSITIONAL) {
+ _reportErrorForToken(
+ ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
+ separator);
+ } else if (kind == ParameterKind.NAMED &&
+ inFunctionType &&
+ parameter.identifier == null) {
+ _reportErrorForCurrentToken(
+ ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER);
}
return astFactory.defaultFormalParameter(
parameter, kind, separator, defaultValue);
} else if (kind != ParameterKind.REQUIRED) {
+ if (kind == ParameterKind.NAMED &&
+ inFunctionType &&
+ parameter.identifier == null) {
+ _reportErrorForCurrentToken(
+ ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER);
+ }
return astFactory.defaultFormalParameter(parameter, kind, null, null);
}
return parameter;
@@ -2881,9 +2884,9 @@
* namedFormalParameters ::=
* '{' defaultNamedParameter (',' defaultNamedParameter)* '}'
*/
- FormalParameterList parseFormalParameterList() {
+ FormalParameterList parseFormalParameterList({bool inFunctionType: false}) {
if (_matches(TokenType.OPEN_PAREN)) {
- return _parseFormalParameterListUnchecked();
+ return _parseFormalParameterListUnchecked(inFunctionType: inFunctionType);
}
// TODO(brianwilkerson) Improve the error message.
_reportErrorForCurrentToken(
@@ -3267,6 +3270,90 @@
}
/**
+ * Parse the portion of a generic function type following the [returnType].
+ *
+ * functionType ::=
+ * returnType? 'Function' typeParameters? parameterTypeList
+ * parameterTypeList ::=
+ * '(' ')' |
+ * | '(' normalParameterTypes ','? ')' |
+ * | '(' normalParameterTypes ',' optionalParameterTypes ')' |
+ * | '(' optionalParameterTypes ')'
+ * normalParameterTypes ::=
+ * normalParameterType (',' normalParameterType)*
+ * normalParameterType ::=
+ * type | typedIdentifier
+ * optionalParameterTypes ::=
+ * optionalPositionalParameterTypes | namedParameterTypes
+ * optionalPositionalParameterTypes ::=
+ * '[' normalParameterTypes ','? ']'
+ * namedParameterTypes ::=
+ * '{' typedIdentifier (',' typedIdentifier)* ','? '}'
+ * typedIdentifier ::=
+ * type identifier
+ */
+ GenericFunctionType parseGenericFunctionTypeAfterReturnType(
+ TypeAnnotation returnType) {
+ Token functionKeyword = null;
+ if (_matchesString('Function')) {
+ functionKeyword = getAndAdvance();
+ } else if (_matchesIdentifier()) {
+ _reportErrorForCurrentToken(ParserErrorCode.NAMED_FUNCTION_TYPE);
+ } else {
+ _reportErrorForCurrentToken(ParserErrorCode.MISSING_FUNCTION_KEYWORD);
+ }
+ TypeParameterList typeParameters = null;
+ if (_matches(TokenType.LT)) {
+ typeParameters = parseTypeParameterList();
+ }
+ FormalParameterList parameters =
+ parseFormalParameterList(inFunctionType: true);
+ return astFactory.genericFunctionType(
+ returnType, functionKeyword, typeParameters, parameters);
+ }
+
+ /**
+ * Parse a generic function type alias.
+ *
+ * This method assumes that the current token is an identifier.
+ *
+ * genericTypeAlias ::=
+ * 'typedef' identifier typeParameterList? '=' functionType ';'
+ */
+ GenericTypeAlias parseGenericTypeAlias(
+ CommentAndMetadata commentAndMetadata, Token keyword) {
+ Identifier name = _parseSimpleIdentifierUnchecked(isDeclaration: true);
+ TypeParameterList typeParameters = null;
+ if (_matches(TokenType.LT)) {
+ typeParameters = parseTypeParameterList();
+ }
+ Token equals = _expect(TokenType.EQ);
+ TypeAnnotation functionType = parseTypeAnnotation();
+ Token semicolon = _expect(TokenType.SEMICOLON);
+ if (functionType is! GenericFunctionType) {
+ // TODO(brianwilkerson) Generate an error and recover (better than this).
+ return astFactory.genericTypeAlias(
+ commentAndMetadata.comment,
+ commentAndMetadata.metadata,
+ keyword,
+ name,
+ typeParameters,
+ equals,
+ null,
+ semicolon);
+ }
+ return astFactory.genericTypeAlias(
+ commentAndMetadata.comment,
+ commentAndMetadata.metadata,
+ keyword,
+ name,
+ typeParameters,
+ equals,
+ functionType,
+ semicolon);
+ }
+
+ /**
* Parse a getter. The [commentAndMetadata] is the documentation comment and
* metadata to be associated with the declaration. The externalKeyword] is the
* 'external' token. The staticKeyword] is the static keyword, or `null` if
@@ -4015,15 +4102,21 @@
* declaredIdentifier
* | metadata identifier
*/
- NormalFormalParameter parseNormalFormalParameter() {
+ NormalFormalParameter parseNormalFormalParameter(
+ {bool inFunctionType: false}) {
CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
- FinalConstVarOrType holder = parseFinalConstVarOrType(true);
+ FinalConstVarOrType holder = parseFinalConstVarOrType(!inFunctionType,
+ inFunctionType: inFunctionType);
Token thisKeyword = null;
Token period = null;
if (_matchesKeyword(Keyword.THIS)) {
thisKeyword = getAndAdvance();
period = _expect(TokenType.PERIOD);
}
+ if (!_matchesIdentifier() && inFunctionType) {
+ return astFactory.simpleFormalParameter(commentAndMetadata.comment,
+ commentAndMetadata.metadata, holder.keyword, holder.type, null);
+ }
SimpleIdentifier identifier = parseSimpleIdentifier();
TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
if (_matches(TokenType.OPEN_PAREN)) {
@@ -4860,16 +4953,10 @@
*
* typeAlias ::=
* 'typedef' typeAliasBody
+ * | genericTypeAlias
*
* typeAliasBody ::=
- * classTypeAlias
- * | functionTypeAlias
- *
- * classTypeAlias ::=
- * identifier typeParameters? '=' 'abstract'? mixinApplication
- *
- * mixinApplication ::=
- * qualified withClause implementsClause? ';'
+ * functionTypeAlias
*
* functionTypeAlias ::=
* functionPrefix typeParameterList? formalParameterList ';'
@@ -4885,16 +4972,12 @@
next = _skipTypeParameterList(next);
if (next != null && _tokenMatches(next, TokenType.EQ)) {
TypeAlias typeAlias =
- parseClassTypeAlias(commentAndMetadata, null, keyword);
- _reportErrorForToken(
- ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
+ parseGenericTypeAlias(commentAndMetadata, keyword);
return typeAlias;
}
} else if (_tokenMatches(next, TokenType.EQ)) {
TypeAlias typeAlias =
- parseClassTypeAlias(commentAndMetadata, null, keyword);
- _reportErrorForToken(
- ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
+ parseGenericTypeAlias(commentAndMetadata, keyword);
return typeAlias;
}
}
@@ -4902,6 +4985,25 @@
}
/**
+ * Parse a type.
+ *
+ * type ::=
+ * typeWithoutFunction
+ * | functionType
+ */
+ TypeAnnotation parseTypeAnnotation() {
+ if (_matchesString('Function')) {
+ // Generic function type with no return type.
+ return parseGenericFunctionTypeAfterReturnType(null);
+ }
+ TypeAnnotation type = parseReturnType();
+ while (_matchesString('Function')) {
+ type = parseGenericFunctionTypeAfterReturnType(type);
+ }
+ return type;
+ }
+
+ /**
* Parse a list of type arguments. Return the type argument list that was
* parsed.
*
@@ -6367,8 +6469,8 @@
* Parse a list of formal parameters given that the list starts with the given
* [leftParenthesis]. Return the formal parameters that were parsed.
*/
- FormalParameterList _parseFormalParameterListAfterParen(
- Token leftParenthesis) {
+ FormalParameterList _parseFormalParameterListAfterParen(Token leftParenthesis,
+ {bool inFunctionType: false}) {
if (_matches(TokenType.CLOSE_PAREN)) {
return astFactory.formalParameterList(
leftParenthesis, null, null, null, getAndAdvance());
@@ -6441,7 +6543,8 @@
//
// Parse and record the parameter.
//
- FormalParameter parameter = parseFormalParameter(kind);
+ FormalParameter parameter =
+ parseFormalParameter(kind, inFunctionType: inFunctionType);
parameters.add(parameter);
if (kind == ParameterKind.REQUIRED && wasOptionalParameter) {
_reportErrorForNode(
@@ -6530,8 +6633,10 @@
*
* This method assumes that the current token matches `TokenType.OPEN_PAREN`.
*/
- FormalParameterList _parseFormalParameterListUnchecked() {
- return _parseFormalParameterListAfterParen(getAndAdvance());
+ FormalParameterList _parseFormalParameterListUnchecked(
+ {bool inFunctionType: false}) {
+ return _parseFormalParameterListAfterParen(getAndAdvance(),
+ inFunctionType: inFunctionType);
}
/**
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 6e3ecfc..43146a2 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -2283,8 +2283,16 @@
* by a [DirectiveElementBuilder].
*/
class DirectiveResolver extends SimpleAstVisitor {
+ final Map<Source, int> sourceModificationTimeMap;
+ final Map<Source, SourceKind> importSourceKindMap;
+ final Map<Source, SourceKind> exportSourceKindMap;
+ final List<AnalysisError> errors = <AnalysisError>[];
+
LibraryElement _enclosingLibrary;
+ DirectiveResolver(this.sourceModificationTimeMap, this.importSourceKindMap,
+ this.exportSourceKindMap);
+
@override
void visitCompilationUnit(CompilationUnit node) {
_enclosingLibrary =
@@ -2301,6 +2309,19 @@
for (ExportElement element in _enclosingLibrary.exports) {
if (element.nameOffset == nodeOffset) {
node.element = element;
+ // Verify the exported source kind.
+ Source exportedSource = element.exportedLibrary.source;
+ int exportedTime = sourceModificationTimeMap[exportedSource] ?? -1;
+ if (exportedTime >= 0 &&
+ exportSourceKindMap[exportedSource] != SourceKind.LIBRARY) {
+ StringLiteral uriLiteral = node.uri;
+ errors.add(new AnalysisError(
+ _enclosingLibrary.source,
+ uriLiteral.offset,
+ uriLiteral.length,
+ CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
+ [uriLiteral.toSource()]));
+ }
break;
}
}
@@ -2313,6 +2334,22 @@
for (ImportElement element in _enclosingLibrary.imports) {
if (element.nameOffset == nodeOffset) {
node.element = element;
+ // Verify the imported source kind.
+ Source importedSource = element.importedLibrary.source;
+ int importedTime = sourceModificationTimeMap[importedSource] ?? -1;
+ if (importedTime >= 0 &&
+ importSourceKindMap[importedSource] != SourceKind.LIBRARY) {
+ StringLiteral uriLiteral = node.uri;
+ ErrorCode errorCode = element.isDeferred
+ ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
+ : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY;
+ errors.add(new AnalysisError(
+ _enclosingLibrary.source,
+ uriLiteral.offset,
+ uriLiteral.length,
+ errorCode,
+ [uriLiteral.toSource()]));
+ }
break;
}
}
diff --git a/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart b/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart
index 826ee7d..2139d38 100644
--- a/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart
+++ b/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart
@@ -50,6 +50,16 @@
astFactory.asExpression(
expression, TokenFactory.tokenFromKeyword(Keyword.AS), type);
+ static AssertInitializer assertInitializer(
+ Expression condition, Expression message) =>
+ astFactory.assertInitializer(
+ TokenFactory.tokenFromKeyword(Keyword.ASSERT),
+ TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
+ condition,
+ TokenFactory.tokenFromType(TokenType.COMMA),
+ message,
+ TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
+
static AssertStatement assertStatement(Expression condition,
[Expression message]) =>
astFactory.assertStatement(
diff --git a/pkg/analyzer/lib/src/summary/format.fbs b/pkg/analyzer/lib/src/summary/format.fbs
index d918405..b04f94b 100644
--- a/pkg/analyzer/lib/src/summary/format.fbs
+++ b/pkg/analyzer/lib/src/summary/format.fbs
@@ -226,7 +226,12 @@
/**
* Invocation of a superclass' constructor.
*/
- superInvocation
+ superInvocation,
+
+ /**
+ * Invocation of `assert`.
+ */
+ assertInvocation
}
/**
@@ -802,7 +807,12 @@
* a constant has an error, we can omit the subexpression containing the error
* and only include a marker that an error was detected.
*/
- pushError
+ pushError,
+
+ /**
+ * Push `this` expression onto the stack.
+ */
+ pushThis
}
/**
diff --git a/pkg/analyzer/lib/src/summary/idl.dart b/pkg/analyzer/lib/src/summary/idl.dart
index 6eb2dcc..c3894ca 100644
--- a/pkg/analyzer/lib/src/summary/idl.dart
+++ b/pkg/analyzer/lib/src/summary/idl.dart
@@ -1347,7 +1347,12 @@
/**
* Invocation of a superclass' constructor.
*/
- superInvocation
+ superInvocation,
+
+ /**
+ * Invocation of `assert`.
+ */
+ assertInvocation
}
/**
@@ -2378,6 +2383,11 @@
* and only include a marker that an error was detected.
*/
pushError,
+
+ /**
+ * Push `this` expression onto the stack.
+ */
+ pushThis,
}
/**
diff --git a/pkg/analyzer/lib/src/summary/package_bundle_reader.dart b/pkg/analyzer/lib/src/summary/package_bundle_reader.dart
index 76dc164..24f19d8 100644
--- a/pkg/analyzer/lib/src/summary/package_bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary/package_bundle_reader.dart
@@ -218,14 +218,12 @@
result as ResultDescriptor<int>, 0, TargetedResult.EMPTY_LIST);
return true;
} else if (result == SOURCE_KIND) {
- if (_dataStore.linkedMap.containsKey(uriString)) {
- entry.setValue(result as ResultDescriptor<SourceKind>,
- SourceKind.LIBRARY, TargetedResult.EMPTY_LIST);
- return true;
- }
- if (_dataStore.unlinkedMap.containsKey(uriString)) {
- entry.setValue(result as ResultDescriptor<SourceKind>,
- SourceKind.PART, TargetedResult.EMPTY_LIST);
+ UnlinkedUnit unlinked = _dataStore.unlinkedMap[uriString];
+ if (unlinked != null) {
+ entry.setValue(
+ result as ResultDescriptor<SourceKind>,
+ unlinked.isPartOf ? SourceKind.PART : SourceKind.LIBRARY,
+ TargetedResult.EMPTY_LIST);
return true;
}
return false;
diff --git a/pkg/analyzer/lib/src/summary/public_namespace_computer.dart b/pkg/analyzer/lib/src/summary/public_namespace_computer.dart
index 9a8bd50..203043a 100644
--- a/pkg/analyzer/lib/src/summary/public_namespace_computer.dart
+++ b/pkg/analyzer/lib/src/summary/public_namespace_computer.dart
@@ -178,7 +178,7 @@
@override
visitPartDirective(PartDirective node) {
- parts.add(node.uri.stringValue);
+ parts.add(node.uri.stringValue ?? '');
}
@override
diff --git a/pkg/analyzer/lib/src/summary/resynthesize.dart b/pkg/analyzer/lib/src/summary/resynthesize.dart
index 73f6b8a..aca2852 100644
--- a/pkg/analyzer/lib/src/summary/resynthesize.dart
+++ b/pkg/analyzer/lib/src/summary/resynthesize.dart
@@ -515,6 +515,9 @@
Expression expression = _pop();
_push(AstTestFactory.awaitExpression(expression));
break;
+ case UnlinkedExprOperation.pushThis:
+ _push(AstTestFactory.thisExpression());
+ break;
case UnlinkedExprOperation.assignToRef:
case UnlinkedExprOperation.assignToProperty:
case UnlinkedExprOperation.assignToIndex:
diff --git a/pkg/analyzer/lib/src/summary/summarize_const_expr.dart b/pkg/analyzer/lib/src/summary/summarize_const_expr.dart
index e3a9017..52ad3bc 100644
--- a/pkg/analyzer/lib/src/summary/summarize_const_expr.dart
+++ b/pkg/analyzer/lib/src/summary/summarize_const_expr.dart
@@ -36,6 +36,14 @@
}
}
+ if (node is AssertInitializer) {
+ serializeArguments(node.message != null
+ ? [node.condition, node.message]
+ : [node.condition]);
+ return new UnlinkedConstructorInitializerBuilder(
+ kind: UnlinkedConstructorInitializerKind.assertInvocation,
+ arguments: arguments);
+ }
if (node is RedirectingConstructorInvocation) {
serializeArguments(node.argumentList.arguments);
return new UnlinkedConstructorInitializerBuilder(
@@ -380,6 +388,8 @@
_serialize(expr.expression);
references.add(serializeTypeName(expr.type));
operations.add(UnlinkedExprOperation.typeCheck);
+ } else if (expr is ThisExpression) {
+ operations.add(UnlinkedExprOperation.pushThis);
} else if (expr is ThrowExpression) {
isValidConst = false;
_serialize(expr.expression);
diff --git a/pkg/analyzer/lib/src/task/dart.dart b/pkg/analyzer/lib/src/task/dart.dart
index 6de317c..d842d2f 100644
--- a/pkg/analyzer/lib/src/task/dart.dart
+++ b/pkg/analyzer/lib/src/task/dart.dart
@@ -116,7 +116,7 @@
const SimpleResultCachingPolicy(-1, -1);
/**
- * The errors produced while resolving a library directives.
+ * The errors produced while building a library's directives.
*
* The list will be empty if there were no errors, but will not be `null`.
*
@@ -125,7 +125,6 @@
final ListResultDescriptor<AnalysisError> BUILD_DIRECTIVES_ERRORS =
new ListResultDescriptor<AnalysisError>(
'BUILD_DIRECTIVES_ERRORS', AnalysisError.NO_ERRORS);
-
/**
* The errors produced while building a library element.
*
@@ -352,6 +351,7 @@
HINTS,
LIBRARY_UNIT_ERRORS,
LINTS,
+ RESOLVE_DIRECTIVES_ERRORS,
RESOLVE_TYPE_BOUNDS_ERRORS,
RESOLVE_TYPE_NAMES_ERRORS,
RESOLVE_UNIT_ERRORS,
@@ -705,6 +705,17 @@
'REQUIRED_CONSTANTS', const <ConstantEvaluationTarget>[]);
/**
+ * The errors produced while resolving a library's directives.
+ *
+ * The list will be empty if there were no errors, but will not be `null`.
+ *
+ * The result is only available for [Source]s representing a library.
+ */
+final ListResultDescriptor<AnalysisError> RESOLVE_DIRECTIVES_ERRORS =
+ new ListResultDescriptor<AnalysisError>(
+ 'RESOLVE_DIRECTIVES_ERRORS', AnalysisError.NO_ERRORS);
+
+/**
* The errors produced while resolving bounds of type parameters of classes,
* class and function aliases.
*
@@ -1232,8 +1243,10 @@
libraryElement.invalidateLibraryCycles();
errors = builder.errors;
} else {
- DirectiveResolver resolver = new DirectiveResolver();
+ DirectiveResolver resolver = new DirectiveResolver(
+ sourceModificationTimeMap, importSourceKindMap, exportSourceKindMap);
libraryUnit.accept(resolver);
+ errors = resolver.errors;
}
//
// Record outputs.
@@ -3868,6 +3881,12 @@
'STATIC_VARIABLE_RESOLUTION_ERRORS_INPUT';
/**
+ * The name of the [RESOLVE_DIRECTIVES_ERRORS] input.
+ */
+ static const String RESOLVE_DIRECTIVES_ERRORS_INPUT =
+ 'RESOLVE_DIRECTIVES_ERRORS';
+
+ /**
* The name of the [STRONG_MODE_ERRORS] input.
*/
static const String STRONG_MODE_ERRORS_INPUT = 'STRONG_MODE_ERRORS';
@@ -3925,6 +3944,7 @@
errorLists.add(getRequiredInput(BUILD_LIBRARY_ERRORS_INPUT));
errorLists.add(getRequiredInput(HINTS_INPUT));
errorLists.add(getRequiredInput(LINTS_INPUT));
+ errorLists.add(getRequiredInput(RESOLVE_DIRECTIVES_ERRORS_INPUT));
errorLists.add(getRequiredInput(RESOLVE_TYPE_NAMES_ERRORS_INPUT));
errorLists.add(getRequiredInput(RESOLVE_TYPE_NAMES_ERRORS2_INPUT));
errorLists.add(getRequiredInput(RESOLVE_UNIT_ERRORS_INPUT));
@@ -3948,6 +3968,7 @@
Map<String, TaskInput> inputs = <String, TaskInput>{
HINTS_INPUT: HINTS.of(unit),
LINTS_INPUT: LINTS.of(unit),
+ RESOLVE_DIRECTIVES_ERRORS_INPUT: RESOLVE_DIRECTIVES_ERRORS.of(unit),
RESOLVE_TYPE_NAMES_ERRORS_INPUT: RESOLVE_TYPE_NAMES_ERRORS.of(unit),
RESOLVE_TYPE_NAMES_ERRORS2_INPUT: RESOLVE_TYPE_BOUNDS_ERRORS.of(unit),
RESOLVE_UNIT_ERRORS_INPUT: RESOLVE_UNIT_ERRORS.of(unit),
@@ -5017,14 +5038,22 @@
*/
static const String UNIT_INPUT = 'UNIT_INPUT';
+ static const String SOURCES_MODIFICATION_TIME_INPUT =
+ 'SOURCES_MODIFICATION_TIME_INPUT';
+ static const String IMPORTS_SOURCE_KIND_INPUT = 'IMPORTS_SOURCE_KIND_INPUT';
+ static const String EXPORTS_SOURCE_KIND_INPUT = 'EXPORTS_SOURCE_KIND_INPUT';
+
/**
* The task descriptor describing this kind of task.
*/
static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
'ResolveDirectiveElementsTask',
createTask,
- buildInputs,
- <ResultDescriptor>[CREATED_RESOLVED_UNIT2, RESOLVED_UNIT2]);
+ buildInputs, <ResultDescriptor>[
+ CREATED_RESOLVED_UNIT2,
+ RESOLVED_UNIT2,
+ RESOLVE_DIRECTIVES_ERRORS
+ ]);
ResolveDirectiveElementsTask(
InternalAnalysisContext context, AnalysisTarget target)
@@ -5040,18 +5069,28 @@
// Prepare inputs.
//
CompilationUnit unit = getRequiredInput(UNIT_INPUT);
+ Map<Source, int> sourceModificationTimeMap =
+ getRequiredInput(SOURCES_MODIFICATION_TIME_INPUT);
+ Map<Source, SourceKind> importSourceKindMap =
+ getRequiredInput(IMPORTS_SOURCE_KIND_INPUT);
+ Map<Source, SourceKind> exportSourceKindMap =
+ getRequiredInput(EXPORTS_SOURCE_KIND_INPUT);
//
// Resolve directive AST nodes to elements.
//
+ List<AnalysisError> errors = const <AnalysisError>[];
if (targetUnit.unit == targetUnit.library) {
- DirectiveResolver resolver = new DirectiveResolver();
+ DirectiveResolver resolver = new DirectiveResolver(
+ sourceModificationTimeMap, importSourceKindMap, exportSourceKindMap);
unit.accept(resolver);
+ errors = resolver.errors;
}
//
// Record outputs.
//
outputs[CREATED_RESOLVED_UNIT2] = true;
outputs[RESOLVED_UNIT2] = unit;
+ outputs[RESOLVE_DIRECTIVES_ERRORS] = errors;
}
/**
@@ -5063,7 +5102,13 @@
LibrarySpecificUnit unit = target;
return <String, TaskInput>{
LIBRARY_INPUT: LIBRARY_ELEMENT2.of(unit.library),
- UNIT_INPUT: RESOLVED_UNIT1.of(unit)
+ UNIT_INPUT: RESOLVED_UNIT1.of(unit),
+ SOURCES_MODIFICATION_TIME_INPUT:
+ REFERENCED_SOURCES.of(unit.library).toMapOf(MODIFICATION_TIME),
+ IMPORTS_SOURCE_KIND_INPUT:
+ IMPORTED_LIBRARIES.of(unit.library).toMapOf(SOURCE_KIND),
+ EXPORTS_SOURCE_KIND_INPUT:
+ EXPORTED_LIBRARIES.of(unit.library).toMapOf(SOURCE_KIND)
};
}
diff --git a/pkg/analyzer/lib/src/task/dart_work_manager.dart b/pkg/analyzer/lib/src/task/dart_work_manager.dart
index aecdba4..0a56cd8 100644
--- a/pkg/analyzer/lib/src/task/dart_work_manager.dart
+++ b/pkg/analyzer/lib/src/task/dart_work_manager.dart
@@ -40,6 +40,7 @@
HINTS,
LINTS,
LIBRARY_UNIT_ERRORS,
+ RESOLVE_DIRECTIVES_ERRORS,
RESOLVE_TYPE_NAMES_ERRORS,
RESOLVE_TYPE_BOUNDS_ERRORS,
RESOLVE_UNIT_ERRORS,
diff --git a/pkg/analyzer/lib/src/task/strong_mode.dart b/pkg/analyzer/lib/src/task/strong_mode.dart
index d60460e..c5b6bad 100644
--- a/pkg/analyzer/lib/src/task/strong_mode.dart
+++ b/pkg/analyzer/lib/src/task/strong_mode.dart
@@ -79,11 +79,12 @@
/**
* Initialize a newly create inferrer.
*/
- InstanceMemberInferrer(this.typeProvider, this.inheritanceManager,
+ InstanceMemberInferrer(TypeProvider typeProvider, this.inheritanceManager,
{TypeSystem typeSystem})
: typeSystem = (typeSystem != null)
? typeSystem
- : new TypeSystemImpl(typeProvider);
+ : new TypeSystemImpl(typeProvider),
+ this.typeProvider = typeProvider;
/**
* Infer type information for all of the instance members in the given
diff --git a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart
new file mode 100644
index 0000000..b8d01e9
--- /dev/null
+++ b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_driver_test.dart
@@ -0,0 +1,20 @@
+// 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'checked_mode_compile_time_error_code_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(CheckedModeCompileTimeErrorCodeTest_Driver);
+ });
+}
+
+@reflectiveTest
+class CheckedModeCompileTimeErrorCodeTest_Driver
+ extends CheckedModeCompileTimeErrorCodeTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart
index e948278..6a7256c 100644
--- a/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart
+++ b/pkg/analyzer/test/generated/checked_mode_compile_time_error_code_test.dart
@@ -13,7 +13,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
- defineReflectiveTests(CheckedModeCompileTimeErrorCodeTest_Driver);
});
}
@@ -618,10 +617,3 @@
verify([source]);
}
}
-
-@reflectiveTest
-class CheckedModeCompileTimeErrorCodeTest_Driver
- extends CheckedModeCompileTimeErrorCodeTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart b/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart
index 96200ce..04e0671 100644
--- a/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart
+++ b/pkg/analyzer/test/generated/compile_time_error_code_driver_test.dart
@@ -19,12 +19,6 @@
@failingTest
@override
- test_exportOfNonLibrary() {
- return super.test_exportOfNonLibrary();
- }
-
- @failingTest
- @override
test_fieldInitializerOutsideConstructor_inFunctionTypeParameter() {
return super
.test_fieldInitializerOutsideConstructor_inFunctionTypeParameter();
@@ -38,24 +32,6 @@
@failingTest
@override
- test_importOfNonLibrary() {
- return super.test_importOfNonLibrary();
- }
-
- @failingTest
- @override
- test_nonConstValueInInitializer_assert_condition() {
- return super.test_nonConstValueInInitializer_assert_condition();
- }
-
- @failingTest
- @override
- test_nonConstValueInInitializer_assert_message() {
- return super.test_nonConstValueInInitializer_assert_message();
- }
-
- @failingTest
- @override
test_prefixCollidesWithTopLevelMembers_functionTypeAlias() {
return super.test_prefixCollidesWithTopLevelMembers_functionTypeAlias();
}
@@ -89,16 +65,4 @@
test_uriDoesNotExist_import_appears_after_deleting_target() {
return super.test_uriDoesNotExist_import_appears_after_deleting_target();
}
-
- @failingTest
- @override
- test_uriDoesNotExist_import_disappears_when_fixed() {
- return super.test_uriDoesNotExist_import_disappears_when_fixed();
- }
-
- @failingTest
- @override
- test_uriWithInterpolation_nonConstant() {
- return super.test_uriWithInterpolation_nonConstant();
- }
}
diff --git a/pkg/analyzer/test/generated/compile_time_error_code_test.dart b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
index b3e4254..6577d9f 100644
--- a/pkg/analyzer/test/generated/compile_time_error_code_test.dart
+++ b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
@@ -6172,16 +6172,21 @@
await computeAnalysisResult(source);
assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
- // Check that the file is represented as missing.
- Source target = analysisContext2
- .getSourcesWithFullName(resourceProvider.convertPath("/target.dart"))
- .first;
- expect(analysisContext2.getModificationStamp(target), -1);
+ String targetPath = resourceProvider.convertPath('/target.dart');
+ if (enableNewAnalysisDriver) {
+ // Add an overlay in the same way as AnalysisServer.
+ fileContentOverlay[targetPath] = '';
+ driver.changeFile(targetPath);
+ } else {
+ // Check that the file is represented as missing.
+ Source target = analysisContext2.getSourcesWithFullName(targetPath).first;
+ expect(analysisContext2.getModificationStamp(target), -1);
- // Add an overlay in the same way as AnalysisServer.
- analysisContext2
- ..setContents(target, "")
- ..handleContentsChanged(target, null, "", true);
+ // Add an overlay in the same way as AnalysisServer.
+ analysisContext2
+ ..setContents(target, "")
+ ..handleContentsChanged(target, null, "", true);
+ }
// Make sure the error goes away.
await computeAnalysisResult(source);
diff --git a/pkg/analyzer/test/generated/error_suppression_driver_test.dart b/pkg/analyzer/test/generated/error_suppression_driver_test.dart
new file mode 100644
index 0000000..6e2273d
--- /dev/null
+++ b/pkg/analyzer/test/generated/error_suppression_driver_test.dart
@@ -0,0 +1,20 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'error_suppression_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(ErrorSuppressionTest);
+ defineReflectiveTests(ErrorSuppressionTest_Driver);
+ });
+}
+
+@reflectiveTest
+class ErrorSuppressionTest_Driver extends ErrorSuppressionTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analyzer/test/generated/error_suppression_test.dart b/pkg/analyzer/test/generated/error_suppression_test.dart
index ea353b2..62d525e 100644
--- a/pkg/analyzer/test/generated/error_suppression_test.dart
+++ b/pkg/analyzer/test/generated/error_suppression_test.dart
@@ -12,7 +12,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(ErrorSuppressionTest);
- defineReflectiveTests(ErrorSuppressionTest_Driver);
});
}
@@ -197,9 +196,3 @@
]);
}
}
-
-@reflectiveTest
-class ErrorSuppressionTest_Driver extends ErrorSuppressionTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analyzer/test/generated/non_hint_code_driver_test.dart b/pkg/analyzer/test/generated/non_hint_code_driver_test.dart
new file mode 100644
index 0000000..d13f558
--- /dev/null
+++ b/pkg/analyzer/test/generated/non_hint_code_driver_test.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'non_hint_code_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(NonHintCodeTest_Driver);
+ });
+}
+
+@reflectiveTest
+class NonHintCodeTest_Driver extends NonHintCodeTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analyzer/test/generated/non_hint_code_test.dart b/pkg/analyzer/test/generated/non_hint_code_test.dart
index 04a5623..9954b62 100644
--- a/pkg/analyzer/test/generated/non_hint_code_test.dart
+++ b/pkg/analyzer/test/generated/non_hint_code_test.dart
@@ -15,7 +15,6 @@
main() {
defineReflectiveSuite(() {
defineReflectiveTests(NonHintCodeTest);
- defineReflectiveTests(NonHintCodeTest_Driver);
});
}
@@ -1281,12 +1280,6 @@
}
}
-@reflectiveTest
-class NonHintCodeTest_Driver extends NonHintCodeTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
-
class PubSuggestionCodeTest extends ResolverTestCase {
test_import_package() async {
Source source = addSource("import 'package:somepackage/other.dart';");
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 9a2611f..41ae0f4 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -866,14 +866,31 @@
listener.assertNoErrors();
}
- void test_deprecatedClassTypeAlias() {
- ParserTestCase.parseCompilationUnit(
- "typedef C = S with M;", [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+ void test_defaultValueInFunctionType_named_colon() {
+ createParser('int x : 0');
+ FormalParameter parameter =
+ parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertErrorsWithCodes(
+ [ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE]);
}
- void test_deprecatedClassTypeAlias_withGeneric() {
- ParserTestCase.parseCompilationUnit("typedef C<T> = S<T> with M;",
- [ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS]);
+ void test_defaultValueInFunctionType_named_equal() {
+ createParser('int x = 0');
+ FormalParameter parameter =
+ parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertErrorsWithCodes(
+ [ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE]);
+ }
+
+ void test_defaultValueInFunctionType_positional() {
+ createParser('int x = 0');
+ FormalParameter parameter = parser
+ .parseFormalParameter(ParameterKind.POSITIONAL, inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertErrorsWithCodes(
+ [ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE]);
}
void test_directiveAfterDeclaration_classBeforeDirective() {
@@ -1090,15 +1107,6 @@
[ParserErrorCode.EXPECTED_TOKEN, ParserErrorCode.MISSING_IDENTIFIER]);
}
- void test_expectedToken_semicolonAfterClass() {
- Token token = TokenFactory.tokenFromKeyword(Keyword.CLASS);
- createParser('A = B with C');
- ClassTypeAlias declaration =
- parser.parseClassTypeAlias(emptyCommentAndMetadata(), null, token);
- expectNotNullIfNoErrors(declaration);
- listener.assertErrorsWithCodes([ParserErrorCode.EXPECTED_TOKEN]);
- }
-
void test_expectedToken_semicolonMissingAfterExport() {
CompilationUnit unit = ParserTestCase.parseCompilationUnit(
"export '' class A {}", [ParserErrorCode.EXPECTED_TOKEN]);
@@ -2002,6 +2010,37 @@
listener.assertErrorsWithCodes([ParserErrorCode.MISSING_METHOD_PARAMETERS]);
}
+ void test_missingNameForNamedParameter_colon() {
+ createParser('int : 0');
+ FormalParameter parameter =
+ parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertErrorsWithCodes([
+ ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE,
+ ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER
+ ]);
+ }
+
+ void test_missingNameForNamedParameter_equals() {
+ createParser('int = 0');
+ FormalParameter parameter =
+ parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertErrorsWithCodes([
+ ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE,
+ ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER
+ ]);
+ }
+
+ void test_missingNameForNamedParameter_noDefault() {
+ createParser('int');
+ FormalParameter parameter =
+ parser.parseFormalParameter(ParameterKind.NAMED, inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertErrorsWithCodes(
+ [ParserErrorCode.MISSING_NAME_FOR_NAMED_PARAMETER]);
+ }
+
void test_missingNameInLibraryDirective() {
CompilationUnit unit = ParserTestCase.parseCompilationUnit(
"library;", [ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE]);
@@ -6438,75 +6477,6 @@
expect(constructor.body, isNotNull);
}
- void test_parseClassTypeAlias_abstract() {
- Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
- Token abstractToken = TokenFactory.tokenFromKeyword(Keyword.ABSTRACT);
- createParser('A = B with C;');
- ClassTypeAlias classTypeAlias = parser.parseClassTypeAlias(
- emptyCommentAndMetadata(), abstractToken, classToken);
- expectNotNullIfNoErrors(classTypeAlias);
- listener.assertNoErrors();
- expect(classTypeAlias.typedefKeyword, isNotNull);
- expect(classTypeAlias.name.name, "A");
- expect(classTypeAlias.equals, isNotNull);
- expect(classTypeAlias.abstractKeyword, isNotNull);
- expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
- expect(classTypeAlias.withClause, isNotNull);
- expect(classTypeAlias.implementsClause, isNull);
- expect(classTypeAlias.semicolon, isNotNull);
- }
-
- void test_parseClassTypeAlias_implements() {
- Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
- createParser('A = B with C implements D;');
- ClassTypeAlias classTypeAlias =
- parser.parseClassTypeAlias(emptyCommentAndMetadata(), null, classToken);
- expectNotNullIfNoErrors(classTypeAlias);
- listener.assertNoErrors();
- expect(classTypeAlias.typedefKeyword, isNotNull);
- expect(classTypeAlias.name.name, "A");
- expect(classTypeAlias.equals, isNotNull);
- expect(classTypeAlias.abstractKeyword, isNull);
- expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
- expect(classTypeAlias.withClause, isNotNull);
- expect(classTypeAlias.implementsClause, isNotNull);
- expect(classTypeAlias.semicolon, isNotNull);
- }
-
- void test_parseClassTypeAlias_with() {
- Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
- createParser('A = B with C;');
- ClassTypeAlias classTypeAlias =
- parser.parseClassTypeAlias(emptyCommentAndMetadata(), null, classToken);
- expectNotNullIfNoErrors(classTypeAlias);
- listener.assertNoErrors();
- expect(classTypeAlias.typedefKeyword, isNotNull);
- expect(classTypeAlias.name.name, "A");
- expect(classTypeAlias.equals, isNotNull);
- expect(classTypeAlias.abstractKeyword, isNull);
- expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
- expect(classTypeAlias.withClause, isNotNull);
- expect(classTypeAlias.implementsClause, isNull);
- expect(classTypeAlias.semicolon, isNotNull);
- }
-
- void test_parseClassTypeAlias_with_implements() {
- Token classToken = TokenFactory.tokenFromKeyword(Keyword.CLASS);
- createParser('A = B with C implements D;');
- ClassTypeAlias classTypeAlias =
- parser.parseClassTypeAlias(emptyCommentAndMetadata(), null, classToken);
- expectNotNullIfNoErrors(classTypeAlias);
- listener.assertNoErrors();
- expect(classTypeAlias.typedefKeyword, isNotNull);
- expect(classTypeAlias.name.name, "A");
- expect(classTypeAlias.equals, isNotNull);
- expect(classTypeAlias.abstractKeyword, isNull);
- expect(classTypeAlias.superclass.name.name, isNotNull, reason: "B");
- expect(classTypeAlias.withClause, isNotNull);
- expect(classTypeAlias.implementsClause, isNotNull);
- expect(classTypeAlias.semicolon, isNotNull);
- }
-
void test_parseCombinator_hide() {
createParser('hide a;');
Combinator combinator = parser.parseCombinator();
@@ -8486,6 +8456,30 @@
expect(clause.superclass, new isInstanceOf<TypeName>());
}
+ void test_parseFinalConstVarOrType_const_functionType() {
+ createParser('const int Function(int) f');
+ FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
+ expectNotNullIfNoErrors(result);
+ listener.assertNoErrors();
+ Token keyword = result.keyword;
+ expect(keyword, isNotNull);
+ expect(keyword.type, TokenType.KEYWORD);
+ expect(keyword.keyword, Keyword.CONST);
+ expect(result.type, isNotNull);
+ }
+
+ void test_parseFinalConstVarOrType_const_namedType() {
+ createParser('const A a');
+ FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
+ expectNotNullIfNoErrors(result);
+ listener.assertNoErrors();
+ Token keyword = result.keyword;
+ expect(keyword, isNotNull);
+ expect(keyword.type, TokenType.KEYWORD);
+ expect(keyword.keyword, Keyword.CONST);
+ expect(result.type, isNotNull);
+ }
+
void test_parseFinalConstVarOrType_const_noType() {
createParser('const');
FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
@@ -8498,15 +8492,27 @@
expect(result.type, isNull);
}
- void test_parseFinalConstVarOrType_const_type() {
- createParser('const A a');
+ void test_parseFinalConstVarOrType_final_functionType() {
+ createParser('final int Function(int) f');
FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
expectNotNullIfNoErrors(result);
listener.assertNoErrors();
Token keyword = result.keyword;
expect(keyword, isNotNull);
expect(keyword.type, TokenType.KEYWORD);
- expect(keyword.keyword, Keyword.CONST);
+ expect(keyword.keyword, Keyword.FINAL);
+ expect(result.type, isNotNull);
+ }
+
+ void test_parseFinalConstVarOrType_final_namedType() {
+ createParser('final A a');
+ FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
+ expectNotNullIfNoErrors(result);
+ listener.assertNoErrors();
+ Token keyword = result.keyword;
+ expect(keyword, isNotNull);
+ expect(keyword.type, TokenType.KEYWORD);
+ expect(keyword.keyword, Keyword.FINAL);
expect(result.type, isNotNull);
}
@@ -8534,15 +8540,12 @@
expect(result.type, isNotNull);
}
- void test_parseFinalConstVarOrType_final_type() {
- createParser('final A a');
+ void test_parseFinalConstVarOrType_type_function() {
+ createParser('int Function(int) f');
FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
expectNotNullIfNoErrors(result);
listener.assertNoErrors();
- Token keyword = result.keyword;
- expect(keyword, isNotNull);
- expect(keyword.type, TokenType.KEYWORD);
- expect(keyword.keyword, Keyword.FINAL);
+ expect(result.keyword, isNull);
expect(result.type, isNotNull);
}
@@ -8591,6 +8594,16 @@
expect(result.type, isNotNull);
}
+ void test_parseFinalConstVarOrType_type_simple_noIdentifier_inFunctionType() {
+ createParser('A,');
+ FinalConstVarOrType result =
+ parser.parseFinalConstVarOrType(false, inFunctionType: true);
+ expectNotNullIfNoErrors(result);
+ listener.assertNoErrors();
+ expect(result.keyword, isNull);
+ expect(result.type, isNotNull);
+ }
+
void test_parseFinalConstVarOrType_var() {
createParser('var');
FinalConstVarOrType result = parser.parseFinalConstVarOrType(false);
@@ -8849,6 +8862,34 @@
expect(list.rightParenthesis, isNotNull);
}
+ void test_parseFormalParameterList_normal_named_inFunctionType() {
+ createParser('(A, {B b})');
+ FormalParameterList list =
+ parser.parseFormalParameterList(inFunctionType: true);
+ expectNotNullIfNoErrors(list);
+ listener.assertNoErrors();
+ expect(list.leftParenthesis, isNotNull);
+ expect(list.leftDelimiter, isNotNull);
+ expect(list.rightDelimiter, isNotNull);
+ expect(list.rightParenthesis, isNotNull);
+ NodeList<FormalParameter> parameters = list.parameters;
+ expect(parameters, hasLength(2));
+
+ expect(parameters[0], new isInstanceOf<SimpleFormalParameter>());
+ SimpleFormalParameter required = parameters[0];
+ expect(required.identifier, isNull);
+ expect(required.type, new isInstanceOf<TypeName>());
+ expect((required.type as TypeName).name.name, 'A');
+
+ expect(parameters[1], new isInstanceOf<DefaultFormalParameter>());
+ DefaultFormalParameter named = parameters[1];
+ expect(named.identifier, isNotNull);
+ expect(named.parameter, new isInstanceOf<SimpleFormalParameter>());
+ SimpleFormalParameter simple = named.parameter;
+ expect(simple.type, new isInstanceOf<TypeName>());
+ expect((simple.type as TypeName).name.name, 'B');
+ }
+
void test_parseFormalParameterList_normal_positional() {
createParser('(A a, [B b])');
FormalParameterList list = parser.parseFormalParameterList();
@@ -9599,6 +9640,34 @@
expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
}
+ void test_parseGenericTypeAlias_noTypeParameters() {
+ createParser('F = int Function(int);');
+ GenericTypeAlias alias =
+ parser.parseGenericTypeAlias(emptyCommentAndMetadata(), null);
+ expectNotNullIfNoErrors(alias);
+ listener.assertNoErrors();
+ expect(alias.name, isNotNull);
+ expect(alias.name.name, 'F');
+ expect(alias.typeParameters, isNull);
+ expect(alias.equals, isNotNull);
+ expect(alias.functionType, isNotNull);
+ expect(alias.semicolon, isNotNull);
+ }
+
+ void test_parseGenericTypeAlias_typeParameters() {
+ createParser('F<T> = T Function(T);');
+ GenericTypeAlias alias =
+ parser.parseGenericTypeAlias(emptyCommentAndMetadata(), null);
+ expectNotNullIfNoErrors(alias);
+ listener.assertNoErrors();
+ expect(alias.name, isNotNull);
+ expect(alias.name.name, 'F');
+ expect(alias.typeParameters, isNotNull);
+ expect(alias.equals, isNotNull);
+ expect(alias.functionType, isNotNull);
+ expect(alias.semicolon, isNotNull);
+ }
+
void test_parseGetter_nonStatic() {
Comment comment = astFactory.documentationComment(new List<Token>(0));
TypeName returnType =
@@ -11059,6 +11128,19 @@
expect(simpleParameter.identifier, isNotNull);
}
+ void test_parseNormalFormalParameter_simple_noName() {
+ createParser('a)');
+ NormalFormalParameter parameter =
+ parser.parseNormalFormalParameter(inFunctionType: true);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertNoErrors();
+ expect(parameter, new isInstanceOf<SimpleFormalParameter>());
+ SimpleFormalParameter simpleParameter = parameter;
+ expect(simpleParameter.keyword, isNull);
+ expect(simpleParameter.type, isNotNull);
+ expect(simpleParameter.identifier, isNull);
+ }
+
void test_parseNormalFormalParameter_simple_noType() {
createParser('a)');
NormalFormalParameter parameter = parser.parseNormalFormalParameter();
@@ -12640,6 +12722,381 @@
expect(typeAlias.typeParameters, isNull);
}
+ void test_parseTypeAlias_genericFunction_noParameters() {
+ createParser('typedef F = bool Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_noReturnType() {
+ createParser('typedef F = Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_parameterizedReturnType() {
+ createParser('typedef F = A<B> Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_parameters() {
+ createParser('typedef F = bool Function(Object value);');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_typeParameters() {
+ createParser('typedef F = bool Function<E>();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNotNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_typeParameters_noParameters() {
+ createParser('typedef F<T> = bool Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNotNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_typeParameters_noReturnType() {
+ createParser('typedef F<T> = Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNotNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void
+ test_parseTypeAlias_genericFunction_typeParameters_parameterizedReturnType() {
+ createParser('typedef F<T> = A<B> Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNotNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_typeParameters_parameters() {
+ createParser('typedef F<T> = bool Function(Object value);');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNotNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_typeParameters_typeParameters() {
+ createParser('typedef F<T> = bool Function<E>();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNotNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNotNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_typeParameters_voidReturnType() {
+ createParser('typedef F<T> = void Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNotNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAlias_genericFunction_voidReturnType() {
+ createParser('typedef F = void Function();');
+ GenericTypeAlias typeAlias =
+ parser.parseTypeAlias(emptyCommentAndMetadata());
+ expectNotNullIfNoErrors(typeAlias);
+ listener.assertNoErrors();
+ expect(typeAlias.typedefKeyword, isNotNull);
+ expect(typeAlias.name, isNotNull);
+ expect(typeAlias.typeParameters, isNull);
+ expect(typeAlias.semicolon, isNotNull);
+ GenericFunctionType functionType = typeAlias.functionType;
+ expect(functionType, isNotNull);
+ expect(functionType.parameters, isNotNull);
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ }
+
+ void test_parseTypeAnnotation_function_noReturnType_noParameters() {
+ createParser('Function() v');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNull);
+ expect(functionType.functionKeyword, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ expect(parameterList.parameters, hasLength(0));
+ }
+
+ void test_parseTypeAnnotation_function_noReturnType_parameters() {
+ createParser('Function(int, int) v');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNull);
+ expect(functionType.functionKeyword, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ NodeList<FormalParameter> parameters = parameterList.parameters;
+ expect(parameters, hasLength(2));
+
+ expect(parameters[0], new isInstanceOf<SimpleFormalParameter>());
+ SimpleFormalParameter parameter = parameters[0];
+ expect(parameter.identifier, isNull);
+ expect(parameter.type, new isInstanceOf<TypeName>());
+ expect((parameter.type as TypeName).name.name, 'int');
+
+ expect(parameters[1], new isInstanceOf<SimpleFormalParameter>());
+ parameter = parameters[1];
+ expect(parameter.identifier, isNull);
+ expect(parameter.type, new isInstanceOf<TypeName>());
+ expect((parameter.type as TypeName).name.name, 'int');
+ }
+
+ void test_parseTypeAnnotation_function_noReturnType_typeParameters() {
+ createParser('Function<S, T>()');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNull);
+ expect(functionType.functionKeyword, isNotNull);
+ TypeParameterList typeParameters = functionType.typeParameters;
+ expect(typeParameters, isNotNull);
+ expect(typeParameters.typeParameters, hasLength(2));
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ expect(parameterList.parameters, hasLength(0));
+ }
+
+ void
+ test_parseTypeAnnotation_function_noReturnType_typeParameters_parameters() {
+ createParser('Function<T>(String, {T t})');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNull);
+ expect(functionType.functionKeyword, isNotNull);
+ TypeParameterList typeParameters = functionType.typeParameters;
+ expect(typeParameters, isNotNull);
+ expect(typeParameters.typeParameters, hasLength(1));
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ expect(parameterList.parameters, hasLength(2));
+ }
+
+ void test_parseTypeAnnotation_function_returnType_function() {
+ createParser('A Function(B, C) Function(D) v');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ }
+
+ void test_parseTypeAnnotation_function_returnType_noParameters() {
+ createParser('List<int> Function()');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.functionKeyword, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ expect(parameterList.parameters, hasLength(0));
+ }
+
+ void test_parseTypeAnnotation_function_returnType_parameters() {
+ createParser('List<int> Function(String s, int i)');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.functionKeyword, isNotNull);
+ expect(functionType.typeParameters, isNull);
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ NodeList<FormalParameter> parameters = parameterList.parameters;
+ expect(parameters, hasLength(2));
+
+ expect(parameters[0], new isInstanceOf<SimpleFormalParameter>());
+ SimpleFormalParameter parameter = parameters[0];
+ expect(parameter.identifier, isNotNull);
+ expect(parameter.identifier.name, 's');
+ expect(parameter.type, new isInstanceOf<TypeName>());
+ expect((parameter.type as TypeName).name.name, 'String');
+
+ expect(parameters[1], new isInstanceOf<SimpleFormalParameter>());
+ parameter = parameters[1];
+ expect(parameter.identifier, isNotNull);
+ expect(parameter.identifier.name, 'i');
+ expect(parameter.type, new isInstanceOf<TypeName>());
+ expect((parameter.type as TypeName).name.name, 'int');
+ }
+
+ void test_parseTypeAnnotation_function_returnType_simple() {
+ createParser('A Function(B, C) v');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ }
+
+ void test_parseTypeAnnotation_function_returnType_typeParameters() {
+ createParser('List<T> Function<T>()');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.functionKeyword, isNotNull);
+ TypeParameterList typeParameters = functionType.typeParameters;
+ expect(typeParameters, isNotNull);
+ expect(typeParameters.typeParameters, hasLength(1));
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ expect(parameterList.parameters, hasLength(0));
+ }
+
+ void
+ test_parseTypeAnnotation_function_returnType_typeParameters_parameters() {
+ createParser('List<T> Function<T>(String s, [T])');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ expect(functionType.returnType, isNotNull);
+ expect(functionType.functionKeyword, isNotNull);
+ TypeParameterList typeParameters = functionType.typeParameters;
+ expect(typeParameters, isNotNull);
+ expect(typeParameters.typeParameters, hasLength(1));
+ FormalParameterList parameterList = functionType.parameters;
+ expect(parameterList, isNotNull);
+ expect(parameterList.parameters, hasLength(2));
+ }
+
+ void test_parseTypeAnnotation_function_returnType_withArguments() {
+ createParser('A<B> Function(C) v');
+ GenericFunctionType functionType = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ }
+
+ void test_parseTypeAnnotation_named() {
+ createParser('A<B> v');
+ TypeName typeName = parser.parseTypeAnnotation();
+ expectNotNullIfNoErrors(typeName);
+ listener.assertNoErrors();
+ }
+
void test_parseTypeArgumentList_empty() {
createParser('<>');
TypeArgumentList argumentList = parser.parseTypeArgumentList();
diff --git a/pkg/analyzer/test/generated/resolver_driver_test.dart b/pkg/analyzer/test/generated/resolver_driver_test.dart
new file mode 100644
index 0000000..0d060ce
--- /dev/null
+++ b/pkg/analyzer/test/generated/resolver_driver_test.dart
@@ -0,0 +1,32 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'resolver_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(StrictModeTest_Driver);
+ defineReflectiveTests(TypePropagationTest_Driver);
+ });
+}
+
+@reflectiveTest
+class StrictModeTest_Driver extends StrictModeTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
+
+@reflectiveTest
+class TypePropagationTest_Driver extends TypePropagationTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+
+ @failingTest
+ @override
+ test_query() {
+ return super.test_query();
+ }
+}
diff --git a/pkg/analyzer/test/generated/resolver_test.dart b/pkg/analyzer/test/generated/resolver_test.dart
index d559010..2f7c644 100644
--- a/pkg/analyzer/test/generated/resolver_test.dart
+++ b/pkg/analyzer/test/generated/resolver_test.dart
@@ -52,8 +52,6 @@
defineReflectiveTests(TypePropagationTest);
defineReflectiveTests(TypeProviderImplTest);
defineReflectiveTests(TypeResolverVisitorTest);
- defineReflectiveTests(StrictModeTest_Driver);
- defineReflectiveTests(TypePropagationTest_Driver);
});
}
@@ -782,12 +780,6 @@
}
@reflectiveTest
-class StrictModeTest_Driver extends StrictModeTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
-
-@reflectiveTest
class SubtypeManagerTest {
/**
* The inheritance manager being tested.
@@ -2394,18 +2386,6 @@
}
@reflectiveTest
-class TypePropagationTest_Driver extends TypePropagationTest {
- @override
- bool get enableNewAnalysisDriver => true;
-
- @failingTest
- @override
- test_query() {
- return super.test_query();
- }
-}
-
-@reflectiveTest
class TypeProviderImplTest extends EngineTestCase {
void test_creation() {
//
diff --git a/pkg/analyzer/test/generated/resolver_test_case.dart b/pkg/analyzer/test/generated/resolver_test_case.dart
index 509c639..1cd8849 100644
--- a/pkg/analyzer/test/generated/resolver_test_case.dart
+++ b/pkg/analyzer/test/generated/resolver_test_case.dart
@@ -335,7 +335,7 @@
final Map<Source, TestAnalysisResult> analysisResults = {};
StringBuffer _logBuffer = new StringBuffer();
- FileContentOverlay _fileContentOverlay = new FileContentOverlay();
+ FileContentOverlay fileContentOverlay = new FileContentOverlay();
AnalysisDriver driver;
AnalysisContext get analysisContext => analysisContext2;
@@ -687,7 +687,7 @@
PerformanceLog log = new PerformanceLog(_logBuffer);
AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
driver = new AnalysisDriver(scheduler, log, resourceProvider,
- new MemoryByteStore(), _fileContentOverlay, sourceFactory, options);
+ new MemoryByteStore(), fileContentOverlay, sourceFactory, options);
scheduler.start();
} else {
if (packages != null) {
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_driver_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_driver_test.dart
new file mode 100644
index 0000000..9aa12df
--- /dev/null
+++ b/pkg/analyzer/test/generated/static_type_analyzer_driver_test.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'static_type_analyzer_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(StaticTypeAnalyzer2Test_Driver);
+ });
+}
+
+@reflectiveTest
+class StaticTypeAnalyzer2Test_Driver extends StaticTypeAnalyzer2Test {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
index 14c408f..7fb624b 100644
--- a/pkg/analyzer/test/generated/static_type_analyzer_test.dart
+++ b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
@@ -33,7 +33,6 @@
defineReflectiveSuite(() {
defineReflectiveTests(StaticTypeAnalyzerTest);
defineReflectiveTests(StaticTypeAnalyzer2Test);
- defineReflectiveTests(StaticTypeAnalyzer2Test_Driver);
});
}
@@ -173,12 +172,6 @@
}
@reflectiveTest
-class StaticTypeAnalyzer2Test_Driver extends StaticTypeAnalyzer2Test {
- @override
- bool get enableNewAnalysisDriver => true;
-}
-
-@reflectiveTest
class StaticTypeAnalyzerTest extends EngineTestCase {
/**
* The error listener to which errors will be reported.
diff --git a/pkg/analyzer/test/generated/static_type_warning_code_driver_test.dart b/pkg/analyzer/test/generated/static_type_warning_code_driver_test.dart
new file mode 100644
index 0000000..8c15b0c
--- /dev/null
+++ b/pkg/analyzer/test/generated/static_type_warning_code_driver_test.dart
@@ -0,0 +1,33 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'static_type_warning_code_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(StaticTypeWarningCodeTest_Driver);
+ defineReflectiveTests(StrongModeStaticTypeWarningCodeTest_Driver);
+ });
+}
+
+@reflectiveTest
+class StaticTypeWarningCodeTest_Driver extends StaticTypeWarningCodeTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
+
+@reflectiveTest
+class StrongModeStaticTypeWarningCodeTest_Driver
+ extends StrongModeStaticTypeWarningCodeTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+
+ @failingTest
+ @override
+ test_genericMethodWrongNumberOfTypeArguments() {
+ return super.test_genericMethodWrongNumberOfTypeArguments();
+ }
+}
diff --git a/pkg/analyzer/test/generated/static_type_warning_code_test.dart b/pkg/analyzer/test/generated/static_type_warning_code_test.dart
index 4bd6b61..4290c02 100644
--- a/pkg/analyzer/test/generated/static_type_warning_code_test.dart
+++ b/pkg/analyzer/test/generated/static_type_warning_code_test.dart
@@ -18,8 +18,6 @@
defineReflectiveSuite(() {
defineReflectiveTests(StaticTypeWarningCodeTest);
defineReflectiveTests(StrongModeStaticTypeWarningCodeTest);
- defineReflectiveTests(StaticTypeWarningCodeTest_Driver);
- defineReflectiveTests(StrongModeStaticTypeWarningCodeTest_Driver);
});
}
@@ -2412,12 +2410,6 @@
}
@reflectiveTest
-class StaticTypeWarningCodeTest_Driver extends StaticTypeWarningCodeTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
-
-@reflectiveTest
class StrongModeStaticTypeWarningCodeTest extends ResolverTestCase {
void setUp() {
super.setUp();
@@ -2493,16 +2485,3 @@
[]);
}
}
-
-@reflectiveTest
-class StrongModeStaticTypeWarningCodeTest_Driver
- extends StrongModeStaticTypeWarningCodeTest {
- @override
- bool get enableNewAnalysisDriver => true;
-
- @failingTest
- @override
- test_genericMethodWrongNumberOfTypeArguments() {
- return super.test_genericMethodWrongNumberOfTypeArguments();
- }
-}
diff --git a/pkg/analyzer/test/generated/static_warning_code_driver_test.dart b/pkg/analyzer/test/generated/static_warning_code_driver_test.dart
index 90869fb..5eda88cb 100644
--- a/pkg/analyzer/test/generated/static_warning_code_driver_test.dart
+++ b/pkg/analyzer/test/generated/static_warning_code_driver_test.dart
@@ -22,10 +22,4 @@
test_argumentTypeNotAssignable_ambiguousClassName() {
return super.test_argumentTypeNotAssignable_ambiguousClassName();
}
-
- @failingTest
- @override
- test_importOfNonLibrary() {
- return super.test_importOfNonLibrary();
- }
}
diff --git a/pkg/analyzer/test/generated/strong_mode_driver_test.dart b/pkg/analyzer/test/generated/strong_mode_driver_test.dart
new file mode 100644
index 0000000..77e2736
--- /dev/null
+++ b/pkg/analyzer/test/generated/strong_mode_driver_test.dart
@@ -0,0 +1,78 @@
+// Copyright (c) 2017, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'strong_mode_test.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(StrongModeDownwardsInferenceTest_Driver);
+ defineReflectiveTests(StrongModeStaticTypeAnalyzer2Test_Driver);
+ defineReflectiveTests(StrongModeTypePropagationTest_Driver);
+ });
+}
+
+@reflectiveTest
+class StrongModeDownwardsInferenceTest_Driver
+ extends StrongModeDownwardsInferenceTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+
+ @failingTest
+ @override
+ test_inference_hints() {
+ return super.test_inference_hints();
+ }
+}
+
+@reflectiveTest
+class StrongModeStaticTypeAnalyzer2Test_Driver
+ extends StrongModeStaticTypeAnalyzer2Test {
+ @override
+ bool get enableNewAnalysisDriver => true;
+
+ @failingTest
+ @override
+ test_genericFunction_parameter() {
+ return super.test_genericFunction_parameter();
+ }
+
+ @failingTest
+ @override
+ test_genericMethod_functionExpressionInvocation_explicit() {
+ return super.test_genericMethod_functionExpressionInvocation_explicit();
+ }
+
+ @failingTest
+ @override
+ test_genericMethod_functionExpressionInvocation_inferred() {
+ return super.test_genericMethod_functionExpressionInvocation_inferred();
+ }
+
+ @failingTest
+ @override
+ test_genericMethod_functionInvocation_explicit() {
+ return super.test_genericMethod_functionInvocation_explicit();
+ }
+
+ @failingTest
+ @override
+ test_genericMethod_functionInvocation_inferred() {
+ return super.test_genericMethod_functionInvocation_inferred();
+ }
+
+ @failingTest
+ @override
+ test_genericMethod_tearoff() {
+ return super.test_genericMethod_tearoff();
+ }
+}
+
+@reflectiveTest
+class StrongModeTypePropagationTest_Driver
+ extends StrongModeTypePropagationTest {
+ @override
+ bool get enableNewAnalysisDriver => true;
+}
diff --git a/pkg/analyzer/test/generated/strong_mode_test.dart b/pkg/analyzer/test/generated/strong_mode_test.dart
index 920eb12..8008ac8 100644
--- a/pkg/analyzer/test/generated/strong_mode_test.dart
+++ b/pkg/analyzer/test/generated/strong_mode_test.dart
@@ -25,9 +25,6 @@
defineReflectiveTests(StrongModeDownwardsInferenceTest);
defineReflectiveTests(StrongModeStaticTypeAnalyzer2Test);
defineReflectiveTests(StrongModeTypePropagationTest);
- defineReflectiveTests(StrongModeDownwardsInferenceTest_Driver);
- defineReflectiveTests(StrongModeStaticTypeAnalyzer2Test_Driver);
- defineReflectiveTests(StrongModeTypePropagationTest_Driver);
});
}
@@ -1297,19 +1294,6 @@
}
}
-@reflectiveTest
-class StrongModeDownwardsInferenceTest_Driver
- extends StrongModeDownwardsInferenceTest {
- @override
- bool get enableNewAnalysisDriver => true;
-
- @failingTest
- @override
- test_inference_hints() {
- return super.test_inference_hints();
- }
-}
-
/**
* Strong mode static analyzer end to end tests
*/
@@ -2189,49 +2173,6 @@
}
@reflectiveTest
-class StrongModeStaticTypeAnalyzer2Test_Driver
- extends StrongModeStaticTypeAnalyzer2Test {
- @override
- bool get enableNewAnalysisDriver => true;
-
- @failingTest
- @override
- test_genericFunction_parameter() {
- return super.test_genericFunction_parameter();
- }
-
- @failingTest
- @override
- test_genericMethod_functionExpressionInvocation_explicit() {
- return super.test_genericMethod_functionExpressionInvocation_explicit();
- }
-
- @failingTest
- @override
- test_genericMethod_functionExpressionInvocation_inferred() {
- return super.test_genericMethod_functionExpressionInvocation_inferred();
- }
-
- @failingTest
- @override
- test_genericMethod_functionInvocation_explicit() {
- return super.test_genericMethod_functionInvocation_explicit();
- }
-
- @failingTest
- @override
- test_genericMethod_functionInvocation_inferred() {
- return super.test_genericMethod_functionInvocation_inferred();
- }
-
- @failingTest
- @override
- test_genericMethod_tearoff() {
- return super.test_genericMethod_tearoff();
- }
-}
-
-@reflectiveTest
class StrongModeTypePropagationTest extends ResolverTestCase {
@override
void setUp() {
@@ -2478,10 +2419,3 @@
await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
}
}
-
-@reflectiveTest
-class StrongModeTypePropagationTest_Driver
- extends StrongModeTypePropagationTest {
- @override
- bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analyzer/test/generated/test_all.dart b/pkg/analyzer/test/generated/test_all.dart
index 4bac8af..95358e8 100644
--- a/pkg/analyzer/test/generated/test_all.dart
+++ b/pkg/analyzer/test/generated/test_all.dart
@@ -8,6 +8,8 @@
import 'all_the_rest_test.dart' as all_the_rest;
import 'bazel_test.dart' as bazel_test;
+import 'checked_mode_compile_time_error_code_driver_test.dart'
+ as checked_mode_compile_time_error_code_driver_test;
import 'checked_mode_compile_time_error_code_test.dart'
as checked_mode_compile_time_error_code_test;
import 'compile_time_error_code_driver_test.dart'
@@ -17,6 +19,7 @@
import 'declaration_resolver_test.dart' as declaration_resolver_test;
import 'element_resolver_test.dart' as element_resolver_test;
import 'engine_test.dart' as engine_test;
+import 'error_suppression_driver_test.dart' as error_suppression_driver_test;
import 'error_suppression_test.dart' as error_suppression_test;
import 'hint_code_driver_test.dart' as hint_code_driver_test;
import 'hint_code_test.dart' as hint_code_test;
@@ -26,18 +29,25 @@
import 'java_io_test.dart' as java_io_test;
import 'non_error_resolver_driver_test.dart' as non_error_resolver_driver_test;
import 'non_error_resolver_test.dart' as non_error_resolver_test;
+import 'non_hint_code_driver_test.dart' as non_hint_code_driver_test;
import 'non_hint_code_test.dart' as non_hint_code_test;
import 'parser_test.dart' as parser_test;
+import 'resolver_driver_test.dart' as resolver_driver_test;
import 'resolver_test.dart' as resolver_test;
import 'scanner_test.dart' as scanner_test;
import 'sdk_test.dart' as sdk_test;
import 'simple_resolver_test.dart' as simple_resolver_test;
import 'source_factory_test.dart' as source_factory_test;
+import 'static_type_analyzer_driver_test.dart'
+ as static_type_analyzer_driver_test;
import 'static_type_analyzer_test.dart' as static_type_analyzer_test;
+import 'static_type_warning_code_driver_test.dart'
+ as static_type_warning_code_driver_test;
import 'static_type_warning_code_test.dart' as static_type_warning_code_test;
import 'static_warning_code_driver_test.dart'
as static_warning_code_driver_test;
import 'static_warning_code_test.dart' as static_warning_code_test;
+import 'strong_mode_driver_test.dart' as strong_mode_driver_test;
import 'strong_mode_test.dart' as strong_mode_test;
import 'type_system_test.dart' as type_system_test;
import 'utilities_dart_test.dart' as utilities_dart_test;
@@ -48,6 +58,7 @@
defineReflectiveSuite(() {
all_the_rest.main();
bazel_test.main();
+ checked_mode_compile_time_error_code_driver_test.main();
checked_mode_compile_time_error_code_test.main();
compile_time_error_code_driver_test.main();
compile_time_error_code_test.main();
@@ -55,6 +66,7 @@
declaration_resolver_test.main();
element_resolver_test.main();
engine_test.main();
+ error_suppression_driver_test.main();
error_suppression_test.main();
hint_code_driver_test.main();
hint_code_test.main();
@@ -64,17 +76,22 @@
java_io_test.main();
non_error_resolver_driver_test.main();
non_error_resolver_test.main();
+ non_hint_code_driver_test.main();
non_hint_code_test.main();
parser_test.main();
+ resolver_driver_test.main();
resolver_test.main();
scanner_test.main();
sdk_test.main();
simple_resolver_test.main();
source_factory_test.main();
+ static_type_analyzer_driver_test.main();
static_type_analyzer_test.main();
+ static_type_warning_code_driver_test.main();
static_type_warning_code_test.main();
static_warning_code_driver_test.main();
static_warning_code_test.main();
+ strong_mode_driver_test.main();
strong_mode_test.main();
type_system_test.main();
utilities_dart_test.main();
diff --git a/pkg/analyzer/test/src/dart/sdk/sdk_test.dart b/pkg/analyzer/test/src/dart/sdk/sdk_test.dart
index a32d03b..3abf7c2 100644
--- a/pkg/analyzer/test/src/dart/sdk/sdk_test.dart
+++ b/pkg/analyzer/test/src/dart/sdk/sdk_test.dart
@@ -59,38 +59,6 @@
expectSource('$foxLib/deep/directory/part.dart', 'dart:deep/part.dart');
}
- void test_getLinkedBundle_hasBundle() {
- pathTranslator.newFileWithBytes(
- '$foxPath/sdk.ds', new PackageBundleAssembler().assemble().toBuffer());
- EmbedderYamlLocator locator = new EmbedderYamlLocator({
- 'fox': <Folder>[pathTranslator.getResource(foxLib)]
- });
- // No bundle for spec mode.
- {
- EmbedderSdk sdk =
- new EmbedderSdk(resourceProvider, locator.embedderYamls);
- sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = false;
- sdk.useSummary = true;
- expect(sdk.getLinkedBundle(), isNull);
- }
- // Has bundle for strong mode.
- {
- EmbedderSdk sdk =
- new EmbedderSdk(resourceProvider, locator.embedderYamls);
- sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = true;
- sdk.useSummary = true;
- expect(sdk.getLinkedBundle(), isNotNull);
- }
- // Don't use bundle if not enabled.
- {
- EmbedderSdk sdk =
- new EmbedderSdk(resourceProvider, locator.embedderYamls);
- sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = true;
- sdk.useSummary = false;
- expect(sdk.getLinkedBundle(), isNull);
- }
- }
-
void test_getLinkedBundle_noBundle() {
EmbedderYamlLocator locator = new EmbedderYamlLocator({
'fox': <Folder>[pathTranslator.getResource(foxLib)]
@@ -99,6 +67,30 @@
expect(sdk.getLinkedBundle(), isNull);
}
+ void test_getLinkedBundle_spec() {
+ pathTranslator.newFileWithBytes('$foxPath/spec.sum',
+ new PackageBundleAssembler().assemble().toBuffer());
+ EmbedderYamlLocator locator = new EmbedderYamlLocator({
+ 'fox': <Folder>[pathTranslator.getResource(foxLib)]
+ });
+ EmbedderSdk sdk = new EmbedderSdk(resourceProvider, locator.embedderYamls);
+ sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = false;
+ sdk.useSummary = true;
+ expect(sdk.getLinkedBundle(), isNotNull);
+ }
+
+ void test_getLinkedBundle_strong() {
+ pathTranslator.newFileWithBytes('$foxPath/strong.sum',
+ new PackageBundleAssembler().assemble().toBuffer());
+ EmbedderYamlLocator locator = new EmbedderYamlLocator({
+ 'fox': <Folder>[pathTranslator.getResource(foxLib)]
+ });
+ EmbedderSdk sdk = new EmbedderSdk(resourceProvider, locator.embedderYamls);
+ sdk.analysisOptions = new AnalysisOptionsImpl()..strongMode = true;
+ sdk.useSummary = true;
+ expect(sdk.getLinkedBundle(), isNotNull);
+ }
+
void test_getSdkLibrary() {
EmbedderYamlLocator locator = new EmbedderYamlLocator({
'fox': <Folder>[pathTranslator.getResource(foxLib)]
diff --git a/pkg/analyzer/test/src/summary/package_bundle_reader_test.dart b/pkg/analyzer/test/src/summary/package_bundle_reader_test.dart
index 7b6fab2..404d9af 100644
--- a/pkg/analyzer/test/src/summary/package_bundle_reader_test.dart
+++ b/pkg/analyzer/test/src/summary/package_bundle_reader_test.dart
@@ -72,6 +72,9 @@
when(bundle.linkedLibraries).thenReturn(<LinkedLibrary>[linkedLibrary]);
dataStore.addBundle('/p1.ds', bundle);
+ when(unlinkedUnit1.isPartOf).thenReturn(false);
+ when(unlinkedUnit2.isPartOf).thenReturn(true);
+
when(unlinkedUnit1.publicNamespace)
.thenReturn(_namespaceWithParts(['package:p1/u2.dart']));
when(unlinkedUnit2.publicNamespace).thenReturn(_namespaceWithParts([]));
@@ -124,6 +127,13 @@
expect(entry1.getValue(SOURCE_KIND), SourceKind.LIBRARY);
}
+ test_compute_SOURCE_KIND_librarySource_isPartOf() {
+ when(unlinkedUnit1.isPartOf).thenReturn(true);
+ bool success = provider.compute(entry1, SOURCE_KIND);
+ expect(success, isTrue);
+ expect(entry1.getValue(SOURCE_KIND), SourceKind.PART);
+ }
+
test_compute_SOURCE_KIND_noResults() {
bool success = provider.compute(entry3, SOURCE_KIND);
expect(success, isFalse);
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index e5c2b77..e1448b4 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -346,6 +346,9 @@
} else {
compareConstAsts(rItem.expression, oItem.expression, desc);
}
+ } else if (oItem is AssertInitializer && rItem is AssertInitializer) {
+ compareConstAsts(rItem.condition, oItem.condition, '$desc condition');
+ compareConstAsts(rItem.message, oItem.message, '$desc message');
} else if (oItem is SuperConstructorInvocation &&
rItem is SuperConstructorInvocation) {
compareElements(rItem.staticElement, oItem.staticElement, desc);
@@ -437,6 +440,8 @@
checkElidablePrefix(oTarget.prefix);
checkElidablePrefix(oTarget.identifier);
compareConstAsts(r, o.propertyName, desc);
+ } else if (o is ThisExpression && r is ThisExpression) {
+ // Nothing to compare.
} else if (o is NullLiteral) {
expect(r, new isInstanceOf<NullLiteral>(), reason: desc);
} else if (o is BooleanLiteral && r is BooleanLiteral) {
@@ -1120,7 +1125,8 @@
/**
* Determine the analysis options that should be used for this test.
*/
- AnalysisOptionsImpl createOptions() => new AnalysisOptionsImpl();
+ AnalysisOptionsImpl createOptions() =>
+ new AnalysisOptionsImpl()..enableAssertInitializer = true;
ElementImpl getActualElement(Element element, String desc) {
if (element == null) {
@@ -2424,6 +2430,22 @@
}''');
}
+ test_constructor_initializers_assertInvocation() {
+ checkLibrary('''
+class C {
+ const C(int x) : assert(x >= 42);
+}
+''');
+ }
+
+ test_constructor_initializers_assertInvocation_message() {
+ checkLibrary('''
+class C {
+ const C(int x) : assert(x >= 42, 'foo');
+}
+''');
+ }
+
test_constructor_initializers_field() {
checkLibrary('''
class C {
@@ -4323,6 +4345,15 @@
checkLibrary('library my.lib; part "foo/";');
}
+ test_parts_invalidUri_nullStringValue() {
+ allowMissingFiles = true;
+ addSource('/foo/bar.dart', 'part of my.lib;');
+ checkLibrary(r'''
+library my.lib;
+part "${foo}/bar.dart";
+''');
+ }
+
test_propagated_type_refers_to_closure() {
checkLibrary('''
void f() {
@@ -4637,6 +4668,19 @@
checkLibrary('f() {} g() {}');
}
+ test_unresolved_annotation_instanceCreation_argument_this() {
+ checkLibrary(
+ '''
+class A {
+ const A(_);
+}
+
+@A(this)
+class C {}
+''',
+ allowErrors: true);
+ }
+
test_unresolved_annotation_namedConstructorCall_noClass() {
checkLibrary('@foo.bar() class C {}', allowErrors: true);
}
diff --git a/pkg/analyzer/test/src/summary/summarize_ast_test.dart b/pkg/analyzer/test/src/summary/summarize_ast_test.dart
index fed8019..932e1fc 100644
--- a/pkg/analyzer/test/src/summary/summarize_ast_test.dart
+++ b/pkg/analyzer/test/src/summary/summarize_ast_test.dart
@@ -269,7 +269,7 @@
uri ??= absUri(path);
Uri testDartUri = Uri.parse(uri);
UnlinkedUnitBuilder unlinkedDefiningUnit =
- createUnlinkedSummary(testDartUri, text);
+ createUnlinkedSummary(testDartUri, text);
_filesToLink.uriToUnit[testDartUri.toString()] = unlinkedDefiningUnit;
LinkerInputs linkerInputs = new LinkerInputs(
allowMissingFiles,
@@ -283,9 +283,6 @@
return linkerInputs;
}
- UnlinkedUnitBuilder createUnlinkedSummary(Uri uri, String text) =>
- serializeAstUnlinked(_parseText(text));
-
/**
* Link together the given file, along with any other files passed to
* [addNamedSource], to form a package bundle. Reset the state of the buffers
@@ -312,12 +309,16 @@
return assembler.assemble();
}
+ UnlinkedUnitBuilder createUnlinkedSummary(Uri uri, String text) =>
+ serializeAstUnlinked(_parseText(text));
+
CompilationUnit _parseText(String text) {
CharSequenceReader reader = new CharSequenceReader(text);
Scanner scanner =
new Scanner(null, reader, AnalysisErrorListener.NULL_LISTENER);
Token token = scanner.tokenize();
Parser parser = new Parser(null, AnalysisErrorListener.NULL_LISTENER);
+ parser.enableAssertInitializer = true;
CompilationUnit unit = parser.parseCompilationUnit(token);
unit.lineInfo = new LineInfo(scanner.lineStarts);
return unit;
diff --git a/pkg/analyzer/test/src/summary/summary_common.dart b/pkg/analyzer/test/src/summary/summary_common.dart
index 9d51fd8..3c363df 100644
--- a/pkg/analyzer/test/src/summary/summary_common.dart
+++ b/pkg/analyzer/test/src/summary/summary_common.dart
@@ -140,6 +140,13 @@
LinkedUnit get definingUnit => linked.units[0];
/**
+ * Whether the parts of the IDL marked `@informative` are expected to be
+ * included in the generated summary; if `false`, these parts of the IDL won't
+ * be checked.
+ */
+ bool get includeInformative => true;
+
+ /**
* Get access to the linked summary that results from serializing and
* then deserializing the library under test.
*/
@@ -163,13 +170,6 @@
bool get strongMode;
/**
- * Whether the parts of the IDL marked `@informative` are expected to be
- * included in the generated summary; if `false`, these parts of the IDL won't
- * be checked.
- */
- bool get includeInformative => true;
-
- /**
* Get access to the unlinked compilation unit summaries that result from
* serializing and deserializing the library under test.
*/
@@ -182,6 +182,32 @@
Source addNamedSource(String filePath, String contents);
/**
+ * TODO(scheglov) rename "Const" to "Expr" everywhere
+ */
+ void assertUnlinkedConst(UnlinkedExpr constExpr,
+ {bool isValidConst: true,
+ List<UnlinkedExprOperation> operators: const <UnlinkedExprOperation>[],
+ List<UnlinkedExprAssignOperator> assignmentOperators:
+ const <UnlinkedExprAssignOperator>[],
+ List<int> ints: const <int>[],
+ List<double> doubles: const <double>[],
+ List<String> strings: const <String>[],
+ List<_EntityRefValidator> referenceValidators:
+ const <_EntityRefValidator>[]}) {
+ expect(constExpr, isNotNull);
+ expect(constExpr.isValidConst, isValidConst);
+ expect(constExpr.operations, operators);
+ expect(constExpr.ints, ints);
+ expect(constExpr.doubles, doubles);
+ expect(constExpr.strings, strings);
+ expect(constExpr.assignmentOperators, assignmentOperators);
+ expect(constExpr.references, hasLength(referenceValidators.length));
+ for (int i = 0; i < referenceValidators.length; i++) {
+ referenceValidators[i](constExpr.references[i]);
+ }
+ }
+
+ /**
* Check that [annotations] contains a single entry which is a reference to
* a top level variable called `a` in the current library.
*/
@@ -3563,6 +3589,63 @@
expect(executable, isNull);
}
+ test_constructor_initializers_assertInvocation() {
+ UnlinkedExecutable executable =
+ findExecutable('', executables: serializeClassText(r'''
+class C {
+ const C(int x) : assert(x >= 42);
+}
+''').executables);
+ expect(executable.constantInitializers, hasLength(1));
+ UnlinkedConstructorInitializer initializer =
+ executable.constantInitializers[0];
+ expect(
+ initializer.kind, UnlinkedConstructorInitializerKind.assertInvocation);
+ expect(initializer.name, '');
+ expect(initializer.expression, isNull);
+ expect(initializer.arguments, hasLength(1));
+ assertUnlinkedConst(initializer.arguments[0], operators: [
+ UnlinkedExprOperation.pushParameter,
+ UnlinkedExprOperation.pushInt,
+ UnlinkedExprOperation.greaterEqual
+ ], ints: [
+ 42
+ ], strings: [
+ 'x'
+ ]);
+ }
+
+ test_constructor_initializers_assertInvocation_message() {
+ UnlinkedExecutable executable =
+ findExecutable('', executables: serializeClassText(r'''
+class C {
+ const C(int x) : assert(x >= 42, 'foo');
+}
+''').executables);
+ expect(executable.constantInitializers, hasLength(1));
+ UnlinkedConstructorInitializer initializer =
+ executable.constantInitializers[0];
+ expect(
+ initializer.kind, UnlinkedConstructorInitializerKind.assertInvocation);
+ expect(initializer.name, '');
+ expect(initializer.expression, isNull);
+ expect(initializer.arguments, hasLength(2));
+ assertUnlinkedConst(initializer.arguments[0], operators: [
+ UnlinkedExprOperation.pushParameter,
+ UnlinkedExprOperation.pushInt,
+ UnlinkedExprOperation.greaterEqual
+ ], ints: [
+ 42
+ ], strings: [
+ 'x',
+ ]);
+ assertUnlinkedConst(initializer.arguments[1], operators: [
+ UnlinkedExprOperation.pushString,
+ ], strings: [
+ 'foo'
+ ]);
+ }
+
test_constructor_initializers_field() {
UnlinkedExecutable executable =
findExecutable('', executables: serializeClassText(r'''
@@ -6388,6 +6471,17 @@
expect(unlinkedExports[0].configurations, isEmpty);
}
+ test_export_uri_nullStringValue() {
+ String libraryText = r'''
+export "${'a'}.dart";
+''';
+ serializeLibraryText(libraryText);
+ var unlinkedExports = unlinkedUnits[0].publicNamespace.exports;
+ expect(unlinkedExports, hasLength(1));
+ expect(unlinkedExports[0].uri, '');
+ expect(unlinkedExports[0].configurations, isEmpty);
+ }
+
test_export_variable() {
addNamedSource('/a.dart', 'var v;');
serializeLibraryText('export "a.dart";');
@@ -8263,6 +8357,16 @@
expect(unlinkedUnits[0].imports[0].uri, 'dart:async');
}
+ test_import_uri_nullStringValue() {
+ String libraryText = r'''
+import "${'a'}.dart";
+''';
+ serializeLibraryText(libraryText);
+ // Second import is the implicit import of dart:core
+ expect(unlinkedUnits[0].imports, hasLength(2));
+ expect(unlinkedUnits[0].imports[0].uri, '');
+ }
+
test_inferred_function_type_parameter_type_with_unrelated_type_param() {
if (!strongMode || skipFullyLinkedData) {
return;
@@ -9073,6 +9177,28 @@
checkAnnotationA(unlinkedUnits[0].imports[0].annotations);
}
+ test_metadata_invalid_instanceCreation_argument_this() {
+ List<UnlinkedExpr> annotations = serializeClassText('''
+class A {
+ const A(_);
+}
+
+@A(this)
+class C {}
+''').annotations;
+ expect(annotations, hasLength(1));
+ assertUnlinkedConst(annotations[0], operators: [
+ UnlinkedExprOperation.pushThis,
+ UnlinkedExprOperation.invokeConstructor,
+ ], ints: [
+ 0,
+ 1
+ ], referenceValidators: [
+ (EntityRef r) => checkTypeRef(r, null, null, 'A',
+ expectedKind: ReferenceKind.classOrEnum)
+ ]);
+ }
+
test_metadata_libraryDirective() {
serializeLibraryText('@a library L; const a = null;');
checkAnnotationA(unlinkedUnits[0].libraryAnnotations);
@@ -9370,6 +9496,20 @@
expect(unlinkedUnits[0].parts[0].uriEnd, text.indexOf('; // <-part'));
}
+ test_part_declaration_invalidUri_nullStringValue() {
+ addNamedSource('/a.dart', 'part of my.lib;');
+ String text = r'''
+library my.lib;
+part "${'a'}.dart"; // <-part
+''';
+ serializeLibraryText(text);
+ expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
+ expect(unlinkedUnits[0].publicNamespace.parts[0], '');
+ expect(unlinkedUnits[0].parts, hasLength(1));
+ expect(unlinkedUnits[0].parts[0].uriOffset, text.indexOf(r'"${'));
+ expect(unlinkedUnits[0].parts[0].uriEnd, text.indexOf('; // <-part'));
+ }
+
test_part_isPartOf() {
addNamedSource('/a.dart', 'part of foo; class C {}');
serializeLibraryText('library foo; part "a.dart";');
@@ -10456,32 +10596,6 @@
]);
}
- /**
- * TODO(scheglov) rename "Const" to "Expr" everywhere
- */
- void assertUnlinkedConst(UnlinkedExpr constExpr,
- {bool isValidConst: true,
- List<UnlinkedExprOperation> operators: const <UnlinkedExprOperation>[],
- List<UnlinkedExprAssignOperator> assignmentOperators:
- const <UnlinkedExprAssignOperator>[],
- List<int> ints: const <int>[],
- List<double> doubles: const <double>[],
- List<String> strings: const <String>[],
- List<_EntityRefValidator> referenceValidators:
- const <_EntityRefValidator>[]}) {
- expect(constExpr, isNotNull);
- expect(constExpr.isValidConst, isValidConst);
- expect(constExpr.operations, operators);
- expect(constExpr.ints, ints);
- expect(constExpr.doubles, doubles);
- expect(constExpr.strings, strings);
- expect(constExpr.assignmentOperators, assignmentOperators);
- expect(constExpr.references, hasLength(referenceValidators.length));
- for (int i = 0; i < referenceValidators.length; i++) {
- referenceValidators[i](constExpr.references[i]);
- }
- }
-
void _assertVariableVisible(
String code, UnlinkedVariable v, String visibleBegin, String visibleEnd) {
int expectedVisibleOffset = code.indexOf(visibleBegin);
diff --git a/pkg/analyzer/tool/task_dependency_graph/tasks.dot b/pkg/analyzer/tool/task_dependency_graph/tasks.dot
index e6af229..89988ad 100644
--- a/pkg/analyzer/tool/task_dependency_graph/tasks.dot
+++ b/pkg/analyzer/tool/task_dependency_graph/tasks.dot
@@ -85,6 +85,7 @@
EXPORTED_LIBRARIES -> ReadyLibraryElement2Task
EXPORTED_LIBRARIES -> ReadyLibraryElement5Task
EXPORTED_LIBRARIES -> ReadyLibraryElement7Task
+ EXPORTED_LIBRARIES -> ResolveDirectiveElementsTask
EXPORTED_LIBRARIES -> ResolveTopLevelLibraryTypeBoundsTask
EXPORTED_LIBRARIES [shape=box]
EXPORT_SOURCE_CLOSURE -> BuildExportNamespaceTask
@@ -104,6 +105,7 @@
IMPORTED_LIBRARIES -> ReadyLibraryElement2Task
IMPORTED_LIBRARIES -> ReadyLibraryElement5Task
IMPORTED_LIBRARIES -> ReadyLibraryElement7Task
+ IMPORTED_LIBRARIES -> ResolveDirectiveElementsTask
IMPORTED_LIBRARIES -> ResolveTopLevelLibraryTypeBoundsTask
IMPORTED_LIBRARIES -> ResolveTopLevelUnitTypeBoundsTask
IMPORTED_LIBRARIES [shape=box]
@@ -189,6 +191,7 @@
MODIFICATION_TIME -> BuildDirectiveElementsTask
MODIFICATION_TIME -> BuildLibraryElementTask
MODIFICATION_TIME -> ParseDartTask
+ MODIFICATION_TIME -> ResolveDirectiveElementsTask
MODIFICATION_TIME -> ScanDartTask
MODIFICATION_TIME -> VerifyUnitTask
MODIFICATION_TIME [shape=box]
@@ -226,6 +229,7 @@
READY_RESOLVED_UNIT [shape=box]
REFERENCED_NAMES [shape=box]
REFERENCED_SOURCES -> BuildDirectiveElementsTask
+ REFERENCED_SOURCES -> ResolveDirectiveElementsTask
REFERENCED_SOURCES -> VerifyUnitTask
REFERENCED_SOURCES [shape=box]
REQUIRED_CONSTANTS -> VerifyUnitTask
@@ -270,6 +274,8 @@
RESOLVED_UNIT8 [shape=box]
RESOLVED_UNIT9 -> InferInstanceMembersInUnitTask
RESOLVED_UNIT9 [shape=box]
+ RESOLVE_DIRECTIVES_ERRORS -> LibraryUnitErrorsTask
+ RESOLVE_DIRECTIVES_ERRORS [shape=box]
RESOLVE_TYPE_BOUNDS_ERRORS -> LibraryUnitErrorsTask
RESOLVE_TYPE_BOUNDS_ERRORS [shape=box]
RESOLVE_TYPE_NAMES_ERRORS -> LibraryUnitErrorsTask
@@ -283,6 +289,7 @@
ResolveConstantExpressionTask -> CONSTANT_EXPRESSION_RESOLVED
ResolveDirectiveElementsTask -> CREATED_RESOLVED_UNIT2
ResolveDirectiveElementsTask -> RESOLVED_UNIT2
+ ResolveDirectiveElementsTask -> RESOLVE_DIRECTIVES_ERRORS
ResolveInstanceFieldsInUnitTask -> CREATED_RESOLVED_UNIT9
ResolveInstanceFieldsInUnitTask -> RESOLVED_UNIT9
ResolveLibraryReferencesTask -> LIBRARY_ELEMENT9
@@ -307,6 +314,7 @@
SCAN_ERRORS -> dartErrorsForSource
SCAN_ERRORS [shape=box]
SOURCE_KIND -> BuildDirectiveElementsTask
+ SOURCE_KIND -> ResolveDirectiveElementsTask
SOURCE_KIND [shape=box]
STATIC_VARIABLE_RESOLUTION_ERRORS -> InferStaticVariableTypesInUnitTask
STATIC_VARIABLE_RESOLUTION_ERRORS [shape=box]
diff --git a/pkg/compiler/lib/src/common/backend_api.dart b/pkg/compiler/lib/src/common/backend_api.dart
index e375db2..a33f1fd 100644
--- a/pkg/compiler/lib/src/common/backend_api.dart
+++ b/pkg/compiler/lib/src/common/backend_api.dart
@@ -418,7 +418,7 @@
ClassElement get indexingBehaviorImplementation;
ClassElement get interceptorImplementation;
- bool isDefaultEqualityImplementation(Element element);
+ bool isDefaultEqualityImplementation(MemberElement element);
bool isInterceptorClass(ClassElement cls);
bool isNativeClass(ClassElement element);
bool isNativeMember(MemberElement element);
diff --git a/pkg/compiler/lib/src/common/resolution.dart b/pkg/compiler/lib/src/common/resolution.dart
index 0ccd78e..db13fd4 100644
--- a/pkg/compiler/lib/src/common/resolution.dart
+++ b/pkg/compiler/lib/src/common/resolution.dart
@@ -6,7 +6,6 @@
import '../common.dart';
import '../compile_time_constants.dart';
-import '../compiler.dart' show Compiler;
import '../constants/expressions.dart' show ConstantExpression;
import '../constants/values.dart' show ConstantValue;
import '../core_types.dart' show CommonElements;
diff --git a/pkg/compiler/lib/src/compiler.dart b/pkg/compiler/lib/src/compiler.dart
index 4a377dc..1e2fc08 100644
--- a/pkg/compiler/lib/src/compiler.dart
+++ b/pkg/compiler/lib/src/compiler.dart
@@ -305,10 +305,9 @@
return new ResolverTask(resolution, backend.constantCompilerTask, measurer);
}
- // TODO(johnniwinther): Rename these appropriately when unification of worlds/
- // universes is complete.
- ResolutionWorldBuilder get resolverWorld => enqueuer.resolution.universe;
- CodegenWorldBuilder get codegenWorld => enqueuer.codegen.universe;
+ ResolutionWorldBuilder get resolutionWorldBuilder =>
+ enqueuer.resolution.worldBuilder;
+ CodegenWorldBuilder get codegenWorldBuilder => enqueuer.codegen.worldBuilder;
bool get analyzeAll => options.analyzeAll || compileAll;
@@ -709,7 +708,7 @@
reporter.log('Compiling...');
phase = PHASE_COMPILING;
- codegenWorld.open(closedWorld);
+ codegenWorldBuilder.open(closedWorld);
enqueuer.codegen.applyImpact(backend.onCodegenStart(closedWorld));
if (compileAll) {
libraryLoader.libraries.forEach((LibraryElement library) {
@@ -736,7 +735,7 @@
ClosedWorldRefiner closeResolution() {
phase = PHASE_DONE_RESOLVING;
- ClosedWorldImpl world = resolverWorld.closeWorld(reporter);
+ ClosedWorldImpl world = resolutionWorldBuilder.closeWorld(reporter);
// Compute whole-program-knowledge that the backend needs. (This might
// require the information computed in [world.closeWorld].)
backend.onResolutionComplete(world, world);
@@ -1313,6 +1312,9 @@
_nativeAnnotationClass ??= _findRequired(jsHelperLibrary, 'Native');
@override
+ ResolutionDynamicType get dynamicType => const ResolutionDynamicType();
+
+ @override
ResolutionInterfaceType get objectType {
objectClass.ensureResolved(resolution);
return objectClass.rawType;
@@ -1964,7 +1966,7 @@
@override
void registerClass(ClassElement cls) {
- enqueuer.universe.registerClass(cls);
+ enqueuer.worldBuilder.registerClass(cls);
}
@override
diff --git a/pkg/compiler/lib/src/constant_system_dart.dart b/pkg/compiler/lib/src/constant_system_dart.dart
index cc12636..7c3ebc1 100644
--- a/pkg/compiler/lib/src/constant_system_dart.dart
+++ b/pkg/compiler/lib/src/constant_system_dart.dart
@@ -458,10 +458,10 @@
// TODO(johnniwinther): Change the `Type` type to
// `compiler.commonElements.typeType` and check the backend specific value
// in [checkConstMapKeysDontOverrideEquals] in 'members.dart'.
- return new TypeConstantValue(
- type,
- compiler.backend.backendClasses.typeImplementation
- .computeType(compiler.resolution));
+ ResolutionInterfaceType implementationType = compiler
+ .backend.backendClasses.typeImplementation
+ .computeType(compiler.resolution);
+ return new TypeConstantValue(type, implementationType);
}
@override
diff --git a/pkg/compiler/lib/src/constants/values.dart b/pkg/compiler/lib/src/constants/values.dart
index 9cf9b4b..36c14cc 100644
--- a/pkg/compiler/lib/src/constants/values.dart
+++ b/pkg/compiler/lib/src/constants/values.dart
@@ -8,7 +8,7 @@
import '../core_types.dart';
import '../elements/elements.dart' show Entity;
import '../elements/entities.dart';
-import '../elements/resolution_types.dart';
+import '../elements/types.dart';
import '../tree/dartstring.dart';
import '../util/util.dart' show Hashing;
@@ -82,7 +82,7 @@
bool get isNegativeInfinity => false;
// TODO(johnniwinther): Replace with a 'type' getter.
- ResolutionDartType getType(CommonElements types);
+ DartType getType(CommonElements types);
List<ConstantValue> getDependencies();
@@ -114,7 +114,7 @@
class FunctionConstantValue extends ConstantValue {
final FunctionEntity element;
// TODO(johnniwinther): Should the type be derived from [element].
- final ResolutionFunctionType type;
+ final FunctionType type;
FunctionConstantValue(this.element, this.type);
@@ -131,7 +131,7 @@
return new DartString.literal(element.name);
}
- ResolutionDartType getType(CommonElements types) => type;
+ DartType getType(CommonElements types) => type;
int get hashCode => (17 * element.hashCode) & 0x7fffffff;
@@ -189,7 +189,7 @@
get primitiveValue => null;
- ResolutionDartType getType(CommonElements types) => types.nullType;
+ DartType getType(CommonElements types) => types.nullType;
// The magic constant has no meaning. It is just a random value.
int get hashCode => 785965825;
@@ -261,7 +261,7 @@
bool get isOne => primitiveValue == 1;
- ResolutionDartType getType(CommonElements types) => types.intType;
+ DartType getType(CommonElements types) => types.intType;
// We have to override the equality operator so that ints and doubles are
// treated as separate constants.
@@ -322,7 +322,7 @@
bool get isNegativeInfinity => primitiveValue == -double.INFINITY;
- ResolutionDartType getType(CommonElements types) => types.doubleType;
+ DartType getType(CommonElements types) => types.doubleType;
bool operator ==(var other) {
if (other is! DoubleConstantValue) return false;
@@ -359,7 +359,7 @@
bool get isBool => true;
- ResolutionDartType getType(CommonElements types) => types.boolType;
+ DartType getType(CommonElements types) => types.boolType;
BoolConstantValue negate();
@@ -427,7 +427,7 @@
bool get isString => true;
- ResolutionDartType getType(CommonElements types) => types.stringType;
+ DartType getType(CommonElements types) => types.stringType;
bool operator ==(var other) {
if (identical(this, other)) return true;
@@ -452,13 +452,13 @@
}
abstract class ObjectConstantValue extends ConstantValue {
- final ResolutionInterfaceType type;
+ final InterfaceType type;
ObjectConstantValue(this.type);
bool get isObject => true;
- ResolutionDartType getType(CommonElements types) => type;
+ DartType getType(CommonElements types) => type;
void _unparseTypeArguments(StringBuffer sb) {
if (!type.treatAsRaw) {
@@ -471,10 +471,9 @@
class TypeConstantValue extends ObjectConstantValue {
/// The user type that this constant represents.
- final ResolutionDartType representedType;
+ final DartType representedType;
- TypeConstantValue(this.representedType, ResolutionInterfaceType type)
- : super(type);
+ TypeConstantValue(this.representedType, InterfaceType type) : super(type);
bool get isType => true;
@@ -500,7 +499,7 @@
final List<ConstantValue> entries;
final int hashCode;
- ListConstantValue(ResolutionInterfaceType type, List<ConstantValue> entries)
+ ListConstantValue(InterfaceType type, List<ConstantValue> entries)
: this.entries = entries,
hashCode = Hashing.listHash(entries, Hashing.objectHash(type)),
super(type);
@@ -560,8 +559,8 @@
final int hashCode;
Map<ConstantValue, ConstantValue> _lookupMap;
- MapConstantValue(ResolutionInterfaceType type, List<ConstantValue> keys,
- List<ConstantValue> values)
+ MapConstantValue(
+ InterfaceType type, List<ConstantValue> keys, List<ConstantValue> values)
: this.keys = keys,
this.values = values,
this.hashCode = Hashing.listHash(
@@ -636,20 +635,19 @@
}
class InterceptorConstantValue extends ConstantValue {
- /// The type for which this interceptor holds the methods. The constant
- /// is a dispatch table for this type.
- final ResolutionDartType dispatchedType;
+ /// The class for which this interceptor holds the methods. The constant
+ /// is a dispatch table for this class.
+ final ClassEntity cls;
- InterceptorConstantValue(this.dispatchedType);
+ InterceptorConstantValue(this.cls);
bool get isInterceptor => true;
bool operator ==(other) {
- return other is InterceptorConstantValue &&
- dispatchedType == other.dispatchedType;
+ return other is InterceptorConstantValue && cls == other.cls;
}
- int get hashCode => dispatchedType.hashCode * 43;
+ int get hashCode => cls.hashCode * 43;
List<ConstantValue> getDependencies() => const <ConstantValue>[];
@@ -657,17 +655,16 @@
return visitor.visitInterceptor(this, arg);
}
- ResolutionDartType getType(CommonElements types) =>
- const ResolutionDynamicType();
+ DartType getType(CommonElements types) => types.dynamicType;
ConstantValueKind get kind => ConstantValueKind.INTERCEPTOR;
String toDartText() {
- return 'interceptor($dispatchedType)';
+ return 'interceptor($cls)';
}
String toStructuredText() {
- return 'InterceptorConstant(${dispatchedType.getStringAsDeclared("o")})';
+ return 'InterceptorConstant(${cls.name})';
}
}
@@ -691,8 +688,7 @@
return visitor.visitSynthetic(this, arg);
}
- ResolutionDartType getType(CommonElements types) =>
- const ResolutionDynamicType();
+ DartType getType(CommonElements types) => types.dynamicType;
ConstantValueKind get kind => ConstantValueKind.SYNTHETIC;
@@ -708,7 +704,7 @@
final int hashCode;
ConstructedConstantValue(
- ResolutionInterfaceType type, Map<FieldEntity, ConstantValue> fields)
+ InterfaceType type, Map<FieldEntity, ConstantValue> fields)
: this.fields = fields,
hashCode = Hashing.unorderedMapHash(fields, Hashing.objectHash(type)),
super(type) {
@@ -741,7 +737,7 @@
String toDartText() {
StringBuffer sb = new StringBuffer();
- sb.write(type.name);
+ sb.write(type.element.name);
_unparseTypeArguments(sb);
sb.write('(');
int i = 0;
@@ -796,7 +792,7 @@
accept(ConstantValueVisitor visitor, arg) => visitor.visitDeferred(this, arg);
- ResolutionDartType getType(CommonElements types) => referenced.getType(types);
+ DartType getType(CommonElements types) => referenced.getType(types);
ConstantValueKind get kind => ConstantValueKind.DEFERRED;
@@ -822,8 +818,7 @@
List<ConstantValue> getDependencies() => const <ConstantValue>[];
@override
- ResolutionDartType getType(CommonElements types) =>
- const ResolutionDynamicType();
+ DartType getType(CommonElements types) => types.dynamicType;
ConstantValueKind get kind => ConstantValueKind.NON_CONSTANT;
diff --git a/pkg/compiler/lib/src/core_types.dart b/pkg/compiler/lib/src/core_types.dart
index cbd1f59..8b34bdb 100644
--- a/pkg/compiler/lib/src/core_types.dart
+++ b/pkg/compiler/lib/src/core_types.dart
@@ -134,6 +134,9 @@
/// The 'filled' constructor of `List`.
ConstructorElement get filledListConstructor;
+ /// The `dynamic` type.
+ ResolutionDynamicType get dynamicType;
+
/// The `Object` type defined in 'dart:core'.
ResolutionInterfaceType get objectType;
diff --git a/pkg/compiler/lib/src/deferred_load.dart b/pkg/compiler/lib/src/deferred_load.dart
index 5359f61..6055e03 100644
--- a/pkg/compiler/lib/src/deferred_load.dart
+++ b/pkg/compiler/lib/src/deferred_load.dart
@@ -493,7 +493,8 @@
if (constants.contains(constant)) return;
constants.add(constant);
if (constant is ConstructedConstantValue) {
- _mapDependencies(element: constant.type.element, import: import);
+ ClassElement cls = constant.type.element;
+ _mapDependencies(element: cls, import: import);
}
constant.getDependencies().forEach((ConstantValue dependency) {
_mapConstantDependencies(dependency, import);
@@ -798,7 +799,8 @@
metadata.ensureResolved(compiler.resolution);
ConstantValue value =
compiler.constants.getConstantValue(metadata.constant);
- Element element = value.getType(compiler.commonElements).element;
+ ResolutionDartType type = value.getType(compiler.commonElements);
+ Element element = type.element;
if (element == deferredLibraryClass) {
reporter.reportErrorMessage(
import, MessageKind.DEFERRED_OLD_SYNTAX);
@@ -1034,7 +1036,8 @@
metadata.ensureResolved(compiler.resolution);
ConstantValue value =
compiler.constants.getConstantValue(metadata.constant);
- Element element = value.getType(compiler.commonElements).element;
+ ResolutionDartType type = value.getType(compiler.commonElements);
+ Element element = type.element;
if (element == compiler.commonElements.deferredLibraryClass) {
ConstructedConstantValue constant = value;
StringConstantValue s = constant.fields.values.single;
diff --git a/pkg/compiler/lib/src/elements/elements.dart b/pkg/compiler/lib/src/elements/elements.dart
index e6cb031..1170cd7 100644
--- a/pkg/compiler/lib/src/elements/elements.dart
+++ b/pkg/compiler/lib/src/elements/elements.dart
@@ -904,7 +904,7 @@
}
abstract class LibraryElement extends Element
- implements ScopeContainerElement, AnalyzableElement {
+ implements ScopeContainerElement, AnalyzableElement, LibraryEntity {
/**
* The canonical uri for this library.
*
@@ -1113,6 +1113,9 @@
FunctionTypedElement get functionDeclaration;
VariableDefinitions get node;
+
+ /// Whether the parameter is unnamed in a function type.
+ bool get isUnnamed;
}
/// A formal parameter of a function or constructor.
diff --git a/pkg/compiler/lib/src/elements/entities.dart b/pkg/compiler/lib/src/elements/entities.dart
index c794268..df0abbe 100644
--- a/pkg/compiler/lib/src/elements/entities.dart
+++ b/pkg/compiler/lib/src/elements/entities.dart
@@ -6,6 +6,14 @@
import 'elements.dart' show Entity;
+/// Stripped down super interface for library like entities.
+///
+/// Currently only [LibraryElement] but later also kernel based Dart classes
+/// and/or Dart-in-JS classes.
+abstract class LibraryEntity extends Entity {
+ String get libraryName;
+}
+
/// Stripped down super interface for class like entities.
///
/// Currently only [ClassElement] but later also kernel based Dart classes
diff --git a/pkg/compiler/lib/src/elements/modelx.dart b/pkg/compiler/lib/src/elements/modelx.dart
index 4d5c79d..cd8e04c 100644
--- a/pkg/compiler/lib/src/elements/modelx.dart
+++ b/pkg/compiler/lib/src/elements/modelx.dart
@@ -163,7 +163,7 @@
ClassElement get enclosingClass {
for (Element e = this; e != null; e = e.enclosingElement) {
- if (e.isClass) return e;
+ if (e.isClass) return e.declaration;
}
return null;
}
@@ -1345,7 +1345,7 @@
ResolutionTypedefType computeType(Resolution resolution) {
if (thisTypeCache != null) return thisTypeCache;
Typedef node = parseNode(resolution.parsingContext);
- setThisAndRawTypes(createTypeVariables(node.typeParameters));
+ setThisAndRawTypes(createTypeVariables(node.templateParameters));
ensureResolved(resolution);
return thisTypeCache;
}
@@ -1743,6 +1743,15 @@
: this.identifier = identifier,
super(identifier.source, elementKind, enclosingElement);
+ FormalElementX.unnamed(ElementKind elementKind,
+ FunctionTypedElement enclosingElement,
+ this.definitions)
+ : this.identifier = null,
+ super("<unnamed>", elementKind, enclosingElement);
+
+ /// Whether this is an unnamed parameter in a Function type.
+ bool get isUnnamed => identifier == null;
+
FunctionTypedElement get functionDeclaration => enclosingElement;
Modifiers get modifiers => definitions.modifiers;
@@ -2357,7 +2366,7 @@
ConstructorElement get definingConstructor => null;
- ClassElement get enclosingClass => enclosingElement;
+ ClassElement get enclosingClass => enclosingElement.declaration;
}
class DeferredLoaderGetterElementX extends GetterElementX
diff --git a/pkg/compiler/lib/src/elements/names.dart b/pkg/compiler/lib/src/elements/names.dart
index e38def0..a4a6f7a 100644
--- a/pkg/compiler/lib/src/elements/names.dart
+++ b/pkg/compiler/lib/src/elements/names.dart
@@ -37,7 +37,7 @@
/// Returns `true` if an entity of this name is accessible from library
/// [element].
- bool isAccessibleFrom(LibraryElement element);
+ bool isAccessibleFrom(LibraryEntity element);
/// Returns `true` if this name is private.
bool get isPrivate;
@@ -47,7 +47,7 @@
bool isSimilarTo(Name other);
int get similarHashCode;
- LibraryElement get library;
+ LibraryEntity get library;
/// Returns `true` when [s] is private if used as an identifier.
static bool isPrivateName(String s) => !s.isEmpty && s.codeUnitAt(0) == $_;
@@ -66,7 +66,7 @@
Name get setter => isSetter ? this : new PublicName(text, isSetter: true);
- bool isAccessibleFrom(LibraryElement element) => true;
+ bool isAccessibleFrom(LibraryEntity element) => true;
bool get isPrivate => false;
@@ -81,13 +81,13 @@
text == other.text && isSetter == other.isSetter;
int get similarHashCode => text.hashCode + 11 * isSetter.hashCode;
- LibraryElement get library => null;
+ LibraryEntity get library => null;
String toString() => isSetter ? '$text=' : text;
}
class PrivateName extends PublicName {
- final LibraryElement library;
+ final LibraryEntity library;
PrivateName(String text, this.library, {bool isSetter: false})
: super(text, isSetter: isSetter);
diff --git a/pkg/compiler/lib/src/elements/resolution_types.dart b/pkg/compiler/lib/src/elements/resolution_types.dart
index 19fd8c8..3ba3468a 100644
--- a/pkg/compiler/lib/src/elements/resolution_types.dart
+++ b/pkg/compiler/lib/src/elements/resolution_types.dart
@@ -642,6 +642,16 @@
optionalParameterTypes, namedParameters, namedParameterTypes);
}
+ factory ResolutionFunctionType.generalized(
+ ResolutionDartType returnType,
+ List<ResolutionDartType> parameterTypes,
+ List<ResolutionDartType> optionalParameterTypes,
+ List<String> namedParameters,
+ List<ResolutionDartType> namedParameterTypes) {
+ return new ResolutionFunctionType.internal(null, returnType, parameterTypes,
+ optionalParameterTypes, namedParameters, namedParameterTypes);
+ }
+
ResolutionFunctionType.internal(FunctionTypedElement this.element,
[ResolutionDartType returnType = const ResolutionDynamicType(),
List<ResolutionDartType> parameterTypes = const <ResolutionDartType>[],
diff --git a/pkg/compiler/lib/src/enqueue.dart b/pkg/compiler/lib/src/enqueue.dart
index db112d0..efbcc50 100644
--- a/pkg/compiler/lib/src/enqueue.dart
+++ b/pkg/compiler/lib/src/enqueue.dart
@@ -67,8 +67,7 @@
}
abstract class Enqueuer {
- // TODO(johnniwinther): Rename to `worldBuilder`.
- WorldBuilder get universe;
+ WorldBuilder get worldBuilder;
native.NativeEnqueuer get nativeEnqueuer;
void forgetEntity(Entity entity, Compiler compiler);
@@ -168,7 +167,7 @@
_impactVisitor = new EnqueuerImplImpactVisitor(this);
}
- ResolutionWorldBuilder get universe => _universe;
+ ResolutionWorldBuilder get worldBuilder => _universe;
bool get queueIsEmpty => _queue.isEmpty;
@@ -298,7 +297,7 @@
break;
case TypeUseKind.TYPE_LITERAL:
if (type.isTypedef) {
- universe.registerTypedef(type.element);
+ worldBuilder.registerTypedef(type.element);
}
break;
}
@@ -483,7 +482,7 @@
enqueuer.task.measure(() {
// Run through the classes and see if we need to enqueue more methods.
for (ClassElement classElement
- in enqueuer.universe.directlyInstantiatedClasses) {
+ in enqueuer.worldBuilder.directlyInstantiatedClasses) {
for (ClassElement currentClass = classElement;
currentClass != null;
currentClass = currentClass.superclass) {
diff --git a/pkg/compiler/lib/src/helpers/debug_collection.dart b/pkg/compiler/lib/src/helpers/debug_collection.dart
index b20bf0c..3ff3f49 100644
--- a/pkg/compiler/lib/src/helpers/debug_collection.dart
+++ b/pkg/compiler/lib/src/helpers/debug_collection.dart
@@ -71,11 +71,11 @@
Iterator<E> get iterator => iterable.iterator;
- Iterable map(f(E element)) => iterable.map(f);
+ Iterable<T> map<T>(T f(E element)) => iterable.map(f);
Iterable<E> where(bool test(E element)) => iterable.where(test);
- Iterable expand(Iterable f(E element)) => iterable.expand(f);
+ Iterable<T> expand<T>(Iterable<T> f(E element)) => iterable.expand(f);
bool contains(Object element) => iterable.contains(element);
@@ -83,8 +83,7 @@
E reduce(E combine(E value, E element)) => iterable.reduce(combine);
- dynamic fold(
- var initialValue, dynamic combine(var previousValue, E element)) {
+ T fold<T>(T initialValue, T combine(T previousValue, E element)) {
return iterable.fold(initialValue, combine);
}
diff --git a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart b/pkg/compiler/lib/src/inferrer/builder.dart
similarity index 98%
rename from pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
rename to pkg/compiler/lib/src/inferrer/builder.dart
index 476b0fc..ae3c1c6 100644
--- a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
+++ b/pkg/compiler/lib/src/inferrer/builder.dart
@@ -28,11 +28,11 @@
import '../util/util.dart' show Link, Setlet;
import '../world.dart' show ClosedWorld;
import 'inferrer_engine.dart';
-import 'inferrer_visitor.dart';
+import 'locals_handler.dart';
import 'type_graph_nodes.dart';
import 'type_system.dart';
-/// [SimpleTypeInferrerVisitor] can be thought of as a type-inference graph
+/// [ElementGraphBuilder] can be thought of as a type-inference graph
/// builder for a single element.
///
/// Calling [run] will start the work of visiting the body of the code to
@@ -41,7 +41,7 @@
///
/// This visitor is parameterized by an [InferenceEngine], which internally
/// decides how to represent inference nodes.
-class SimpleTypeInferrerVisitor extends ast.Visitor<TypeInformation>
+class ElementGraphBuilder extends ast.Visitor<TypeInformation>
with
SemanticSendResolvedMixin<TypeInformation, dynamic>,
CompoundBulkMixin<TypeInformation, dynamic>,
@@ -74,7 +74,7 @@
final Setlet<Entity> capturedVariables = new Setlet<Entity>();
final GlobalTypeInferenceElementData inTreeData;
- SimpleTypeInferrerVisitor.internal(
+ ElementGraphBuilder.internal(
AstElement analyzedElement,
this.resolvedAst,
this.outermostElement,
@@ -99,7 +99,7 @@
new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
}
- SimpleTypeInferrerVisitor(Element element, ResolvedAst resolvedAst,
+ ElementGraphBuilder(Element element, ResolvedAst resolvedAst,
Compiler compiler, InferrerEngine inferrer, [LocalsHandler handler])
: this.internal(
element,
@@ -923,10 +923,10 @@
// a mixin application), we have to start a new inferrer visitor
// with the correct context.
// TODO(johnniwinther): Remove once function signatures are fixed.
- SimpleTypeInferrerVisitor visitor = this;
+ ElementGraphBuilder visitor = this;
if (inferrer.hasAlreadyComputedTypeOfParameterDefault(element)) return;
if (element.functionDeclaration != analyzedElement) {
- visitor = new SimpleTypeInferrerVisitor(element.functionDeclaration,
+ visitor = new ElementGraphBuilder(element.functionDeclaration,
element.functionDeclaration.resolvedAst, compiler, inferrer);
}
TypeInformation type =
@@ -1075,7 +1075,7 @@
// method, like for example the types of local variables.
LocalsHandler closureLocals =
new LocalsHandler.from(locals, node, useOtherTryBlock: false);
- SimpleTypeInferrerVisitor visitor = new SimpleTypeInferrerVisitor(
+ ElementGraphBuilder visitor = new ElementGraphBuilder(
element, element.resolvedAst, compiler, inferrer, closureLocals);
visitor.run();
inferrer.recordReturnType(element, visitor.returnType);
@@ -1171,8 +1171,8 @@
bool isThisOrSuper(ast.Node node) => node.isThis() || node.isSuper();
bool isInClassOrSubclass(Element element) {
- ClassElement cls = outermostElement.enclosingClass.declaration;
- ClassElement enclosing = element.enclosingClass.declaration;
+ ClassElement cls = outermostElement.enclosingClass;
+ ClassElement enclosing = element.enclosingClass;
return closedWorld.isSubclassOf(enclosing, cls);
}
@@ -2028,7 +2028,7 @@
TypeMask mask, ArgumentsTypes arguments) {
// Ensure we create a node, to make explicit the call to the
// `noSuchMethod` handler.
- ClassElement cls = outermostElement.enclosingClass.declaration;
+ ClassElement cls = outermostElement.enclosingClass;
MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
if (!Selectors.noSuchMethod_.signatureApplies(element)) {
element = compiler.commonElements.objectClass
diff --git a/pkg/compiler/lib/src/inferrer/inferrer_engine.dart b/pkg/compiler/lib/src/inferrer/inferrer_engine.dart
index 049a86a..fc6d0bf 100644
--- a/pkg/compiler/lib/src/inferrer/inferrer_engine.dart
+++ b/pkg/compiler/lib/src/inferrer/inferrer_engine.dart
@@ -22,10 +22,10 @@
import '../world.dart';
import 'closure_tracer.dart';
import 'debug.dart' as debug;
-import 'inferrer_visitor.dart';
+import 'locals_handler.dart';
import 'list_tracer.dart';
import 'map_tracer.dart';
-import 'simple_types_inferrer.dart';
+import 'builder.dart';
import 'type_graph_dump.dart';
import 'type_graph_inferrer.dart';
import 'type_graph_nodes.dart';
@@ -464,8 +464,8 @@
if (analyzedElements.contains(element)) return;
analyzedElements.add(element);
- SimpleTypeInferrerVisitor visitor =
- new SimpleTypeInferrerVisitor(element, resolvedAst, compiler, this);
+ ElementGraphBuilder visitor =
+ new ElementGraphBuilder(element, resolvedAst, compiler, this);
TypeInformation type;
reporter.withCurrentElement(element, () {
type = visitor.run();
@@ -788,7 +788,7 @@
/**
* Notifies to the inferrer that [analyzedElement] can have return
- * type [newType]. [currentType] is the type the [InferrerVisitor]
+ * type [newType]. [currentType] is the type the [ElementGraphBuilder]
* currently found.
*
* Returns the new type for [analyzedElement].
@@ -834,7 +834,7 @@
// If this class has a 'call' method then we have essentially created a
// closure here. Register it as such so that it is traced.
if (selector != null && selector.isCall && callee.isConstructor) {
- ClassElement cls = callee.enclosingClass.declaration;
+ ClassElement cls = callee.enclosingClass;
if (cls.callType != null) {
types.allocatedClosures.add(info);
}
diff --git a/pkg/compiler/lib/src/inferrer/inferrer_visitor.dart b/pkg/compiler/lib/src/inferrer/locals_handler.dart
similarity index 96%
rename from pkg/compiler/lib/src/inferrer/inferrer_visitor.dart
rename to pkg/compiler/lib/src/inferrer/locals_handler.dart
index 96aedd9..1f588e7 100644
--- a/pkg/compiler/lib/src/inferrer/inferrer_visitor.dart
+++ b/pkg/compiler/lib/src/inferrer/locals_handler.dart
@@ -2,27 +2,14 @@
// 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.
-library inferrer_visitor;
+library locals_handler;
import 'dart:collection' show IterableMixin;
-import '../common.dart';
import '../options.dart' show CompilerOptions;
-import '../compiler.dart' show Compiler;
-import '../constants/constant_system.dart';
-import '../constants/expressions.dart';
-import '../elements/resolution_types.dart';
import '../elements/elements.dart';
-import '../resolution/operators.dart';
-import '../resolution/semantic_visitor.dart';
-import '../resolution/tree_elements.dart' show TreeElements;
import '../tree/tree.dart';
-import '../types/constants.dart' show computeTypeMask;
-import '../types/types.dart' show TypeMask;
-import '../universe/call_structure.dart' show CallStructure;
-import '../universe/selector.dart' show Selector;
import '../util/util.dart';
-import '../world.dart' show ClosedWorld;
import 'inferrer_engine.dart';
import 'type_graph_nodes.dart';
import 'type_system.dart';
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
index 92c2b46..16c9260 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
@@ -32,7 +32,7 @@
import '../util/util.dart' show ImmutableEmptySet, Setlet;
import '../world.dart' show ClosedWorld;
import 'debug.dart' as debug;
-import 'inferrer_visitor.dart' show ArgumentsTypes;
+import 'locals_handler.dart' show ArgumentsTypes;
import 'inferrer_engine.dart';
import 'type_system.dart';
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart
index 87ce42f..2aa4156 100644
--- a/pkg/compiler/lib/src/js_backend/backend.dart
+++ b/pkg/compiler/lib/src/js_backend/backend.dart
@@ -643,12 +643,13 @@
library == helpers.jsHelperLibrary;
}
- Namer determineNamer(ClosedWorld closedWorld) {
+ Namer determineNamer(
+ ClosedWorld closedWorld, CodegenWorldBuilder codegenWorldBuilder) {
return compiler.options.enableMinification
? compiler.options.useFrequencyNamer
- ? new FrequencyBasedNamer(this, closedWorld)
- : new MinifyNamer(this, closedWorld)
- : new Namer(this, closedWorld);
+ ? new FrequencyBasedNamer(this, closedWorld, codegenWorldBuilder)
+ : new MinifyNamer(this, closedWorld, codegenWorldBuilder)
+ : new Namer(this, closedWorld, codegenWorldBuilder);
}
/// The backend must *always* call this method when enqueuing an
@@ -1081,8 +1082,8 @@
} else if (constant.isInterceptor) {
// An interceptor constant references the class's prototype chain.
InterceptorConstantValue interceptor = constant;
- computeImpactForInstantiatedConstantType(
- interceptor.dispatchedType, impactBuilder);
+ ClassElement cls = interceptor.cls;
+ computeImpactForInstantiatedConstantType(cls.thisType, impactBuilder);
} else if (constant.isType) {
if (isForResolution) {
impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
@@ -1291,7 +1292,7 @@
}
computeMembersNeededForReflection(closedWorld);
rti.computeClassesNeedingRti(
- compiler.enqueuer.resolution.universe, closedWorld);
+ compiler.enqueuer.resolution.worldBuilder, closedWorld);
_registeredMetadata.clear();
}
@@ -2048,13 +2049,15 @@
// can include the correct ones when including the class.
Map<ClassElement, List<LocalFunctionElement>> closureMap =
new Map<ClassElement, List<LocalFunctionElement>>();
- for (LocalFunctionElement closure in compiler.resolverWorld.allClosures) {
+ for (LocalFunctionElement closure
+ in compiler.resolutionWorldBuilder.allClosures) {
closureMap.putIfAbsent(closure.enclosingClass, () => []).add(closure);
}
bool foundClosure = false;
Set<Element> reflectableMembers = new Set<Element>();
ResolutionEnqueuer resolution = compiler.enqueuer.resolution;
- for (ClassElement cls in resolution.universe.directlyInstantiatedClasses) {
+ for (ClassElement cls
+ in resolution.worldBuilder.directlyInstantiatedClasses) {
// Do not process internal classes.
if (cls.library.isInternalLibrary || cls.isInjected) continue;
if (referencedFromMirrorSystem(cls)) {
@@ -2157,7 +2160,8 @@
if (foundClosure) {
reflectableMembers.add(helpers.closureClass);
}
- Set<Element> closurizedMembers = compiler.resolverWorld.closurizedMembers;
+ Set<Element> closurizedMembers =
+ compiler.resolutionWorldBuilder.closurizedMembers;
if (closurizedMembers.any(reflectableMembers.contains)) {
reflectableMembers.add(helpers.boundClosureClass);
}
@@ -2309,7 +2313,7 @@
StagedWorldImpactBuilder impactBuilder = enqueuer.isResolutionQueue
? constantImpactsForResolution
- : constantImpactsForResolution;
+ : constantImpactsForCodegen;
if (enqueuer.isResolutionQueue && !enqueuer.queueIsClosed) {
/// Register the constant value of [metadata] as live in resolution.
void registerMetadataConstant(MetadataAnnotation metadata) {
@@ -2361,7 +2365,15 @@
}
}
if (element.enclosingClass != null) {
- processElementMetadata(element.enclosingClass);
+ // Only process library of top level fields/methods
+ // (and not for classes).
+ // TODO(johnniwinther): Fix this: We are missing some metadata on
+ // libraries (example: in co19/Language/Metadata/before_export_t01).
+ if (element.enclosingElement is ClassElement) {
+ // Use [enclosingElement] instead of [enclosingClass] to ensure that
+ // we process patch class metadata for patch and injected members.
+ processElementMetadata(element.enclosingElement);
+ }
} else {
processLibraryMetadata(element.library);
}
@@ -2391,7 +2403,7 @@
WorldImpact onCodegenStart(ClosedWorld closedWorld) {
_closedWorld = closedWorld;
- _namer = determineNamer(_closedWorld);
+ _namer = determineNamer(_closedWorld, compiler.codegenWorldBuilder);
tracer = new Tracer(_closedWorld, namer, compiler.outputProvider);
emitter.createEmitter(_namer, _closedWorld);
lookupMapAnalysis.onCodegenStart();
@@ -3258,7 +3270,7 @@
helpers.jsIndexingBehaviorInterface;
ClassElement get interceptorImplementation => helpers.jsInterceptorClass;
- bool isDefaultEqualityImplementation(Element element) {
+ bool isDefaultEqualityImplementation(MemberElement element) {
assert(element.name == '==');
ClassElement classElement = element.enclosingClass;
return classElement == helpers.commonElements.objectClass ||
diff --git a/pkg/compiler/lib/src/js_backend/constant_emitter.dart b/pkg/compiler/lib/src/js_backend/constant_emitter.dart
index 15787e7..054372f 100644
--- a/pkg/compiler/lib/src/js_backend/constant_emitter.dart
+++ b/pkg/compiler/lib/src/js_backend/constant_emitter.dart
@@ -277,7 +277,7 @@
@override
jsAst.Expression visitInterceptor(InterceptorConstantValue constant, [_]) {
- ClassElement interceptorClass = constant.dispatchedType.element;
+ ClassElement interceptorClass = constant.cls;
return backend.emitter.interceptorPrototypeAccess(interceptorClass);
}
diff --git a/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart b/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart
index 40dcd8f..1571c41 100644
--- a/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart
+++ b/pkg/compiler/lib/src/js_backend/constant_system_javascript.dart
@@ -320,10 +320,10 @@
@override
ConstantValue createType(Compiler compiler, ResolutionDartType type) {
- return new TypeConstantValue(
- type,
- compiler.backend.backendClasses.typeImplementation
- .computeType(compiler.resolution));
+ ResolutionInterfaceType instanceType = compiler
+ .backend.backendClasses.typeImplementation
+ .computeType(compiler.resolution);
+ return new TypeConstantValue(type, instanceType);
}
// Integer checks report true for -0.0, INFINITY, and -INFINITY. At
@@ -382,7 +382,7 @@
}
bool hasProtoKey = (protoValue != null);
- ResolutionDartType keysType;
+ ResolutionInterfaceType keysType;
if (sourceType.treatAsRaw) {
keysType = commonElements.listType();
} else {
diff --git a/pkg/compiler/lib/src/js_backend/enqueuer.dart b/pkg/compiler/lib/src/js_backend/enqueuer.dart
index 65759e5..603e667 100644
--- a/pkg/compiler/lib/src/js_backend/enqueuer.dart
+++ b/pkg/compiler/lib/src/js_backend/enqueuer.dart
@@ -72,7 +72,7 @@
_impactVisitor = new EnqueuerImplImpactVisitor(this);
}
- CodegenWorldBuilder get universe => _universe;
+ CodegenWorldBuilder get worldBuilder => _universe;
bool get queueIsEmpty => _queue.isEmpty;
diff --git a/pkg/compiler/lib/src/js_backend/frequency_namer.dart b/pkg/compiler/lib/src/js_backend/frequency_namer.dart
index 0d4157b..49aecfe 100644
--- a/pkg/compiler/lib/src/js_backend/frequency_namer.dart
+++ b/pkg/compiler/lib/src/js_backend/frequency_namer.dart
@@ -25,8 +25,9 @@
jsAst.Name get staticsPropertyName =>
_staticsPropertyName ??= getFreshName(instanceScope, 'static');
- FrequencyBasedNamer(JavaScriptBackend backend, ClosedWorld closedWorld)
- : super(backend, closedWorld) {
+ FrequencyBasedNamer(JavaScriptBackend backend, ClosedWorld closedWorld,
+ CodegenWorldBuilder codegenWorldBuilder)
+ : super(backend, closedWorld, codegenWorldBuilder) {
fieldRegistry = new _FieldNamingRegistry(this);
}
diff --git a/pkg/compiler/lib/src/js_backend/js_interop_analysis.dart b/pkg/compiler/lib/src/js_backend/js_interop_analysis.dart
index a89326b..b2ad759 100644
--- a/pkg/compiler/lib/src/js_backend/js_interop_analysis.dart
+++ b/pkg/compiler/lib/src/js_backend/js_interop_analysis.dart
@@ -117,7 +117,10 @@
// Skip classes that are completely unreachable. This should only happen
// when all of jsinterop types are unreachable from main.
- if (!backend.compiler.resolverWorld.isImplemented(classElement)) return;
+ if (!backend.compiler.resolutionWorldBuilder
+ .isImplemented(classElement)) {
+ return;
+ }
if (!classElement.implementsInterface(helpers.jsJavaScriptObjectClass)) {
backend.reporter.reportErrorMessage(classElement,
@@ -166,7 +169,7 @@
jsAst.Statement buildJsInteropBootstrap() {
if (!enabledJsInterop) return null;
List<jsAst.Statement> statements = <jsAst.Statement>[];
- backend.compiler.codegenWorld.forEachInvokedName(
+ backend.compiler.codegenWorldBuilder.forEachInvokedName(
(String name, Map<Selector, SelectorConstraints> selectors) {
selectors.forEach((Selector selector, SelectorConstraints constraints) {
if (selector.isClosureCall) {
@@ -189,7 +192,7 @@
}
ResolutionFunctionType buildJsFunctionType() {
- // TODO(jacobr): consider using codegenWorld.isChecks to determine the
+ // TODO(jacobr): consider using codegenWorldBuilder.isChecks to determine the
// range of positional arguments that need to be supported by JavaScript
// function types.
return new ResolutionFunctionType.synthesized(
diff --git a/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart b/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart
index d7bf72e..eb9aa3c 100644
--- a/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart
+++ b/pkg/compiler/lib/src/js_backend/lookup_map_analysis.dart
@@ -201,10 +201,13 @@
}
/// Whether [constant] is an instance of a `LookupMap`.
- bool isLookupMap(ConstantValue constant) =>
- _isEnabled &&
- constant is ConstructedConstantValue &&
- constant.type.asRaw().element.isSubclassOf(typeLookupMapClass);
+ bool isLookupMap(ConstantValue constant) {
+ if (_isEnabled && constant is ConstructedConstantValue) {
+ ResolutionInterfaceType type = constant.type;
+ return type.element.isSubclassOf(typeLookupMapClass);
+ }
+ return false;
+ }
/// Registers an instance of a lookup-map with the analysis.
void registerLookupMapReference(ConstantValue lookupMap) {
@@ -246,13 +249,12 @@
/// If [key] is a type, cache it in [_typeConstants].
_registerTypeKey(ConstantValue key) {
- if (key is TypeConstantValue) {
- ClassElement cls = key.representedType.element;
- if (cls == null || !cls.isClass) {
- // TODO(sigmund): report error?
- return;
- }
- _typeConstants[cls] = key;
+ if (key is TypeConstantValue &&
+ key.representedType is ResolutionInterfaceType) {
+ ResolutionInterfaceType type = key.representedType;
+ _typeConstants[type.element] = key;
+ } else {
+ // TODO(sigmund): report error?
}
}
@@ -431,7 +433,7 @@
/// Restores [original] to contain all of the entries marked as possibly used.
void _prepareForEmission() {
ListConstantValue originalEntries = original.fields[analysis.entriesField];
- ResolutionDartType listType = originalEntries.type;
+ ResolutionInterfaceType listType = originalEntries.type;
List<ConstantValue> keyValuePairs = <ConstantValue>[];
usedEntries.forEach((key, value) {
keyValuePairs.add(key);
diff --git a/pkg/compiler/lib/src/js_backend/minify_namer.dart b/pkg/compiler/lib/src/js_backend/minify_namer.dart
index 10504c4..f0fdcb8 100644
--- a/pkg/compiler/lib/src/js_backend/minify_namer.dart
+++ b/pkg/compiler/lib/src/js_backend/minify_namer.dart
@@ -12,8 +12,9 @@
_MinifiedFieldNamer,
_MinifyConstructorBodyNamer,
_MinifiedOneShotInterceptorNamer {
- MinifyNamer(JavaScriptBackend backend, ClosedWorld closedWorld)
- : super(backend, closedWorld) {
+ MinifyNamer(JavaScriptBackend backend, ClosedWorld closedWorld,
+ CodegenWorldBuilder codegenWorldBuilder)
+ : super(backend, closedWorld, codegenWorldBuilder) {
reserveBackendNames();
fieldRegistry = new _FieldNamingRegistry(this);
}
diff --git a/pkg/compiler/lib/src/js_backend/namer.dart b/pkg/compiler/lib/src/js_backend/namer.dart
index c5b70b8..bfabd01 100644
--- a/pkg/compiler/lib/src/js_backend/namer.dart
+++ b/pkg/compiler/lib/src/js_backend/namer.dart
@@ -23,6 +23,7 @@
import '../tree/tree.dart';
import '../universe/call_structure.dart' show CallStructure;
import '../universe/selector.dart' show Selector, SelectorKind;
+import '../universe/world_builder.dart' show CodegenWorldBuilder;
import '../util/characters.dart';
import '../util/util.dart';
import '../world.dart' show ClosedWorld;
@@ -404,6 +405,7 @@
final JavaScriptBackend backend;
final ClosedWorld closedWorld;
+ final CodegenWorldBuilder codegenWorldBuilder;
/// Used disambiguated names in the global namespace, issued by
/// [_disambiguateGlobal], and [_disambiguateInternalGlobal].
@@ -460,10 +462,12 @@
final Map<LibraryElement, String> _libraryKeys =
new HashMap<LibraryElement, String>();
- Namer(JavaScriptBackend backend, this.closedWorld)
+ Namer(JavaScriptBackend backend, this.closedWorld,
+ CodegenWorldBuilder codegenWorldBuilder)
: this.backend = backend,
- constantHasher =
- new ConstantCanonicalHasher(backend.rtiEncoder, backend.reporter),
+ this.codegenWorldBuilder = codegenWorldBuilder,
+ constantHasher = new ConstantCanonicalHasher(
+ backend.rtiEncoder, backend.reporter, codegenWorldBuilder),
functionTypeNamer = new FunctionTypeNamer(backend.rtiEncoder) {
_literalAsyncPrefix = new StringBackedName(asyncPrefix);
_literalGetterPrefix = new StringBackedName(getterPrefix);
@@ -592,7 +596,7 @@
String longName = constantLongNames[constant];
if (longName == null) {
longName = new ConstantNamingVisitor(
- backend.rtiEncoder, reporter, constantHasher)
+ backend.rtiEncoder, reporter, codegenWorldBuilder, constantHasher)
.getName(constant);
constantLongNames[constant] = longName;
}
@@ -1645,6 +1649,7 @@
final RuntimeTypesEncoder rtiEncoder;
final DiagnosticReporter reporter;
+ final CodegenWorldBuilder codegenWorldBuilder;
final ConstantCanonicalHasher hasher;
String root = null; // First word, usually a type name.
@@ -1652,7 +1657,8 @@
List<String> fragments = <String>[];
int length = 0;
- ConstantNamingVisitor(this.rtiEncoder, this.reporter, this.hasher);
+ ConstantNamingVisitor(
+ this.rtiEncoder, this.reporter, this.codegenWorldBuilder, this.hasher);
String getName(ConstantValue constant) {
_visit(constant);
@@ -1781,10 +1787,12 @@
@override
void visitConstructed(ConstructedConstantValue constant, [_]) {
addRoot(constant.type.element.name);
- constant.type.element.forEachInstanceField((_, FieldElement field) {
+ // TODO(johnniwinther): This should be accessed from a codegen closed world.
+ codegenWorldBuilder.forEachInstanceField(constant.type.element,
+ (_, FieldElement field) {
if (failed) return;
_visit(constant.fields[field]);
- }, includeSuperAndInjectedMembers: true);
+ });
}
@override
@@ -1804,7 +1812,7 @@
@override
void visitInterceptor(InterceptorConstantValue constant, [_]) {
- addRoot(constant.dispatchedType.element.name);
+ addRoot(constant.cls.name);
add('methods');
}
@@ -1846,9 +1854,11 @@
final DiagnosticReporter reporter;
final RuntimeTypesEncoder rtiEncoder;
+ final CodegenWorldBuilder codegenWorldBuilder;
final Map<ConstantValue, int> hashes = new Map<ConstantValue, int>();
- ConstantCanonicalHasher(this.rtiEncoder, this.reporter);
+ ConstantCanonicalHasher(
+ this.rtiEncoder, this.reporter, this.codegenWorldBuilder);
int getHash(ConstantValue constant) => _visit(constant);
@@ -1906,9 +1916,10 @@
@override
int visitConstructed(ConstructedConstantValue constant, [_]) {
int hash = _hashString(3, constant.type.element.name);
- constant.type.element.forEachInstanceField((_, FieldElement field) {
+ codegenWorldBuilder.forEachInstanceField(constant.type.element,
+ (_, FieldElement field) {
hash = _combine(hash, _visit(constant.fields[field]));
- }, includeSuperAndInjectedMembers: true);
+ });
return hash;
}
@@ -1922,7 +1933,7 @@
@override
int visitInterceptor(InterceptorConstantValue constant, [_]) {
- String typeName = constant.dispatchedType.element.name;
+ String typeName = constant.cls.name;
return _hashString(5, typeName);
}
diff --git a/pkg/compiler/lib/src/js_backend/no_such_method_registry.dart b/pkg/compiler/lib/src/js_backend/no_such_method_registry.dart
index 00b9ac7..ea09888 100644
--- a/pkg/compiler/lib/src/js_backend/no_such_method_registry.dart
+++ b/pkg/compiler/lib/src/js_backend/no_such_method_registry.dart
@@ -219,7 +219,8 @@
}
if (expr is Send && expr.isTypeCast) {
Send sendExpr = expr;
- var typeName = sendExpr.typeAnnotationFromIsCheckOrCast.typeName;
+ var typeAnnotation = sendExpr.typeAnnotationFromIsCheckOrCast;
+ var typeName = typeAnnotation.asNominalTypeAnnotation()?.typeName;
if (typeName is Identifier && typeName.source == "dynamic") {
expr = sendExpr.receiver;
}
diff --git a/pkg/compiler/lib/src/js_backend/runtime_types.dart b/pkg/compiler/lib/src/js_backend/runtime_types.dart
index 08f0dcb..d8bb379 100644
--- a/pkg/compiler/lib/src/js_backend/runtime_types.dart
+++ b/pkg/compiler/lib/src/js_backend/runtime_types.dart
@@ -36,7 +36,7 @@
Set<ClassElement> getClassesUsedInSubstitutions(
JavaScriptBackend backend, TypeChecks checks);
void computeClassesNeedingRti(
- ResolutionWorldBuilder resolverWorld, ClosedWorld closedWorld);
+ ResolutionWorldBuilder resolutionWorldBuilder, ClosedWorld closedWorld);
/// Compute the required type checkes and substitutions for the given
/// instantitated and checked classes.
@@ -48,7 +48,7 @@
///
/// This function must be called after all is-checks have been registered.
void addImplicitChecks(
- WorldBuilder universe, Iterable<ClassElement> classesUsingChecks);
+ WorldBuilder worldBuilder, Iterable<ClassElement> classesUsingChecks);
/// Return all classes that are referenced in the type of the function, i.e.,
/// in the return type or the argument types.
@@ -173,18 +173,18 @@
*/
@override
void addImplicitChecks(
- WorldBuilder universe, Iterable<ClassElement> classesUsingChecks) {
+ WorldBuilder worldBuilder, Iterable<ClassElement> classesUsingChecks) {
// If there are no classes that use their variables in checks, there is
// nothing to do.
if (classesUsingChecks.isEmpty) return;
- Set<ResolutionDartType> instantiatedTypes = universe.instantiatedTypes;
+ Set<ResolutionDartType> instantiatedTypes = worldBuilder.instantiatedTypes;
if (cannotDetermineInstantiatedTypesPrecisely) {
for (ResolutionDartType type in instantiatedTypes) {
if (type.kind != ResolutionTypeKind.INTERFACE) continue;
ResolutionInterfaceType interface = type;
do {
for (ResolutionDartType argument in interface.typeArguments) {
- universe.registerIsCheck(argument);
+ worldBuilder.registerIsCheck(argument);
}
interface = interface.element.supertype;
} while (interface != null && !instantiatedTypes.contains(interface));
@@ -207,7 +207,7 @@
ResolutionInterfaceType instance = current.asInstanceOf(cls);
if (instance == null) break;
for (ResolutionDartType argument in instance.typeArguments) {
- universe.registerIsCheck(argument);
+ worldBuilder.registerIsCheck(argument);
}
current = current.element.supertype;
} while (current != null && !instantiatedTypes.contains(current));
@@ -218,7 +218,7 @@
@override
void computeClassesNeedingRti(
- ResolutionWorldBuilder resolverWorld, ClosedWorld closedWorld) {
+ ResolutionWorldBuilder resolutionWorldBuilder, ClosedWorld closedWorld) {
// Find the classes that need runtime type information. Such
// classes are:
// (1) used in a is check with type variables,
@@ -244,7 +244,7 @@
}
Set<ClassElement> classesUsingTypeVariableTests = new Set<ClassElement>();
- resolverWorld.isChecks.forEach((ResolutionDartType type) {
+ resolutionWorldBuilder.isChecks.forEach((ResolutionDartType type) {
if (type.isTypeVariable) {
TypeVariableElement variable = type.element;
// GENERIC_METHODS: When generic method support is complete enough to
@@ -256,7 +256,8 @@
}
});
// Add is-checks that result from classes using type variables in checks.
- addImplicitChecks(compiler.resolverWorld, classesUsingTypeVariableTests);
+ addImplicitChecks(
+ compiler.resolutionWorldBuilder, classesUsingTypeVariableTests);
// Add the rti dependencies that are implicit in the way the backend
// generates code: when we create a new [List], we actually create
// a JSArray in the backend and we need to add type arguments to
@@ -269,7 +270,7 @@
}
// Compute the set of all classes and methods that need runtime type
// information.
- compiler.resolverWorld.isChecks.forEach((ResolutionDartType type) {
+ compiler.resolutionWorldBuilder.isChecks.forEach((ResolutionDartType type) {
if (type.isInterfaceType) {
ResolutionInterfaceType itf = type;
if (!itf.treatAsRaw) {
@@ -294,9 +295,9 @@
}
}
- compiler.resolverWorld.closuresWithFreeTypeVariables
+ compiler.resolutionWorldBuilder.closuresWithFreeTypeVariables
.forEach(analyzeMethod);
- compiler.resolverWorld.callMethodsWithFreeTypeVariables
+ compiler.resolutionWorldBuilder.callMethodsWithFreeTypeVariables
.forEach(analyzeMethod);
}
}
@@ -311,9 +312,9 @@
}
}
- compiler.resolverWorld.closuresWithFreeTypeVariables
+ compiler.resolutionWorldBuilder.closuresWithFreeTypeVariables
.forEach(analyzeMethod);
- compiler.resolverWorld.callMethodsWithFreeTypeVariables
+ compiler.resolutionWorldBuilder.callMethodsWithFreeTypeVariables
.forEach(analyzeMethod);
}
// Add the classes that need RTI because they use a type variable as
@@ -358,10 +359,10 @@
}
void computeRequiredChecks() {
- Set<ResolutionDartType> isChecks = compiler.codegenWorld.isChecks;
+ Set<ResolutionDartType> isChecks = compiler.codegenWorldBuilder.isChecks;
// These types are needed for is-checks against function types.
Set<ResolutionDartType> instantiatedTypesAndClosures =
- computeInstantiatedTypesAndClosures(compiler.codegenWorld);
+ computeInstantiatedTypesAndClosures(compiler.codegenWorldBuilder);
computeInstantiatedArguments(instantiatedTypesAndClosures, isChecks);
computeCheckedArguments(instantiatedTypesAndClosures, isChecks);
cachedRequiredChecks =
@@ -369,10 +370,11 @@
}
Set<ResolutionDartType> computeInstantiatedTypesAndClosures(
- CodegenWorldBuilder universe) {
+ CodegenWorldBuilder worldBuilder) {
Set<ResolutionDartType> instantiatedTypes =
- new Set<ResolutionDartType>.from(universe.instantiatedTypes);
- for (ResolutionDartType instantiatedType in universe.instantiatedTypes) {
+ new Set<ResolutionDartType>.from(worldBuilder.instantiatedTypes);
+ for (ResolutionDartType instantiatedType
+ in worldBuilder.instantiatedTypes) {
if (instantiatedType.isInterfaceType) {
ResolutionInterfaceType interface = instantiatedType;
ResolutionFunctionType callType = interface.callType;
@@ -381,14 +383,15 @@
}
}
}
- for (FunctionElement element in universe.staticFunctionsNeedingGetter) {
+ for (FunctionElement element in worldBuilder.staticFunctionsNeedingGetter) {
instantiatedTypes.add(element.type);
}
// TODO(johnniwinther): We should get this information through the
// [neededClasses] computed in the emitter instead of storing it and pulling
// it from resolution, but currently it would introduce a cyclic dependency
// between [computeRequiredChecks] and [computeNeededClasses].
- for (TypedElement element in compiler.resolverWorld.closurizedMembers) {
+ for (TypedElement element
+ in compiler.resolutionWorldBuilder.closurizedMembers) {
instantiatedTypes.add(element.type);
}
return instantiatedTypes;
diff --git a/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart b/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
index d4e36a0..ae0ca07 100644
--- a/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/class_stub_generator.dart
@@ -7,12 +7,12 @@
class ClassStubGenerator {
final Namer namer;
final JavaScriptBackend backend;
- final CodegenWorldBuilder codegenWorld;
+ final CodegenWorldBuilder worldBuilder;
final ClosedWorld closedWorld;
final bool enableMinification;
ClassStubGenerator(
- this.namer, this.backend, this.codegenWorld, this.closedWorld,
+ this.namer, this.backend, this.worldBuilder, this.closedWorld,
{this.enableMinification});
jsAst.Expression generateClassConstructor(ClassElement classElement,
@@ -130,7 +130,7 @@
Map<jsAst.Name, Selector> jsNames = <jsAst.Name, Selector>{};
// Do not generate no such method handlers if there is no class.
- if (codegenWorld.directlyInstantiatedClasses.isEmpty) {
+ if (worldBuilder.directlyInstantiatedClasses.isEmpty) {
return jsNames;
}
@@ -145,9 +145,9 @@
}
}
- codegenWorld.forEachInvokedName(addNoSuchMethodHandlers);
- codegenWorld.forEachInvokedGetter(addNoSuchMethodHandlers);
- codegenWorld.forEachInvokedSetter(addNoSuchMethodHandlers);
+ worldBuilder.forEachInvokedName(addNoSuchMethodHandlers);
+ worldBuilder.forEachInvokedGetter(addNoSuchMethodHandlers);
+ worldBuilder.forEachInvokedSetter(addNoSuchMethodHandlers);
return jsNames;
}
diff --git a/pkg/compiler/lib/src/js_emitter/constant_ordering.dart b/pkg/compiler/lib/src/js_emitter/constant_ordering.dart
index 1991726..49b77e7 100644
--- a/pkg/compiler/lib/src/js_emitter/constant_ordering.dart
+++ b/pkg/compiler/lib/src/js_emitter/constant_ordering.dart
@@ -105,7 +105,9 @@
int visitList(ListConstantValue a, ListConstantValue b) {
int r = compareLists(compareValues, a.entries, b.entries);
if (r != 0) return r;
- return compareDartTypes(a.type, b.type);
+ ResolutionInterfaceType type1 = a.type;
+ ResolutionInterfaceType type2 = b.type;
+ return compareDartTypes(type1, type2);
}
int visitMap(MapConstantValue a, MapConstantValue b) {
@@ -113,11 +115,15 @@
if (r != 0) return r;
r = compareLists(compareValues, a.values, b.values);
if (r != 0) return r;
- return compareDartTypes(a.type, b.type);
+ ResolutionInterfaceType type1 = a.type;
+ ResolutionInterfaceType type2 = b.type;
+ return compareDartTypes(type1, type2);
}
int visitConstructed(ConstructedConstantValue a, ConstructedConstantValue b) {
- int r = compareDartTypes(a.type, b.type);
+ ResolutionInterfaceType type1 = a.type;
+ ResolutionInterfaceType type2 = b.type;
+ int r = compareDartTypes(type1, type2);
if (r != 0) return r;
List<FieldEntity> aFields = a.fields.keys.toList()..sort(compareElements);
@@ -135,11 +141,13 @@
int visitType(TypeConstantValue a, TypeConstantValue b) {
int r = compareDartTypes(a.representedType, b.representedType);
if (r != 0) return r;
- return compareDartTypes(a.type, b.type);
+ ResolutionInterfaceType type1 = a.type;
+ ResolutionInterfaceType type2 = b.type;
+ return compareDartTypes(type1, type2);
}
int visitInterceptor(InterceptorConstantValue a, InterceptorConstantValue b) {
- return compareDartTypes(a.dispatchedType, b.dispatchedType);
+ return compareElements(a.cls, b.cls);
}
int visitSynthetic(SyntheticConstantValue a, SyntheticConstantValue b) {
diff --git a/pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart b/pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart
index fa91726..979e11d 100644
--- a/pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart
+++ b/pkg/compiler/lib/src/js_emitter/full_emitter/class_emitter.dart
@@ -10,7 +10,7 @@
ClassEmitter(this.closedWorld);
ClassStubGenerator get _stubGenerator =>
- new ClassStubGenerator(namer, backend, codegenWorld, closedWorld,
+ new ClassStubGenerator(namer, backend, codegenWorldBuilder, closedWorld,
enableMinification: compiler.options.enableMinification);
/**
diff --git a/pkg/compiler/lib/src/js_emitter/full_emitter/code_emitter_helper.dart b/pkg/compiler/lib/src/js_emitter/full_emitter/code_emitter_helper.dart
index c1acde7..185f093 100644
--- a/pkg/compiler/lib/src/js_emitter/full_emitter/code_emitter_helper.dart
+++ b/pkg/compiler/lib/src/js_emitter/full_emitter/code_emitter_helper.dart
@@ -19,7 +19,7 @@
DiagnosticReporter get reporter => compiler.reporter;
- CodegenWorldBuilder get codegenWorld => compiler.codegenWorld;
+ CodegenWorldBuilder get codegenWorldBuilder => compiler.codegenWorldBuilder;
String get n => emitter.n;
diff --git a/pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart b/pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart
index 6b3a226..84b8e31 100644
--- a/pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart
+++ b/pkg/compiler/lib/src/js_emitter/full_emitter/emitter.dart
@@ -1889,7 +1889,8 @@
// specific to the class. For now, not supported for native classes and
// native elements.
ClassElement cls = element.enclosingClassOrCompilationUnit.declaration;
- if (compiler.codegenWorld.directlyInstantiatedClasses.contains(cls) &&
+ if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
+ .contains(cls) &&
!backend.isNative(cls) &&
compiler.deferredLoadTask.outputUnitForElement(element) ==
compiler.deferredLoadTask.outputUnitForElement(cls)) {
diff --git a/pkg/compiler/lib/src/js_emitter/full_emitter/nsm_emitter.dart b/pkg/compiler/lib/src/js_emitter/full_emitter/nsm_emitter.dart
index 9f8cc28..3bc27de 100644
--- a/pkg/compiler/lib/src/js_emitter/full_emitter/nsm_emitter.dart
+++ b/pkg/compiler/lib/src/js_emitter/full_emitter/nsm_emitter.dart
@@ -23,7 +23,7 @@
void emitNoSuchMethodHandlers(AddPropertyFunction addProperty) {
ClassStubGenerator generator = new ClassStubGenerator(
- namer, backend, codegenWorld, closedWorld,
+ namer, backend, codegenWorldBuilder, closedWorld,
enableMinification: compiler.options.enableMinification);
// Keep track of the JavaScript names we've already added so we
diff --git a/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart b/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
index a6255d3..d235adb 100644
--- a/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart
@@ -169,7 +169,7 @@
]));
} else {
ClassElement jsUnknown = helpers.jsUnknownJavaScriptObjectClass;
- if (compiler.codegenWorld.directlyInstantiatedClasses
+ if (compiler.codegenWorldBuilder.directlyInstantiatedClasses
.contains(jsUnknown)) {
statements.add(js.statement('if (!(receiver instanceof #)) return #;', [
backend.emitter
@@ -361,9 +361,10 @@
List<ConstantValue> constants =
handler.getConstantsForEmission(emitter.compareConstants);
for (ConstantValue constant in constants) {
- if (constant is TypeConstantValue) {
- TypeConstantValue typeConstant = constant;
- Element element = typeConstant.representedType.element;
+ if (constant is TypeConstantValue &&
+ constant.representedType is ResolutionInterfaceType) {
+ ResolutionInterfaceType type = constant.representedType;
+ Element element = type.element;
if (element is ClassElement) {
ClassElement classElement = element;
if (!analysis.needsClass(classElement)) continue;
diff --git a/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart b/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
index ad7f2ed..81467cc 100644
--- a/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/parameter_stub_generator.dart
@@ -20,7 +20,7 @@
DiagnosticReporter get reporter => compiler.reporter;
bool needsSuperGetter(FunctionElement element) =>
- compiler.codegenWorld.methodsNeedingSuperGetter.contains(element);
+ compiler.codegenWorldBuilder.methodsNeedingSuperGetter.contains(element);
/**
* Generates stubs to handle invocation of methods with optional
@@ -214,12 +214,12 @@
// Only instance members (not static methods) need stubs.
if (member.isInstanceMember) {
- selectors = compiler.codegenWorld.invocationsByName(member.name);
+ selectors = compiler.codegenWorldBuilder.invocationsByName(member.name);
}
if (canTearOff) {
String call = namer.closureInvocationSelectorName;
- callSelectors = compiler.codegenWorld.invocationsByName(call);
+ callSelectors = compiler.codegenWorldBuilder.invocationsByName(call);
}
assert(emptySelectorSet.isEmpty);
diff --git a/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart b/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
index 8c66d00..01b3a99 100644
--- a/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
+++ b/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
@@ -57,7 +57,7 @@
for (ConstantValue constant in constants) {
if (constant is InterceptorConstantValue) {
InterceptorConstantValue interceptorConstant = constant;
- classes.add(interceptorConstant.dispatchedType.element);
+ classes.add(interceptorConstant.cls);
}
}
return classes;
@@ -178,7 +178,10 @@
// Compute needed classes.
Set<ClassElement> instantiatedClasses = compiler
- .codegenWorld.directlyInstantiatedClasses
+ // TODO(johnniwinther): This should be accessed from a codegen closed
+ // world.
+ .codegenWorldBuilder
+ .directlyInstantiatedClasses
.where(computeClassFilter())
.toSet();
@@ -286,7 +289,11 @@
list.add(element);
}
- Iterable<Element> fields = compiler.codegenWorld.allReferencedStaticFields
+ Iterable<Element> fields = compiler
+ // TODO(johnniwinther): This should be accessed from a codegen closed
+ // world.
+ .codegenWorldBuilder
+ .allReferencedStaticFields
.where((FieldElement field) {
if (!field.isConst) {
return field.isField &&
diff --git a/pkg/compiler/lib/src/js_emitter/program_builder/field_visitor.dart b/pkg/compiler/lib/src/js_emitter/program_builder/field_visitor.dart
index 5b07be3..2e19299 100644
--- a/pkg/compiler/lib/src/js_emitter/program_builder/field_visitor.dart
+++ b/pkg/compiler/lib/src/js_emitter/program_builder/field_visitor.dart
@@ -72,8 +72,9 @@
// If the class is never instantiated we still need to set it up for
// inheritance purposes, but we can simplify its JavaScript constructor.
- bool isInstantiated =
- compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
+ bool isInstantiated = compiler
+ .codegenWorldBuilder.directlyInstantiatedClasses
+ .contains(element);
void visitField(Element holder, FieldElement field) {
assert(invariant(element, field.isDeclaration));
@@ -141,7 +142,7 @@
if (fieldAccessNeverThrows(field)) return false;
if (backend.shouldRetainGetter(field)) return true;
return field.isClassMember &&
- compiler.codegenWorld.hasInvokedGetter(field, closedWorld);
+ compiler.codegenWorldBuilder.hasInvokedGetter(field, closedWorld);
}
bool fieldNeedsSetter(VariableElement field) {
@@ -150,7 +151,7 @@
if (field.isFinal || field.isConst) return false;
if (backend.shouldRetainSetter(field)) return true;
return field.isClassMember &&
- compiler.codegenWorld.hasInvokedSetter(field, closedWorld);
+ compiler.codegenWorldBuilder.hasInvokedSetter(field, closedWorld);
}
static bool fieldAccessNeverThrows(VariableElement field) {
diff --git a/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart b/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
index 0448ef6..287c465 100644
--- a/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
+++ b/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
@@ -84,7 +84,7 @@
JavaScriptBackend get backend => _compiler.backend;
BackendHelpers get helpers => backend.helpers;
- CodegenWorldBuilder get universe => _compiler.codegenWorld;
+ CodegenWorldBuilder get worldBuilder => _compiler.codegenWorldBuilder;
/// Mapping from [ClassElement] to constructed [Class]. We need this to
/// update the superclass in the [Class].
@@ -354,8 +354,7 @@
backend.nativeData.getUnescapedJSInteropName(member.name);
if (!member.isInstanceMember) return;
if (member.isGetter || member.isField || member.isFunction) {
- var selectors =
- _compiler.codegenWorld.getterInvocationsByName(member.name);
+ var selectors = worldBuilder.getterInvocationsByName(member.name);
if (selectors != null && !selectors.isEmpty) {
for (var selector in selectors.keys) {
var stubName = namer.invocationName(selector);
@@ -369,8 +368,7 @@
}
if (member.isSetter || (member.isField && !member.isConst)) {
- var selectors =
- _compiler.codegenWorld.setterInvocationsByName(member.name);
+ var selectors = worldBuilder.setterInvocationsByName(member.name);
if (selectors != null && !selectors.isEmpty) {
var stubName = namer.setterForElement(member);
if (stubNames.add(stubName.key)) {
@@ -423,8 +421,7 @@
minArgs = 0;
maxArgs = 32767;
}
- var selectors =
- _compiler.codegenWorld.invocationsByName(member.name);
+ var selectors = worldBuilder.invocationsByName(member.name);
// Named arguments are not yet supported. In the future we
// may want to map named arguments to an object literal containing
// all named arguments.
@@ -522,7 +519,7 @@
List<StubMethod> callStubs = <StubMethod>[];
ClassStubGenerator classStubGenerator = new ClassStubGenerator(
- namer, backend, universe, closedWorld,
+ namer, backend, worldBuilder, closedWorld,
enableMinification: _compiler.options.enableMinification);
RuntimeTypeGenerator runtimeTypeGenerator =
new RuntimeTypeGenerator(_compiler, _task, namer);
@@ -538,7 +535,7 @@
}
if (member.isGetter || member.isField) {
Map<Selector, SelectorConstraints> selectors =
- _compiler.codegenWorld.invocationsByName(member.name);
+ worldBuilder.invocationsByName(member.name);
if (selectors != null && !selectors.isEmpty) {
Map<js.Name, js.Expression> callStubsForMember =
classStubGenerator.generateCallStubsForGetter(member, selectors);
@@ -624,7 +621,7 @@
// building a class.
Holder holder = _registry.registerHolder(holderName);
bool isInstantiated = !backend.isJsInterop(element) &&
- _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
+ worldBuilder.directlyInstantiatedClasses.contains(element);
Class result;
if (element.isMixinApplication && !onlyForRti) {
@@ -741,10 +738,10 @@
isClosureCallMethod = true;
} else {
// Careful with operators.
- canTearOff = universe.hasInvokedGetter(element, closedWorld) ||
+ canTearOff = worldBuilder.hasInvokedGetter(element, closedWorld) ||
(canBeReflected && !element.isOperator);
assert(canTearOff ||
- !universe.methodsNeedingSuperGetter.contains(element));
+ !worldBuilder.methodsNeedingSuperGetter.contains(element));
tearOffName = namer.getterForElement(element);
}
}
@@ -935,7 +932,7 @@
bool needsTearOff = isApplyTarget &&
(canBeReflected ||
- universe.staticFunctionsNeedingGetter.contains(element));
+ worldBuilder.staticFunctionsNeedingGetter.contains(element));
js.Name tearOffName =
needsTearOff ? namer.staticClosureName(element) : null;
diff --git a/pkg/compiler/lib/src/js_emitter/type_test_registry.dart b/pkg/compiler/lib/src/js_emitter/type_test_registry.dart
index 9efbbeb..ffd3b55 100644
--- a/pkg/compiler/lib/src/js_emitter/type_test_registry.dart
+++ b/pkg/compiler/lib/src/js_emitter/type_test_registry.dart
@@ -28,7 +28,8 @@
Iterable<ClassElement> get classesUsingTypeVariableTests {
if (cachedClassesUsingTypeVariableTests == null) {
- cachedClassesUsingTypeVariableTests = compiler.codegenWorld.isChecks
+ cachedClassesUsingTypeVariableTests = compiler
+ .codegenWorldBuilder.isChecks
.where((ResolutionDartType t) => t is ResolutionTypeVariableType)
.map((ResolutionTypeVariableType v) => v.element.enclosingClass)
.toList();
@@ -106,7 +107,8 @@
return false;
} else if (function.isInstanceMember) {
if (!function.enclosingClass.isClosure) {
- return compiler.codegenWorld.hasInvokedGetter(function, closedWorld);
+ return compiler.codegenWorldBuilder
+ .hasInvokedGetter(function, closedWorld);
}
}
return false;
@@ -144,11 +146,11 @@
assert(checkedClasses == null && checkedFunctionTypes == null);
backend.rti.addImplicitChecks(
- compiler.codegenWorld, classesUsingTypeVariableTests);
+ compiler.codegenWorldBuilder, classesUsingTypeVariableTests);
checkedClasses = new Set<ClassElement>();
checkedFunctionTypes = new Set<ResolutionFunctionType>();
- compiler.codegenWorld.isChecks.forEach((ResolutionDartType t) {
+ compiler.codegenWorldBuilder.isChecks.forEach((ResolutionDartType t) {
if (t is ResolutionInterfaceType) {
checkedClasses.add(t.element);
} else if (t is ResolutionFunctionType) {
diff --git a/pkg/compiler/lib/src/kernel/kernel_visitor.dart b/pkg/compiler/lib/src/kernel/kernel_visitor.dart
index c4ec66d..6a663b0 100644
--- a/pkg/compiler/lib/src/kernel/kernel_visitor.dart
+++ b/pkg/compiler/lib/src/kernel/kernel_visitor.dart
@@ -104,6 +104,7 @@
ForIn,
FunctionDeclaration,
FunctionExpression,
+ FunctionTypeAnnotation,
Identifier,
If,
Label,
@@ -122,6 +123,7 @@
NewExpression,
Node,
NodeList,
+ NominalTypeAnnotation,
Operator,
ParenthesizedExpression,
RedirectingFactoryBody,
@@ -297,8 +299,7 @@
// TODO(ahe): Hack. Fix dart2js instead.
ir.Name nameToIrName(Name name) {
- assert(!name.isPrivate ||
- name.library.implementation == currentElement.library.implementation);
+ assert(!name.isPrivate || name.library == currentElement.library);
return kernel.irName(name.text, currentElement);
}
@@ -1088,14 +1089,28 @@
@override
visitTypeAnnotation(TypeAnnotation node) {
- // Shouldn't be called, as the resolver have already resolved types and
+ // Shouldn't be called, as the resolver has already resolved types and
// created [DartType] objects.
return internalError(node, "TypeAnnotation");
}
@override
+ visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+ // Shouldn't be called, as the resolver has already resolved types and
+ // created [DartType] objects.
+ return internalError(node, "NominalTypeAnnotation");
+ }
+
+ @override
+ visitFunctionTypeAnnotation(FunctionTypeAnnotation node) {
+ // Shouldn't be called, as the resolver has already resolved types and
+ // created [DartType] objects.
+ return internalError(node, "FunctionTypeAnnotation");
+ }
+
+ @override
visitTypeVariable(TypeVariable node) {
- // Shouldn't be called, as the resolver have already resolved types and
+ // Shouldn't be called, as the resolver has already resolved types and
// created [DartType] objects.
return internalError(node, "TypeVariable");
}
diff --git a/pkg/compiler/lib/src/mirrors_used.dart b/pkg/compiler/lib/src/mirrors_used.dart
index 34a81a5..08c8750 100644
--- a/pkg/compiler/lib/src/mirrors_used.dart
+++ b/pkg/compiler/lib/src/mirrors_used.dart
@@ -252,7 +252,8 @@
metadata.ensureResolved(compiler.resolution);
ConstantValue value =
compiler.constants.getConstantValue(metadata.constant);
- Element element = value.getType(compiler.commonElements).element;
+ ResolutionDartType type = value.getType(compiler.commonElements);
+ Element element = type.element;
if (element == compiler.commonElements.mirrorsUsedClass) {
result.add(buildUsage(value));
}
diff --git a/pkg/compiler/lib/src/native/behavior.dart b/pkg/compiler/lib/src/native/behavior.dart
index e236975..1f9faa8 100644
--- a/pkg/compiler/lib/src/native/behavior.dart
+++ b/pkg/compiler/lib/src/native/behavior.dart
@@ -257,7 +257,7 @@
/// Each tag kind (including the 'type-tag's) can only occur once in the
/// sequence.
///
- /// [specString] is the specification string, [resolveType] resolves named
+ /// [specString] is the specification string, [lookupType] resolves named
/// types into type values, [typesReturned] and [typesInstantiated] collects
/// the types defined by the specification string, and [objectType] and
/// [nullType] define the types for `Object` and `Null`, respectively. The
diff --git a/pkg/compiler/lib/src/parser/element_listener.dart b/pkg/compiler/lib/src/parser/element_listener.dart
index 5c058ee..1c031aa 100644
--- a/pkg/compiler/lib/src/parser/element_listener.dart
+++ b/pkg/compiler/lib/src/parser/element_listener.dart
@@ -260,10 +260,17 @@
}
}
- void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
- popNode(); // TODO(karlklose): do not throw away typeVariables.
- Identifier name = popNode();
- popNode(); // returnType
+ void endTypedef(Token typedefKeyword, Token equals, Token endToken) {
+ Identifier name;
+ if (equals == null) {
+ popNode(); // TODO(karlklose): do not throw away typeVariables.
+ name = popNode();
+ popNode(); // returnType
+ } else {
+ popNode(); // Function type.
+ popNode(); // TODO(karlklose): do not throw away typeVariables.
+ name = popNode();
+ }
pushElement(new PartialTypedefElement(
name.source, compilationUnitElement, typedefKeyword, endToken));
rejectBuiltInIdentifier(name);
@@ -294,12 +301,12 @@
void endMixinApplication() {
NodeList mixins = popNode();
- TypeAnnotation superclass = popNode();
+ NominalTypeAnnotation superclass = popNode();
pushNode(new MixinApplication(superclass, mixins));
}
void handleVoidKeyword(Token token) {
- pushNode(new TypeAnnotation(new Identifier(token), null));
+ pushNode(new NominalTypeAnnotation(new Identifier(token), null));
}
void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
@@ -366,7 +373,7 @@
}
void endTypeVariable(Token token, Token extendsOrSuper) {
- TypeAnnotation bound = popNode();
+ NominalTypeAnnotation bound = popNode();
Identifier name = popNode();
pushNode(new TypeVariable(name, extendsOrSuper, bound));
rejectBuiltInIdentifier(name);
@@ -391,7 +398,17 @@
void endType(Token beginToken, Token endToken) {
NodeList typeArguments = popNode();
Expression typeName = popNode();
- pushNode(new TypeAnnotation(typeName, typeArguments));
+ pushNode(new NominalTypeAnnotation(typeName, typeArguments));
+ }
+
+ void handleNoName(Token token) {
+ pushNode(null);
+ }
+
+ void endFunctionType(Token functionToken, Token endToken) {
+ popNode(); // Type parameters.
+ popNode(); // Return type.
+ pushNode(null);
}
void handleParenthesizedExpression(BeginGroupToken token) {
diff --git a/pkg/compiler/lib/src/parser/listener.dart b/pkg/compiler/lib/src/parser/listener.dart
index b33bd84..d3eab2f 100644
--- a/pkg/compiler/lib/src/parser/listener.dart
+++ b/pkg/compiler/lib/src/parser/listener.dart
@@ -130,9 +130,9 @@
void endFunctionName(Token token) {}
- void beginFunctionTypeAlias(Token token) {}
+ void beginTypedef(Token token) {}
- void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {}
+ void endTypedef(Token typedefKeyword, Token equals, Token endToken) {}
void beginMixinApplication(Token token) {}
@@ -295,6 +295,10 @@
void endType(Token beginToken, Token endToken) {}
+ void handleNoName(Token token) {}
+
+ void endFunctionType(Token functionToken, Token endToken) {}
+
void beginTypeArguments(Token token) {}
void endTypeArguments(int count, Token beginToken, Token endToken) {}
diff --git a/pkg/compiler/lib/src/parser/node_listener.dart b/pkg/compiler/lib/src/parser/node_listener.dart
index 4dc325c..e11a5f1 100644
--- a/pkg/compiler/lib/src/parser/node_listener.dart
+++ b/pkg/compiler/lib/src/parser/node_listener.dart
@@ -12,7 +12,6 @@
import '../tree/tree.dart';
import '../util/util.dart' show Link;
import 'element_listener.dart' show ElementListener, ScannerOptions;
-import 'partial_elements.dart' show PartialFunctionElement;
class NodeListener extends ElementListener {
NodeListener(ScannerOptions scannerOptions, DiagnosticReporter reporter,
@@ -115,13 +114,58 @@
pushNode(makeNodeList(count, null, null, '\n'));
}
- void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
+ void endTypedef(Token typedefKeyword, Token equals, Token endToken) {
+ bool isGeneralizedTypeAlias;
+ NodeList templateParameters;
+ TypeAnnotation returnType;
+ Identifier name;
+ NodeList typeParameters;
+ NodeList formals;
+ if (equals == null) {
+ isGeneralizedTypeAlias = false;
+ formals = popNode();
+ templateParameters = popNode();
+ name = popNode();
+ returnType = popNode();
+ } else {
+ // TODO(floitsch): keep using the `FunctionTypeAnnotation' node.
+ isGeneralizedTypeAlias = true;
+ Node type = popNode();
+ if (type.asFunctionTypeAnnotation() == null) {
+ // TODO(floitsch): The parser should diagnose this problem, not
+ // this listener.
+ // However, this problem goes away, when we allow aliases for
+ // non-function types too.
+ reportFatalError(type, 'Expected a function type.');
+ }
+ FunctionTypeAnnotation functionType = type;
+ templateParameters = popNode();
+ name = popNode();
+ returnType = functionType.returnType;
+ typeParameters = functionType.typeParameters;
+ formals = functionType.formals;
+ }
+ pushNode(new Typedef(
+ isGeneralizedTypeAlias,
+ templateParameters,
+ returnType,
+ name,
+ typeParameters,
+ formals,
+ typedefKeyword,
+ endToken));
+ }
+
+ void handleNoName(Token token) {
+ pushNode(null);
+ }
+
+ void endFunctionType(Token functionToken, Token endToken) {
NodeList formals = popNode();
NodeList typeParameters = popNode();
- Identifier name = popNode();
TypeAnnotation returnType = popNode();
- pushNode(new Typedef(
- returnType, name, typeParameters, formals, typedefKeyword, endToken));
+ pushNode(new FunctionTypeAnnotation(
+ returnType, functionToken, typeParameters, formals));
}
void endNamedMixinApplication(
@@ -206,7 +250,7 @@
NodeList typeArguments = popNode();
Node classReference = popNode();
if (typeArguments != null) {
- classReference = new TypeAnnotation(classReference, typeArguments);
+ classReference = new NominalTypeAnnotation(classReference, typeArguments);
} else {
Identifier identifier = classReference.asIdentifier();
Send send = classReference.asSend();
@@ -791,7 +835,7 @@
NodeList typeArguments = popNode();
Node receiver = popNode();
if (typeArguments != null) {
- receiver = new TypeAnnotation(receiver, typeArguments);
+ receiver = new NominalTypeAnnotation(receiver, typeArguments);
recoverableError(typeArguments, 'Type arguments are not allowed here.');
} else {
Identifier identifier = receiver.asIdentifier();
diff --git a/pkg/compiler/lib/src/parser/parser.dart b/pkg/compiler/lib/src/parser/parser.dart
index 0ef9cb8..fa4ac4b 100644
--- a/pkg/compiler/lib/src/parser/parser.dart
+++ b/pkg/compiler/lib/src/parser/parser.dart
@@ -362,12 +362,21 @@
Token parseTypedef(Token token) {
Token typedefKeyword = token;
- listener.beginFunctionTypeAlias(token);
- token = parseReturnTypeOpt(token.next);
- token = parseIdentifier(token);
- token = parseTypeVariablesOpt(token);
- token = parseFormalParameters(token);
- listener.endFunctionTypeAlias(typedefKeyword, token);
+ listener.beginTypedef(token);
+ Token equals;
+ if (optional('=', peekAfterNominalType(token.next))) {
+ token = parseIdentifier(token.next);
+ token = parseTypeVariablesOpt(token);
+ equals = token;
+ token = expect('=', token);
+ token = parseType(token);
+ } else {
+ token = parseReturnTypeOpt(token.next);
+ token = parseIdentifier(token);
+ token = parseTypeVariablesOpt(token);
+ token = parseFormalParameters(token);
+ }
+ listener.endTypedef(typedefKeyword, equals, token);
return expect(';', token);
}
@@ -398,7 +407,11 @@
}
}
- Token parseFormalParameters(Token token) {
+ /// Parses the formal parameter list of a function.
+ ///
+ /// If [inFunctionType] is true, then the names may be omitted (except for
+ /// named arguments). If it is false, then the types may be omitted.
+ Token parseFormalParameters(Token token, {bool inFunctionType: false}) {
Token begin = token;
listener.beginFormalParameters(begin);
expect('(', token);
@@ -411,19 +424,23 @@
++parameterCount;
String value = token.stringValue;
if (identical(value, '[')) {
- token = parseOptionalFormalParameters(token, false);
+ token = parseOptionalFormalParameters(
+ token, false, inFunctionType: inFunctionType);
break;
} else if (identical(value, '{')) {
- token = parseOptionalFormalParameters(token, true);
+ token = parseOptionalFormalParameters(
+ token, true, inFunctionType: inFunctionType);
break;
}
- token = parseFormalParameter(token, FormalParameterType.REQUIRED);
+ token = parseFormalParameter(token, FormalParameterType.REQUIRED,
+ inFunctionType: inFunctionType);
} while (optional(',', token));
listener.endFormalParameters(parameterCount, begin, token);
return expect(')', token);
}
- Token parseFormalParameter(Token token, FormalParameterType type) {
+ Token parseFormalParameter(Token token, FormalParameterType type,
+ {bool inFunctionType}) {
token = parseMetadataStar(token, forParameter: true);
listener.beginFormalParameter(token);
@@ -436,24 +453,41 @@
token = token.next;
}
token = parseModifiers(token);
- // TODO(ahe): Validate that there are formal parameters if void.
- token = parseReturnTypeOpt(token);
+ bool isNamedParameter = type == FormalParameterType.NAMED;
+
Token thisKeyword = null;
- if (optional('this', token)) {
- thisKeyword = token;
- // TODO(ahe): Validate field initializers are only used in
- // constructors, and not for function-typed arguments.
- token = expect('.', token.next);
+ if (inFunctionType && isNamedParameter) {
+ token = parseType(token);
+ token = parseIdentifier(token);
+ } else if (inFunctionType) {
+ token = parseType(token);
+ if (token.isIdentifier()) {
+ token = parseIdentifier(token);
+ } else {
+ listener.handleNoName(token);
+ }
+ } else {
+ token = parseReturnTypeOpt(token);
+ if (optional('this', token)) {
+ thisKeyword = token;
+ token = expect('.', token.next);
+ }
+ token = parseIdentifier(token);
}
- token = parseIdentifier(token);
- if (optional('(', token)) {
- listener.handleNoTypeVariables(token);
- token = parseFormalParameters(token);
- listener.handleFunctionTypedFormalParameter(token);
- } else if (optional('<', token)) {
- token = parseTypeVariablesOpt(token);
- token = parseFormalParameters(token);
- listener.handleFunctionTypedFormalParameter(token);
+
+ // Generalized function types don't allow inline function types.
+ // The following isn't allowed:
+ // int Function(int bar(String x)).
+ if (!inFunctionType) {
+ if (optional('(', token)) {
+ listener.handleNoTypeVariables(token);
+ token = parseFormalParameters(token);
+ listener.handleFunctionTypedFormalParameter(token);
+ } else if (optional('<', token)) {
+ token = parseTypeVariablesOpt(token);
+ token = parseFormalParameters(token);
+ listener.handleFunctionTypedFormalParameter(token);
+ }
}
String value = token.stringValue;
if ((identical('=', value)) || (identical(':', value))) {
@@ -473,7 +507,8 @@
return token;
}
- Token parseOptionalFormalParameters(Token token, bool isNamed) {
+ Token parseOptionalFormalParameters(Token token, bool isNamed,
+ {bool inFunctionType}) {
Token begin = token;
listener.beginOptionalFormalParameters(begin);
assert((isNamed && optional('{', token)) || optional('[', token));
@@ -487,7 +522,8 @@
}
var type =
isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
- token = parseFormalParameter(token, type);
+ token =
+ parseFormalParameter(token, type, inFunctionType: inFunctionType);
++parameterCount;
} while (optional(',', token));
if (parameterCount == 0) {
@@ -506,6 +542,10 @@
}
Token parseTypeOpt(Token token) {
+ if (isGeneralizedFunctionType(token)) {
+ // Function type without return type.
+ return parseType(token);
+ }
Token peek = peekAfterIfType(token);
if (peek != null && (peek.isIdentifier() || optional('this', peek))) {
return parseType(token);
@@ -670,7 +710,7 @@
token = token.next;
}
Token classKeyword = token;
- var isMixinApplication = optional('=', peekAfterType(token.next));
+ var isMixinApplication = optional('=', peekAfterNominalType(token.next));
if (isMixinApplication) {
listener.beginNamedMixinApplication(begin);
} else {
@@ -711,7 +751,7 @@
Token extendsKeyword;
if (optional('extends', token)) {
extendsKeyword = token;
- if (optional('with', peekAfterType(token.next))) {
+ if (optional('with', peekAfterNominalType(token.next))) {
token = parseMixinApplication(token.next);
} else {
token = parseType(token.next);
@@ -809,16 +849,53 @@
!identical(value, token.stringValue);
}
+ bool isGeneralizedFunctionType(Token token) {
+ // TODO(floitsch): don't use string comparison, but the keyword-state
+ // table is currently not set up to deal with upper-case characters.
+ return (optional('<', token.next) || optional('(', token.next)) &&
+ token.value == "Function";
+ }
+
Token parseType(Token token) {
Token begin = token;
- if (isValidTypeReference(token)) {
- token = parseIdentifier(token);
- token = parseQualifiedRestOpt(token);
+ if (isGeneralizedFunctionType(token)) {
+ // A function type without return type.
+ // Push the non-existing return type first. The loop below will
+ // generate the full type.
+ listener.handleNoType(token);
} else {
- token = listener.expectedType(token);
+ if (isValidTypeReference(token)) {
+ token = parseIdentifier(token);
+ token = parseQualifiedRestOpt(token);
+ } else {
+ token = listener.expectedType(token);
+ }
+ token = parseTypeArgumentsOpt(token);
+ listener.endType(begin, token);
}
- token = parseTypeArgumentsOpt(token);
- listener.endType(begin, token);
+
+ // While we see a `Function(` treat the pushed type as return type.
+ // For example: `int Function() Function(int) Function(String x)`.
+ while (isGeneralizedFunctionType(token)) {
+ token = parseFunctionType(token);
+ }
+ return token;
+ }
+
+ /// Parses a generalized function type.
+ ///
+ /// The return type must already be pushed.
+ Token parseFunctionType(Token token) {
+ // TODO(floitsch): don't use string comparison, but the keyword-state
+ // table is currently not set up to deal with upper-case characters.
+ if (token.value != "Function") {
+ return listener.expected("Function", token);
+ }
+ Token functionToken = token;
+ token = token.next;
+ token = parseTypeVariablesOpt(token);
+ token = parseFormalParameters(token, inFunctionType: true);
+ listener.endFunctionType(functionToken, token);
return token;
}
@@ -1175,26 +1252,55 @@
hasName = true;
}
identifiers = identifiers.prepend(token);
- if (isValidTypeReference(token)) {
- // type ...
- if (optional('.', token.next)) {
- // type '.' ...
- if (token.next.next.isIdentifier()) {
- // type '.' identifier
- token = token.next.next;
+
+ if (!isGeneralizedFunctionType(token)) {
+ // Read a potential return type.
+ if (isValidTypeReference(token)) {
+ // type ...
+ if (optional('.', token.next)) {
+ // type '.' ...
+ if (token.next.next.isIdentifier()) {
+ // type '.' identifier
+ token = token.next.next;
+ }
+ }
+ if (optional('<', token.next)) {
+ if (token.next is BeginGroupToken) {
+ BeginGroupToken beginGroup = token.next;
+ if (beginGroup.endGroup == null) {
+ listener.unmatched(beginGroup);
+ }
+ token = beginGroup.endGroup;
+ }
}
}
- if (optional('<', token.next)) {
- if (token.next is BeginGroupToken) {
- BeginGroupToken beginGroup = token.next;
+ token = token.next;
+ }
+ while (isGeneralizedFunctionType(token)) {
+ token = token.next;
+ if (optional('<', token)) {
+ if (token is BeginGroupToken) {
+ BeginGroupToken beginGroup = token;
if (beginGroup.endGroup == null) {
listener.unmatched(beginGroup);
}
- token = beginGroup.endGroup;
+ token = beginGroup.endGroup.next;
}
}
+ if (!optional('(', token)) {
+ if (optional(';', token)) {
+ listener.recoverableError(token, "expected '('");
+ }
+ token = listener.unexpected(token);
+ }
+ if (token is BeginGroupToken) {
+ BeginGroupToken beginGroup = token;
+ if (beginGroup.endGroup == null) {
+ listener.unmatched(beginGroup);
+ }
+ token = beginGroup.endGroup.next;
+ }
}
- token = token.next;
}
return const Link<Token>();
}
@@ -1292,11 +1398,31 @@
/**
* Returns the first token after the type starting at [token].
+ *
* This method assumes that [token] is an identifier (or void).
* Use [peekAfterIfType] if [token] isn't known to be an identifier.
*/
Token peekAfterType(Token token) {
// We are looking at "identifier ...".
+ Token peek = token;
+ if (!isGeneralizedFunctionType(token)) {
+ peek = peekAfterNominalType(token);
+ }
+
+ // We might have just skipped over the return value of the function type.
+ // Check again, if we are now at a function type position.
+ while (isGeneralizedFunctionType(peek)) {
+ peek = peekAfterFunctionType(peek);
+ }
+ return peek;
+ }
+
+ /**
+ * Returns the first token after the nominal type starting at [token].
+ *
+ * This method assumes that [token] is an identifier (or void).
+ */
+ Token peekAfterNominalType(Token token) {
Token peek = token.next;
if (identical(peek.kind, PERIOD_TOKEN)) {
if (peek.next.isIdentifier()) {
@@ -1312,13 +1438,57 @@
Token gtToken = beginGroupToken.endGroup;
if (gtToken != null) {
// We are looking at "qualified '<' ... '>' ...".
- return gtToken.next;
+ peek = gtToken.next;
}
}
return peek;
}
/**
+ * Returns the first token after the function type starting at [token].
+ *
+ * The token must be at the `Function` token position. That is, the return
+ * type must have already been skipped.
+ *
+ * This function only skips over one function type syntax.
+ * If necessary, this function must be called multiple times.
+ *
+ * Example:
+ * ```
+ * int Function() Function<T>(int)
+ * ^ ^
+ * A call to this function must be at one of the `Function` tokens.
+ * If `token` pointed to the first `Function` token, then the returned
+ * token points to the second `Function` token.
+ */
+ Token peekAfterFunctionType(Token token) {
+ // Possible inputs are:
+ // Function( ... )
+ // Function< ... >( ... )
+
+ Token peek = token.next; // Skip over the Function token.
+ // If there is a generic argument to the function, skip over that one first.
+ if (identical(peek.kind, LT_TOKEN)) {
+ BeginGroupToken beginGroupToken = peek;
+ Token closeToken = beginGroupToken.endGroup;
+ if (closeToken != null) {
+ peek = closeToken.next;
+ }
+ }
+
+ // Now we just need to skip over the formals.
+ expect('(', peek);
+
+ BeginGroupToken beginGroupToken = peek;
+ Token closeToken = beginGroupToken.endGroup;
+ if (closeToken != null) {
+ peek = closeToken.next;
+ }
+
+ return peek;
+ }
+
+ /**
* If [token] is the start of a type, returns the token after that type.
* If [token] is not the start of a type, null is returned.
*/
diff --git a/pkg/compiler/lib/src/parser/partial_parser.dart b/pkg/compiler/lib/src/parser/partial_parser.dart
index 6aaa52c..1c03790 100644
--- a/pkg/compiler/lib/src/parser/partial_parser.dart
+++ b/pkg/compiler/lib/src/parser/partial_parser.dart
@@ -156,7 +156,8 @@
return token;
}
- Token parseFormalParameters(Token token) => skipFormals(token);
+ Token parseFormalParameters(Token token, {bool inFunctionType: false})
+ => skipFormals(token);
Token skipFormals(Token token) {
listener.beginOptionalFormalParameters(token);
diff --git a/pkg/compiler/lib/src/patch_parser.dart b/pkg/compiler/lib/src/patch_parser.dart
index a356887..bf2ae05 100644
--- a/pkg/compiler/lib/src/patch_parser.dart
+++ b/pkg/compiler/lib/src/patch_parser.dart
@@ -462,8 +462,8 @@
void validate(Compiler compiler, Element element,
MetadataAnnotation annotation, ConstantValue constant) {
JavaScriptBackend backend = compiler.backend;
- if (constant.getType(compiler.commonElements).element !=
- backend.helpers.jsAnnotationClass) {
+ ResolutionDartType type = constant.getType(compiler.commonElements);
+ if (type.element != backend.helpers.jsAnnotationClass) {
compiler.reporter
.internalError(annotation, 'Invalid @JS(...) annotation.');
}
diff --git a/pkg/compiler/lib/src/resolution/class_hierarchy.dart b/pkg/compiler/lib/src/resolution/class_hierarchy.dart
index a63a093..f9e6480 100644
--- a/pkg/compiler/lib/src/resolution/class_hierarchy.dart
+++ b/pkg/compiler/lib/src/resolution/class_hierarchy.dart
@@ -66,8 +66,8 @@
TypeVariableElementX variableElement = typeVariable.element;
if (typeNode.bound != null) {
- ResolutionDartType boundType =
- typeResolver.resolveTypeAnnotation(this, typeNode.bound);
+ ResolutionDartType boundType = typeResolver
+ .resolveNominalTypeAnnotation(this, typeNode.bound, const []);
variableElement.boundCache = boundType;
void checkTypeVariableBound() {
@@ -251,8 +251,8 @@
/// Resolves the mixed type for [mixinNode] and checks that the mixin type
/// is a valid, non-blacklisted interface type. The mixin type is returned.
- ResolutionDartType checkMixinType(TypeAnnotation mixinNode) {
- ResolutionDartType mixinType = resolveType(mixinNode);
+ ResolutionDartType checkMixinType(NominalTypeAnnotation mixinNode) {
+ ResolutionDartType mixinType = resolveNominalType(mixinNode);
if (isBlackListed(mixinType)) {
reporter.reportErrorMessage(
mixinNode, MessageKind.CANNOT_MIXIN, {'type': mixinType});
@@ -441,13 +441,13 @@
return mixinType;
}
- ResolutionDartType resolveType(TypeAnnotation node) {
- return typeResolver.resolveTypeAnnotation(this, node);
+ ResolutionDartType resolveNominalType(NominalTypeAnnotation node) {
+ return typeResolver.resolveNominalTypeAnnotation(this, node, const []);
}
ResolutionDartType resolveSupertype(
- ClassElement cls, TypeAnnotation superclass) {
- ResolutionDartType supertype = resolveType(superclass);
+ ClassElement cls, NominalTypeAnnotation superclass) {
+ ResolutionDartType supertype = resolveNominalType(superclass);
if (supertype != null) {
if (supertype.isMalformed) {
reporter.reportErrorMessage(
@@ -477,7 +477,7 @@
Link<ResolutionDartType> result = const Link<ResolutionDartType>();
if (interfaces == null) return result;
for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
- ResolutionDartType interfaceType = resolveType(link.head);
+ ResolutionDartType interfaceType = resolveNominalType(link.head);
if (interfaceType != null) {
if (interfaceType.isMalformed) {
reporter.reportErrorMessage(
@@ -491,7 +491,7 @@
{'className': element.name, 'enumType': interfaceType});
} else if (!interfaceType.isInterfaceType) {
// TODO(johnniwinther): Handle dynamic.
- TypeAnnotation typeAnnotation = link.head;
+ NominalTypeAnnotation typeAnnotation = link.head;
reporter.reportErrorMessage(
typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
} else {
@@ -616,7 +616,7 @@
visitNodeList(node.interfaces);
}
- void visitTypeAnnotation(TypeAnnotation node) {
+ void visitNominalTypeAnnotation(NominalTypeAnnotation node) {
node.typeName.accept(this);
}
diff --git a/pkg/compiler/lib/src/resolution/constructors.dart b/pkg/compiler/lib/src/resolution/constructors.dart
index bd127d0..cc02a99 100644
--- a/pkg/compiler/lib/src/resolution/constructors.dart
+++ b/pkg/compiler/lib/src/resolution/constructors.dart
@@ -98,7 +98,10 @@
Element target;
FieldElement field;
if (isFieldInitializer(init)) {
- target = constructor.enclosingClass.lookupLocalMember(name);
+ // Use [enclosingElement] instead of [enclosingClass] to ensure lookup in
+ // patch class when necessary.
+ ClassElement cls = constructor.enclosingElement;
+ target = cls.lookupLocalMember(name);
if (target == null) {
reporter.reportErrorMessage(
selector, MessageKind.CANNOT_RESOLVE, {'name': name});
@@ -616,7 +619,7 @@
return result;
}
- ConstructorResult visitTypeAnnotation(TypeAnnotation node) {
+ ConstructorResult visitNominalTypeAnnotation(NominalTypeAnnotation node) {
// This is not really resolving a type-annotation, but the name of the
// constructor. Therefore we allow deferred types.
ResolutionDartType type = resolver.resolveTypeAnnotation(node,
diff --git a/pkg/compiler/lib/src/resolution/members.dart b/pkg/compiler/lib/src/resolution/members.dart
index 8fa327f..b02d8bf 100644
--- a/pkg/compiler/lib/src/resolution/members.dart
+++ b/pkg/compiler/lib/src/resolution/members.dart
@@ -4016,7 +4016,7 @@
for (ConstantValue key in map.keys) {
if (!key.isObject) continue;
ObjectConstantValue objectConstant = key;
- ResolutionDartType keyType = objectConstant.type;
+ ResolutionInterfaceType keyType = objectConstant.type;
ClassElement cls = keyType.element;
if (cls == commonElements.stringClass) continue;
Element equals = cls.lookupMember('==');
@@ -4489,7 +4489,8 @@
if (constant.isFunction) return commonElements.functionType;
assert(constant.isObject);
ObjectConstantValue objectConstant = constant;
- return objectConstant.type;
+ ResolutionInterfaceType type = objectConstant.type;
+ return type;
}
bool overridesEquals(ResolutionDartType type) {
diff --git a/pkg/compiler/lib/src/resolution/resolution.dart b/pkg/compiler/lib/src/resolution/resolution.dart
index 59694a2..3210976 100644
--- a/pkg/compiler/lib/src/resolution/resolution.dart
+++ b/pkg/compiler/lib/src/resolution/resolution.dart
@@ -76,7 +76,7 @@
ParsingContext get parsingContext => resolution.parsingContext;
CompilerOptions get options => resolution.options;
ResolutionEnqueuer get enqueuer => resolution.enqueuer;
- OpenWorld get world => enqueuer.universe;
+ OpenWorld get world => enqueuer.worldBuilder;
ResolutionImpact resolve(Element element) {
return measure(() {
diff --git a/pkg/compiler/lib/src/resolution/resolution_common.dart b/pkg/compiler/lib/src/resolution/resolution_common.dart
index 53d3c69..837906c 100644
--- a/pkg/compiler/lib/src/resolution/resolution_common.dart
+++ b/pkg/compiler/lib/src/resolution/resolution_common.dart
@@ -56,6 +56,10 @@
/// Add [element] to the current scope and check for duplicate definitions.
void addToScope(Element element) {
+ if (element is FormalElement && element.isUnnamed) {
+ // No duplicate names possible.
+ return;
+ }
Element existing = scope.add(element);
if (existing != element) {
reportDuplicateDefinition(element.name, element, existing);
diff --git a/pkg/compiler/lib/src/resolution/signatures.dart b/pkg/compiler/lib/src/resolution/signatures.dart
index ae39454..7fd39ee 100644
--- a/pkg/compiler/lib/src/resolution/signatures.dart
+++ b/pkg/compiler/lib/src/resolution/signatures.dart
@@ -94,7 +94,9 @@
reporter.internalError(node, 'function type parameters not supported');
}
currentDefinitions = node;
- FormalElementX element = definition.accept(this);
+ FormalElementX element = definition == null
+ ? createUnnamedParameter() // This happens in function types.
+ : definition.accept(this);
if (currentDefinitions.metadata != null) {
element.metadataInternal =
resolution.resolver.resolveMetadata(element, node);
@@ -113,7 +115,8 @@
void computeParameterType(FormalElementX element,
[VariableElement fieldElement]) {
- void computeFunctionType(FunctionExpression functionExpression) {
+ // Function-type as in `foo(int bar(String x))`
+ void computeInlineFunctionType(FunctionExpression functionExpression) {
FunctionSignature functionSignature = SignatureResolver.analyze(
resolution,
scope,
@@ -135,13 +138,14 @@
assert(invariant(currentDefinitions, link.tail.isEmpty));
if (link.head.asFunctionExpression() != null) {
// Inline function typed parameter, like `void m(int f(String s))`.
- computeFunctionType(link.head);
+ computeInlineFunctionType(link.head);
} else if (link.head.asSend() != null &&
link.head.asSend().selector.asFunctionExpression() != null) {
// Inline function typed initializing formal or
// parameter with default value, like `C(int this.f(String s))` or
// `void m([int f(String s) = null])`.
- computeFunctionType(link.head.asSend().selector.asFunctionExpression());
+ computeInlineFunctionType(
+ link.head.asSend().selector.asFunctionExpression());
} else {
assert(invariant(currentDefinitions,
link.head.asIdentifier() != null || link.head.asSend() != null));
@@ -198,6 +202,15 @@
return parameter;
}
+ FormalElementX createUnnamedParameter() {
+ FormalElementX parameter;
+ assert(!createRealParameters);
+ parameter = new FormalElementX.unnamed(
+ ElementKind.PARAMETER, enclosingElement, currentDefinitions);
+ computeParameterType(parameter);
+ return parameter;
+ }
+
InitializingFormalElementX createFieldParameter(
Send node, Expression initializer) {
InitializingFormalElementX element;
@@ -421,7 +434,7 @@
List<Element> orderedOptionalParameters =
visitor.optionalParameters.toList();
if (visitor.optionalParametersAreNamed) {
- // TODO(karlklose); replace when [visitor.optinalParameters] is a [List].
+ // TODO(karlklose); replace when [visitor.optionalParameters] is a [List].
orderedOptionalParameters.sort((Element a, Element b) {
return a.name.compareTo(b.name);
});
@@ -436,7 +449,7 @@
namedParameterTypes =
namedParameterTypesBuilder.toLink().toList(growable: false);
} else {
- // TODO(karlklose); replace when [visitor.optinalParameters] is a [List].
+ // TODO(karlklose); replace when [visitor.optionalParameters] is a [List].
LinkBuilder<ResolutionDartType> optionalParameterTypesBuilder =
new LinkBuilder<ResolutionDartType>();
for (FormalElement parameter in visitor.optionalParameters) {
diff --git a/pkg/compiler/lib/src/resolution/type_resolver.dart b/pkg/compiler/lib/src/resolution/type_resolver.dart
index 318e748..34e5cab 100644
--- a/pkg/compiler/lib/src/resolution/type_resolver.dart
+++ b/pkg/compiler/lib/src/resolution/type_resolver.dart
@@ -27,6 +27,16 @@
import 'resolution_common.dart' show MappingVisitor;
import 'scope.dart' show Scope;
+class _FormalsTypeResolutionResult {
+ final List<ResolutionDartType> requiredTypes;
+ final List<ResolutionDartType> orderedTypes;
+ final List<String> names;
+ final List<ResolutionDartType> nameTypes;
+
+ _FormalsTypeResolutionResult(
+ this.requiredTypes, this.orderedTypes, this.names, this.nameTypes);
+}
+
class TypeResolver {
final Resolution resolution;
@@ -66,6 +76,154 @@
ResolutionDartType resolveTypeAnnotation(
MappingVisitor visitor, TypeAnnotation node,
{bool malformedIsError: false, bool deferredIsMalformed: true}) {
+ return _resolveTypeAnnotation(
+ visitor, node, const [], malformedIsError: malformedIsError,
+ deferredIsMalformed: deferredIsMalformed);
+ }
+
+ // TODO(floitsch): the [visibleTypeParameterNames] is a hack to put
+ // type parameters in scope for the nested types.
+ //
+ // For example, in the following example, the generic type "A" would be stored
+ // in `visibleTypeParameterNames`.
+ // `typedef F = Function(List<A> Function<A>(A x))`.
+ //
+ // They are resolved to `dynamic` until dart2js supports generic methods.
+ ResolutionDartType _resolveTypeAnnotation(
+ MappingVisitor visitor, TypeAnnotation node,
+ List<List<String>> visibleTypeParameterNames,
+ {bool malformedIsError: false, bool deferredIsMalformed: true}) {
+
+ if (node.asNominalTypeAnnotation() != null) {
+ return resolveNominalTypeAnnotation(
+ visitor, node,
+ visibleTypeParameterNames,
+ malformedIsError: malformedIsError,
+ deferredIsMalformed: deferredIsMalformed);
+ }
+ assert(node.asFunctionTypeAnnotation() != null);
+ return _resolveFunctionTypeAnnotation(
+ visitor, node, visibleTypeParameterNames,
+ malformedIsError: malformedIsError,
+ deferredIsMalformed: deferredIsMalformed);
+ }
+
+ /// Resolves the types of a parameter list.
+ ///
+ /// This function does not accept "inline" function types. For example
+ /// `foo(int bar(String x))` is not accepted.
+ ///
+ /// However, it does work with nested generalized function types:
+ /// `foo(int Function(String) x)`.
+ _FormalsTypeResolutionResult _resolveFormalTypes(
+ MappingVisitor visitor, NodeList formals,
+ List<List<String>> visibleTypeParameterNames) {
+
+ ResolutionDartType resolvePositionalType(VariableDefinitions node) {
+ return _resolveTypeAnnotation(
+ visitor, node.type, visibleTypeParameterNames);
+ }
+
+ void fillNamedTypes(NodeList namedFormals,
+ List<String> names, List<ResolutionDartType> types) {
+ List<Node> nodes = namedFormals.nodes.toList(growable: false);
+
+ // Sort the named arguments first.
+ nodes.sort((node1, node2) {
+ VariableDefinitions a = node1;
+ VariableDefinitions b = node2;
+ assert(a.definitions.nodes.tail.isEmpty);
+ assert(b.definitions.nodes.tail.isEmpty);
+ return a.definitions.nodes.head.asIdentifier().source.compareTo(
+ b.definitions.nodes.head.asIdentifier().source);
+ });
+
+ for (VariableDefinitions node in nodes) {
+ String name = node.definitions.nodes.head.asIdentifier().source;
+ ResolutionDartType type = node.type == null
+ ? const ResolutionDynamicType()
+ : _resolveTypeAnnotation(
+ visitor, node.type, visibleTypeParameterNames);
+ names.add(name);
+ types.add(type);
+ }
+ }
+
+ List<ResolutionDartType> requiredTypes = <ResolutionDartType>[];
+ NodeList optionalFormals = null;
+ for (Link<Node> link = formals.nodes; !link.isEmpty; link = link.tail) {
+ if (link.tail.isEmpty && link.head is NodeList) {
+ optionalFormals = link.head;
+ break;
+ }
+ requiredTypes.add(resolvePositionalType(link.head));
+ }
+
+
+ List<ResolutionDartType> orderedTypes = const <ResolutionDartType>[];
+ List<String> names = const <String>[];
+ List<ResolutionDartType> namedTypes = const <ResolutionDartType>[];
+
+ if (optionalFormals != null) {
+ // This must be a list of optional arguments.
+ String value = optionalFormals.beginToken.stringValue;
+ if ((!identical(value, '[')) && (!identical(value, '{'))) {
+ reporter.internalError(optionalFormals, "expected optional parameters");
+ }
+ bool optionalParametersAreNamed = (identical(value, '{'));
+
+ if (optionalParametersAreNamed) {
+ names = <String>[];
+ namedTypes = <ResolutionDartType>[];
+ fillNamedTypes(optionalFormals, names, namedTypes);
+ } else {
+ orderedTypes = <ResolutionDartType>[];
+ for (Link<Node> link = optionalFormals.nodes;
+ !link.isEmpty;
+ link = link.tail) {
+ orderedTypes.add(resolvePositionalType(link.head));
+ }
+ }
+ }
+ return new _FormalsTypeResolutionResult(
+ requiredTypes, orderedTypes, names, namedTypes);
+ }
+
+ ResolutionFunctionType _resolveFunctionTypeAnnotation(MappingVisitor visitor,
+ FunctionTypeAnnotation node,
+ List<List<String>> visibleTypeParameterNames,
+ {bool malformedIsError: false, bool deferredIsMalformed: true}) {
+
+ assert(visibleTypeParameterNames != null);
+
+ if (node.typeParameters != null) {
+ List<String> newTypeNames = node.typeParameters.map((TypeVariable node) {
+ return node.name.asIdentifier().source;
+ }).toList();
+ visibleTypeParameterNames =
+ visibleTypeParameterNames.toList()..add(newTypeNames);
+ }
+
+ ResolutionDartType returnType = node.returnType == null
+ ? const ResolutionDynamicType()
+ : _resolveTypeAnnotation(visitor, node.returnType,
+ visibleTypeParameterNames);
+ var formalTypes =
+ _resolveFormalTypes(visitor, node.formals, visibleTypeParameterNames);
+ var result = new ResolutionFunctionType.generalized(
+ returnType,
+ formalTypes.requiredTypes,
+ formalTypes.orderedTypes,
+ formalTypes.names,
+ formalTypes.nameTypes);
+ visitor.registry.useType(node, result);
+ return result;
+ }
+
+ ResolutionDartType resolveNominalTypeAnnotation(MappingVisitor visitor,
+ NominalTypeAnnotation node,
+ List<List<String>> visibleTypeParameterNames,
+ {bool malformedIsError: false, bool deferredIsMalformed: true}) {
ResolutionRegistry registry = visitor.registry;
Identifier typeName;
@@ -74,7 +232,8 @@
ResolutionDartType checkNoTypeArguments(ResolutionDartType type) {
List<ResolutionDartType> arguments = new List<ResolutionDartType>();
bool hasTypeArgumentMismatch = resolveTypeArguments(
- visitor, node, const <ResolutionDartType>[], arguments);
+ visitor, node, const <ResolutionDartType>[], arguments,
+ visibleTypeParameterNames);
if (hasTypeArgumentMismatch) {
return new MalformedType(
new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
@@ -106,9 +265,6 @@
}
}
- Element element = resolveTypeName(prefixName, typeName, visitor.scope,
- deferredIsMalformed: deferredIsMalformed);
-
ResolutionDartType reportFailureAndCreateType(
MessageKind messageKind, Map messageArguments,
{ResolutionDartType userProvidedBadType,
@@ -128,14 +284,33 @@
typeName.source, visitor.enclosingElement);
}
List<ResolutionDartType> arguments = <ResolutionDartType>[];
- resolveTypeArguments(
- visitor, node, const <ResolutionDartType>[], arguments);
+ resolveTypeArguments(visitor, node, const <ResolutionDartType>[],
+ arguments, visibleTypeParameterNames);
return new MalformedType(
erroneousElement, userProvidedBadType, arguments);
}
+ Element element;
+ // Resolve references to type names as dynamic.
+ // TODO(floitsch): this hackishly resolves generic function type arguments
+ // to dynamic.
+ if (prefixName == null &&
+ visibleTypeParameterNames.any((n) => n.contains(typeName.source))) {
+ type = const ResolutionDynamicType();
+ } else {
+ element = resolveTypeName(prefixName, typeName, visitor.scope,
+ deferredIsMalformed: deferredIsMalformed);
+ }
+
// Try to construct the type from the element.
- if (element == null) {
+ if (type != null) {
+ // Already assigned to through the visibleTypeParameterNames.
+ // Just make sure that it doesn't have type arguments.
+ if (node.typeArguments != null) {
+ reporter.reportWarningMessage(node.typeArguments.nodes.head,
+ MessageKind.ADDITIONAL_TYPE_ARGUMENT);
+ }
+ } else if (element == null) {
type = reportFailureAndCreateType(
MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
} else if (element.isAmbiguous) {
@@ -170,8 +345,9 @@
resolver.ensureClassWillBeResolvedInternal(cls);
cls.computeType(resolution);
List<ResolutionDartType> arguments = <ResolutionDartType>[];
- bool hasTypeArgumentMismatch =
- resolveTypeArguments(visitor, node, cls.typeVariables, arguments);
+ bool hasTypeArgumentMismatch = resolveTypeArguments(
+ visitor, node, cls.typeVariables, arguments,
+ visibleTypeParameterNames);
if (hasTypeArgumentMismatch) {
type = new BadInterfaceType(
cls.declaration,
@@ -194,7 +370,8 @@
typdef.computeType(resolution);
List<ResolutionDartType> arguments = <ResolutionDartType>[];
bool hasTypeArgumentMismatch = resolveTypeArguments(
- visitor, node, typdef.typeVariables, arguments);
+ visitor, node, typdef.typeVariables, arguments,
+ visibleTypeParameterNames);
if (hasTypeArgumentMismatch) {
type = new BadTypedefType(
typdef,
@@ -241,7 +418,7 @@
}
/// Checks the type arguments of [type] against the type variable bounds.
- void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
+ void checkTypeVariableBounds(NominalTypeAnnotation node, GenericType type) {
void checkTypeVariableBound(_, ResolutionDartType typeArgument,
ResolutionTypeVariableType typeVariable, ResolutionDartType bound) {
if (!types.isSubtype(typeArgument, bound)) {
@@ -266,9 +443,10 @@
*/
bool resolveTypeArguments(
MappingVisitor visitor,
- TypeAnnotation node,
+ NominalTypeAnnotation node,
List<ResolutionDartType> typeVariables,
- List<ResolutionDartType> arguments) {
+ List<ResolutionDartType> arguments,
+ List<List<String>> visibleTypeParameterNames) {
if (node.typeArguments == null) {
return false;
}
@@ -283,8 +461,8 @@
typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
typeArgumentCountMismatch = true;
}
- ResolutionDartType argType =
- resolveTypeAnnotation(visitor, typeArguments.head);
+ ResolutionDartType argType = _resolveTypeAnnotation(
+ visitor, typeArguments.head, visibleTypeParameterNames);
// TODO(karlklose): rewrite to not modify [arguments].
arguments.add(argType);
}
diff --git a/pkg/compiler/lib/src/resolution/typedefs.dart b/pkg/compiler/lib/src/resolution/typedefs.dart
index 90fc2c3..6ed34df 100644
--- a/pkg/compiler/lib/src/resolution/typedefs.dart
+++ b/pkg/compiler/lib/src/resolution/typedefs.dart
@@ -27,12 +27,12 @@
visitTypedef(Typedef node) {
element.computeType(resolution);
scope = new TypeDeclarationScope(scope, element);
- resolveTypeVariableBounds(node.typeParameters);
+ resolveTypeVariableBounds(node.templateParameters);
FunctionSignature signature = SignatureResolver.analyze(
resolution,
scope,
- null /* typeVariables */,
+ node.typeParameters,
node.formals,
node.returnType,
element,
diff --git a/pkg/compiler/lib/src/serialization/element_serialization.dart b/pkg/compiler/lib/src/serialization/element_serialization.dart
index 743952e..0e5c562 100644
--- a/pkg/compiler/lib/src/serialization/element_serialization.dart
+++ b/pkg/compiler/lib/src/serialization/element_serialization.dart
@@ -166,8 +166,7 @@
static void serializeParentRelation(Element element, ObjectEncoder encoder) {
if (element.enclosingClass != null) {
encoder.setElement(Key.CLASS, element.enclosingClass);
- if (element.enclosingClass.declaration.compilationUnit !=
- element.compilationUnit) {
+ if (element.enclosingClass.compilationUnit != element.compilationUnit) {
encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
}
} else {
diff --git a/pkg/compiler/lib/src/serialization/equivalence.dart b/pkg/compiler/lib/src/serialization/equivalence.dart
index 907c8d4..50318a8 100644
--- a/pkg/compiler/lib/src/serialization/equivalence.dart
+++ b/pkg/compiler/lib/src/serialization/equivalence.dart
@@ -151,9 +151,11 @@
/// Returns `true` if the names [a] and [b] are equivalent.
bool areNamesEquivalent(Name a, Name b) {
+ LibraryElement library1 = a.library;
+ LibraryElement library2 = b.library;
return a.text == b.text &&
a.isSetter == b.isSetter &&
- areElementsEquivalent(a.library, b.library);
+ areElementsEquivalent(library1, library2);
}
/// Returns `true` if the dynamic uses [a] and [b] are equivalent.
@@ -866,8 +868,9 @@
@override
bool visitConstructed(
ConstructedConstantValue value1, ConstructedConstantValue value2) {
- return strategy.testTypes(
- value1, value2, 'type', value1.type, value2.type) &&
+ ResolutionInterfaceType type1 = value1.type;
+ ResolutionInterfaceType type2 = value2.type;
+ return strategy.testTypes(value1, value2, 'type', type1, type2) &&
strategy.testMaps(
value1,
value2,
@@ -889,16 +892,18 @@
@override
bool visitList(ListConstantValue value1, ListConstantValue value2) {
- return strategy.testTypes(
- value1, value2, 'type', value1.type, value2.type) &&
+ ResolutionInterfaceType type1 = value1.type;
+ ResolutionInterfaceType type2 = value2.type;
+ return strategy.testTypes(value1, value2, 'type', type1, type2) &&
strategy.testConstantValueLists(
value1, value2, 'entries', value1.entries, value2.entries);
}
@override
bool visitMap(MapConstantValue value1, MapConstantValue value2) {
- return strategy.testTypes(
- value1, value2, 'type', value1.type, value2.type) &&
+ ResolutionInterfaceType type1 = value1.type;
+ ResolutionInterfaceType type2 = value2.type;
+ return strategy.testTypes(value1, value2, 'type', type1, type2) &&
strategy.testConstantValueLists(
value1, value2, 'keys', value1.keys, value2.keys) &&
strategy.testConstantValueLists(
@@ -907,7 +912,9 @@
@override
bool visitType(TypeConstantValue value1, TypeConstantValue value2) {
- return strategy.testTypes(value1, value2, 'type', value1.type, value2.type);
+ ResolutionInterfaceType type1 = value1.type;
+ ResolutionInterfaceType type2 = value2.type;
+ return strategy.testTypes(value1, value2, 'type', type1, type2);
}
@override
@@ -965,8 +972,9 @@
@override
bool visitInterceptor(
InterceptorConstantValue value1, InterceptorConstantValue value2) {
- return strategy.testTypes(value1, value2, 'dispatchedType',
- value1.dispatchedType, value2.dispatchedType);
+ ClassElement cls1 = value1.cls;
+ ClassElement cls2 = value2.cls;
+ return strategy.testElements(value1, value2, 'cls', cls1, cls2);
}
}
@@ -1957,7 +1965,8 @@
}
@override
- bool visitTypeAnnotation(TypeAnnotation node1, TypeAnnotation node2) {
+ bool visitNominalTypeAnnotation(
+ NominalTypeAnnotation node1, NominalTypeAnnotation node2) {
return testNodes(
node1, node2, 'typeName', node1.typeName, node2.typeName) &&
testNodes(node1, node2, 'typeArguments', node1.typeArguments,
@@ -1965,6 +1974,16 @@
}
@override
+ bool visitFunctionTypeAnnotation(
+ FunctionTypeAnnotation node1, FunctionTypeAnnotation node2) {
+ return testNodes(
+ node1, node2, 'returnType', node1.returnType, node2.returnType) &&
+ testNodes(node1, node2, 'formals', node1.formals, node2.formals) &&
+ testNodes(node1, node2, 'typeParameters', node1.typeParameters,
+ node2.typeParameters);
+ }
+
+ @override
bool visitTypeVariable(TypeVariable node1, TypeVariable node2) {
return testNodes(node1, node2, 'name', node1.name, node2.name) &&
testNodes(node1, node2, 'bound', node1.bound, node2.bound);
@@ -1978,8 +1997,8 @@
testNodes(
node1, node2, 'returnType', node1.returnType, node2.returnType) &&
testNodes(node1, node2, 'name', node1.name, node2.name) &&
- testNodes(node1, node2, 'typeParameters', node1.typeParameters,
- node2.typeParameters) &&
+ testNodes(node1, node2, 'typeParameters', node1.templateParameters,
+ node2.templateParameters) &&
testNodes(node1, node2, 'formals', node1.formals, node2.formals);
}
diff --git a/pkg/compiler/lib/src/serialization/modelz.dart b/pkg/compiler/lib/src/serialization/modelz.dart
index e1fb5d0..4c20911 100644
--- a/pkg/compiler/lib/src/serialization/modelz.dart
+++ b/pkg/compiler/lib/src/serialization/modelz.dart
@@ -2152,6 +2152,9 @@
@override
ElementKind get kind => ElementKind.PARAMETER;
+
+ @override
+ bool get isUnnamed => false;
}
class InitializingFormalElementZ extends LocalParameterElementZ
diff --git a/pkg/compiler/lib/src/serialization/serialization_util.dart b/pkg/compiler/lib/src/serialization/serialization_util.dart
index 8d60881..9c7d1a8 100644
--- a/pkg/compiler/lib/src/serialization/serialization_util.dart
+++ b/pkg/compiler/lib/src/serialization/serialization_util.dart
@@ -23,7 +23,8 @@
encoder.setString(Key.NAME, name.text);
encoder.setBool(Key.IS_SETTER, name.isSetter);
if (name.library != null) {
- encoder.setElement(Key.LIBRARY, name.library);
+ LibraryElement library = name.library;
+ encoder.setElement(Key.LIBRARY, library);
}
}
diff --git a/pkg/compiler/lib/src/ssa/builder.dart b/pkg/compiler/lib/src/ssa/builder.dart
index b6ef7c1..7cf54fc 100644
--- a/pkg/compiler/lib/src/ssa/builder.dart
+++ b/pkg/compiler/lib/src/ssa/builder.dart
@@ -1358,8 +1358,7 @@
List bodyCallInputs = <HInstruction>[];
if (isNativeUpgradeFactory) {
if (interceptor == null) {
- ConstantValue constant =
- new InterceptorConstantValue(classElement.thisType);
+ ConstantValue constant = new InterceptorConstantValue(classElement);
interceptor = graph.addConstant(constant, closedWorld);
}
bodyCallInputs.add(interceptor);
@@ -2902,9 +2901,10 @@
HInstruction argumentInstruction = pop();
if (argumentInstruction is HConstant) {
ConstantValue argumentConstant = argumentInstruction.constant;
- if (argumentConstant is TypeConstantValue) {
- ConstantValue constant =
- new InterceptorConstantValue(argumentConstant.representedType);
+ if (argumentConstant is TypeConstantValue &&
+ argumentConstant.representedType is ResolutionInterfaceType) {
+ ResolutionInterfaceType type = argumentConstant.representedType;
+ ConstantValue constant = new InterceptorConstantValue(type.element);
HInstruction instruction = graph.addConstant(constant, closedWorld);
stack.add(instruction);
return;
@@ -3464,6 +3464,7 @@
}
js.Template code = js.js.parseForeignJS('new Array(#)');
var behavior = new native.NativeBehavior();
+ behavior.typesInstantiated.add(expectedType);
behavior.typesReturned.add(expectedType);
// The allocation can throw only if the given length is a double or
// outside the unsigned 32 bit range.
@@ -3993,10 +3994,10 @@
bool isLength = selector.isGetter && selector.name == "length";
if (isLength || selector.isIndex) {
return closedWorld.isSubtypeOf(
- element.enclosingClass.declaration, helpers.jsIndexableClass);
+ element.enclosingClass, helpers.jsIndexableClass);
} else if (selector.isIndexSet) {
- return closedWorld.isSubtypeOf(element.enclosingClass.declaration,
- helpers.jsMutableIndexableClass);
+ return closedWorld.isSubtypeOf(
+ element.enclosingClass, helpers.jsMutableIndexableClass);
} else {
return false;
}
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index aab6519..2fb417b 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -198,7 +198,7 @@
field.initializer.accept(this);
HInstruction fieldValue = pop();
HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
- fieldValue, astAdapter.getDartType(field.type));
+ fieldValue, astAdapter.getDartTypeIfValid(field.type));
stack.add(checkInstruction);
} else {
stack.add(graph.addConstantNull(closedWorld));
@@ -497,12 +497,33 @@
push(trap);
}
- /// Returns the current source element.
+ /// Returns the current source element. This is used by the type builder.
///
/// The returned element is a declaration element.
// TODO(efortuna): Update this when we implement inlining.
+ // TODO(sra): Re-implement type builder using Kernel types and the
+ // `target` for context.
@override
- Element get sourceElement => astAdapter.getElement(target);
+ Element get sourceElement => _sourceElementForTarget(target);
+
+ Element _sourceElementForTarget(ir.Node target) {
+ // For closure-converted (i.e. local functions) the source element is the
+ // 'call' method of the class that represents the closure.
+ if (target is ir.FunctionExpression) {
+ LocalFunctionElement element = astAdapter.getElement(target);
+ ClosureClassMap classMap = compiler.closureToClassMapper
+ .getClosureToClassMapping(element.resolvedAst);
+ return classMap.callElement;
+ }
+ if (target is ir.FunctionDeclaration) {
+ LocalFunctionElement element = astAdapter.getElement(target);
+ ClosureClassMap classMap = compiler.closureToClassMapper
+ .getClosureToClassMapping(element.resolvedAst);
+ return classMap.callElement;
+ }
+ Element element = astAdapter.getElement(target);
+ return element;
+ }
@override
void visitBlock(ir.Block block) {
@@ -941,6 +962,13 @@
void visitAsExpression(ir.AsExpression asExpression) {
asExpression.operand.accept(this);
HInstruction expressionInstruction = pop();
+
+ if (asExpression.type is ir.InvalidType) {
+ generateTypeError(asExpression, 'invalid type');
+ stack.add(expressionInstruction);
+ return;
+ }
+
ResolutionDartType type = astAdapter.getDartType(asExpression.type);
if (type.isMalformed) {
if (type is MalformedType) {
@@ -962,14 +990,17 @@
}
}
- void generateError(ir.Node node, String message, TypeMask typeMask) {
+ void generateError(
+ ir.Node node, ir.Procedure procedure, String message, TypeMask typeMask) {
HInstruction errorMessage =
graph.addConstantString(new DartString.literal(message), closedWorld);
- _pushStaticInvocation(node, [errorMessage], typeMask);
+ // TODO(sra): Assocate source info from [node].
+ _pushStaticInvocation(procedure, [errorMessage], typeMask);
}
void generateTypeError(ir.Node node, String message) {
- generateError(node, message, astAdapter.throwTypeErrorType);
+ generateError(node, astAdapter.throwTypeError, message,
+ astAdapter.throwTypeErrorType);
}
@override
@@ -1300,7 +1331,7 @@
add(new HStaticStore(
astAdapter.getMember(staticTarget),
typeBuilder.potentiallyCheckOrTrustType(
- value, astAdapter.getDartType(staticTarget.setterType))));
+ value, astAdapter.getDartTypeIfValid(staticTarget.setterType))));
}
stack.add(value);
}
@@ -1379,7 +1410,7 @@
localsHandler.updateLocal(
local,
typeBuilder.potentiallyCheckOrTrustType(
- value, astAdapter.getDartType(variable.type)));
+ value, astAdapter.getDartTypeIfValid(variable.type)));
}
@override
@@ -1863,10 +1894,11 @@
HInstruction argumentInstruction = pop();
if (argumentInstruction is HConstant) {
ConstantValue argumentConstant = argumentInstruction.constant;
- if (argumentConstant is TypeConstantValue) {
+ if (argumentConstant is TypeConstantValue &&
+ argumentConstant.representedType is ResolutionInterfaceType) {
+ ResolutionInterfaceType type = argumentConstant.representedType;
// TODO(sra): Check that type is a subclass of [Interceptor].
- ConstantValue constant =
- new InterceptorConstantValue(argumentConstant.representedType);
+ ConstantValue constant = new InterceptorConstantValue(type.element);
HInstruction instruction = graph.addConstant(constant, closedWorld);
stack.add(instruction);
return;
@@ -2112,30 +2144,38 @@
void visitIsExpression(ir.IsExpression isExpression) {
isExpression.operand.accept(this);
HInstruction expression = pop();
- push(buildIsNode(isExpression, isExpression.type, expression));
+ pushIsTest(isExpression, isExpression.type, expression);
}
- HInstruction buildIsNode(
- ir.Node node, ir.DartType type, HInstruction expression) {
+ void pushIsTest(ir.Node node, ir.DartType type, HInstruction expression) {
// Note: The call to "unalias" this type like in the original SSA builder is
// unnecessary in kernel because Kernel has no notion of typedef.
// TODO(efortuna): Add test for this.
- ResolutionDartType typeValue =
- localsHandler.substInContext(astAdapter.getDartType(type));
+
if (type is ir.InvalidType) {
- generateTypeError(node, (typeValue.element as ErroneousElement).message);
- return new HIs.compound(
- typeValue, expression, pop(), commonMasks.boolType);
+ // TODO(sra): Make InvalidType carry a message.
+ generateTypeError(node, 'invalid type');
+ pop();
+ stack.add(graph.addConstantBool(true, closedWorld));
+ return;
}
+ if (type is ir.DynamicType) {
+ stack.add(graph.addConstantBool(true, closedWorld));
+ return;
+ }
+
+ ResolutionDartType typeValue =
+ localsHandler.substInContext(astAdapter.getDartType(type));
if (type is ir.FunctionType) {
List arguments = [buildFunctionType(typeValue), expression];
_pushDynamicInvocation(node, null, arguments,
selector: new Selector.call(
new PrivateName('_isTest', backend.helpers.jsHelperLibrary),
CallStructure.ONE_ARG));
- return new HIs.compound(
- typeValue, expression, pop(), commonMasks.boolType);
+ push(
+ new HIs.compound(typeValue, expression, pop(), commonMasks.boolType));
+ return;
}
if (type is ir.TypeParameterType) {
@@ -2143,8 +2183,9 @@
typeBuilder.addTypeVariableReference(typeValue, sourceElement);
_pushStaticInvocation(astAdapter.checkSubtypeOfRuntimeType,
<HInstruction>[expression, runtimeType], commonMasks.boolType);
- return new HIs.variable(
- typeValue, expression, pop(), commonMasks.boolType);
+ push(
+ new HIs.variable(typeValue, expression, pop(), commonMasks.boolType));
+ return;
}
if (_isInterfaceWithNoDynamicTypes(type)) {
@@ -2167,17 +2208,20 @@
];
_pushStaticInvocation(
astAdapter.checkSubtype, inputs, commonMasks.boolType);
- return new HIs.compound(
- typeValue, expression, pop(), commonMasks.boolType);
+ push(
+ new HIs.compound(typeValue, expression, pop(), commonMasks.boolType));
+ return;
}
if (backend.hasDirectCheckFor(typeValue)) {
- return new HIs.direct(typeValue, expression, commonMasks.boolType);
+ push(new HIs.direct(typeValue, expression, commonMasks.boolType));
+ return;
}
// The interceptor is not always needed. It is removed by optimization
// when the receiver type or tested type permit.
- return new HIs.raw(typeValue, expression, _interceptorFor(expression),
- commonMasks.boolType);
+ push(new HIs.raw(typeValue, expression, _interceptorFor(expression),
+ commonMasks.boolType));
+ return;
}
bool _isInterfaceWithNoDynamicTypes(ir.DartType type) {
@@ -2423,14 +2467,9 @@
int catchesIndex = 0;
void pushCondition(ir.Catch catchBlock) {
- if (catchBlock.guard is! ir.DynamicType) {
- HInstruction condition = kernelBuilder.buildIsNode(
- catchBlock.exception, catchBlock.guard, unwrappedException);
- kernelBuilder.push(condition);
- } else {
- kernelBuilder.stack.add(kernelBuilder.graph
- .addConstantBool(true, kernelBuilder.closedWorld));
- }
+ // `guard` is often `dynamic`, which generates `true`.
+ kernelBuilder.pushIsTest(
+ catchBlock.exception, catchBlock.guard, unwrappedException);
}
void visitThen() {
diff --git a/pkg/compiler/lib/src/ssa/codegen.dart b/pkg/compiler/lib/src/ssa/codegen.dart
index 3ede5f6..78a800f 100644
--- a/pkg/compiler/lib/src/ssa/codegen.dart
+++ b/pkg/compiler/lib/src/ssa/codegen.dart
@@ -2070,7 +2070,8 @@
// available to 'upgrade' the native object.
TypeConstantValue type = constant;
if (type.representedType.isInterfaceType) {
- registry.registerTypeConstant(type.representedType.element);
+ InterfaceType representedType = type.representedType;
+ registry.registerTypeConstant(representedType.element);
}
}
js.Expression expression = backend.emitter.constantReference(constant);
diff --git a/pkg/compiler/lib/src/ssa/graph_builder.dart b/pkg/compiler/lib/src/ssa/graph_builder.dart
index 93700c8..8948546 100644
--- a/pkg/compiler/lib/src/ssa/graph_builder.dart
+++ b/pkg/compiler/lib/src/ssa/graph_builder.dart
@@ -263,6 +263,14 @@
ResolutionTypeVariableType type, GraphBuilder builder) {
ClassElement cls = builder.backend.helpers.RuntimeType;
TypeMask instructionType = new TypeMask.subclass(cls, closedWorld);
+
+ // TODO(floitsch): this hack maps type variables of generic function
+ // typedefs to dynamic. For example: `typedef F = Function<T>(T)`.
+ if (type is MethodTypeVariableType) {
+ visitDynamicType(const ResolutionDynamicType(), builder);
+ return;
+ }
+
if (!builder.sourceElement.enclosingElement.isClosure &&
builder.sourceElement.isInstanceMember) {
HInstruction receiver = builder.localsHandler.readThis();
diff --git a/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart b/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart
index e015e67..86d436e 100644
--- a/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart
+++ b/pkg/compiler/lib/src/ssa/interceptor_simplifier.dart
@@ -6,7 +6,7 @@
import '../compiler.dart' show Compiler;
import '../constants/constant_system.dart';
import '../constants/values.dart';
-import '../elements/elements.dart';
+import '../elements/entities.dart';
import '../js_backend/backend.dart';
import '../types/types.dart';
import '../universe/selector.dart' show Selector;
@@ -39,10 +39,10 @@
final String name = "SsaSimplifyInterceptors";
final ClosedWorld closedWorld;
final Compiler compiler;
- final Element element;
+ final ClassEntity enclosingClass;
HGraph graph;
- SsaSimplifyInterceptors(this.compiler, this.closedWorld, this.element);
+ SsaSimplifyInterceptors(this.compiler, this.closedWorld, this.enclosingClass);
JavaScriptBackend get backend => compiler.backend;
@@ -95,7 +95,7 @@
}
bool canUseSelfForInterceptor(
- HInstruction receiver, Set<ClassElement> interceptedClasses) {
+ HInstruction receiver, Set<ClassEntity> interceptedClasses) {
if (receiver.canBePrimitive(closedWorld)) {
// Primitives always need interceptors.
return false;
@@ -114,7 +114,7 @@
}
HInstruction tryComputeConstantInterceptor(
- HInstruction input, Set<ClassElement> interceptedClasses) {
+ HInstruction input, Set<ClassEntity> interceptedClasses) {
if (input == graph.explicitReceiverParameter) {
// If `explicitReceiverParameter` is set it means the current method is an
// interceptor method, and `this` is the interceptor. The caller just did
@@ -122,25 +122,24 @@
return graph.thisInstruction;
}
- ClassElement constantInterceptor = tryComputeConstantInterceptorFromType(
+ ClassEntity constantInterceptor = tryComputeConstantInterceptorFromType(
input.instructionType, interceptedClasses);
if (constantInterceptor == null) return null;
// If we just happen to be in an instance method of the constant
// interceptor, `this` is a shorter alias.
- if (constantInterceptor == element.enclosingClass &&
+ if (constantInterceptor == enclosingClass &&
graph.thisInstruction != null) {
return graph.thisInstruction;
}
- ConstantValue constant =
- new InterceptorConstantValue(constantInterceptor.thisType);
+ ConstantValue constant = new InterceptorConstantValue(constantInterceptor);
return graph.addConstant(constant, closedWorld);
}
- ClassElement tryComputeConstantInterceptorFromType(
- TypeMask type, Set<ClassElement> interceptedClasses) {
+ ClassEntity tryComputeConstantInterceptorFromType(
+ TypeMask type, Set<ClassEntity> interceptedClasses) {
if (type.isNullable) {
if (type.isNull) {
return backendClasses.nullImplementation;
@@ -174,7 +173,7 @@
// for a subclass or call methods defined on a subclass. Provided the
// code is completely insensitive to the specific instance subclasses, we
// can use the non-leaf class directly.
- ClassElement element = type.singleClass(closedWorld);
+ ClassEntity element = type.singleClass(closedWorld);
if (element != null && backendClasses.isNativeClass(element)) {
return element;
}
@@ -217,7 +216,7 @@
int useCount(HInstruction user, HInstruction used) =>
user.inputs.where((input) => input == used).length;
- Set<ClassElement> interceptedClasses;
+ Set<ClassEntity> interceptedClasses;
HInstruction dominator = findDominator(node.usedBy);
// If there is a call that dominates all other uses, we can use just the
// selector of that instruction.
@@ -233,17 +232,21 @@
if (interceptedClasses.contains(backendClasses.numImplementation) &&
!(interceptedClasses.contains(backendClasses.doubleImplementation) ||
interceptedClasses.contains(backendClasses.intImplementation))) {
- Set<ClassElement> required;
+ Set<ClassEntity> required;
for (HInstruction user in node.usedBy) {
if (user is! HInvoke) continue;
- Set<ClassElement> intercepted =
+ Set<ClassEntity> intercepted =
backend.getInterceptedClassesOn(user.selector.name);
if (intercepted.contains(backendClasses.intImplementation)) {
- required ??= new Set<ClassElement>();
+ // TODO(johnniwinther): Use type argument when all uses of
+ // intercepted classes expect entities instead of elements.
+ required ??= new Set/*<ClassEntity>*/();
required.add(backendClasses.intImplementation);
}
if (intercepted.contains(backendClasses.doubleImplementation)) {
- required ??= new Set<ClassElement>();
+ // TODO(johnniwinther): Use type argument when all uses of
+ // intercepted classes expect entities instead of elements.
+ required ??= new Set/*<ClassEntity>*/();
required.add(backendClasses.doubleImplementation);
}
}
@@ -253,7 +256,9 @@
}
}
} else {
- interceptedClasses = new Set<ClassElement>();
+ // TODO(johnniwinther): Use type argument when all uses of intercepted
+ // classes expect entities instead of elements.
+ interceptedClasses = new Set/*<ClassEntity>*/();
for (HInstruction user in node.usedBy) {
if (user is HInvokeDynamic &&
user.isCallOnInterceptor(closedWorld) &&
@@ -315,12 +320,11 @@
if (!(receiver.canBePrimitiveNumber(closedWorld) ||
receiver.canBePrimitiveBoolean(closedWorld) ||
receiver.canBePrimitiveString(closedWorld))) {
- ClassElement interceptorClass = tryComputeConstantInterceptorFromType(
+ ClassEntity interceptorClass = tryComputeConstantInterceptorFromType(
receiver.instructionType.nonNullable(), interceptedClasses);
if (interceptorClass != null) {
HInstruction constantInstruction = graph.addConstant(
- new InterceptorConstantValue(interceptorClass.thisType),
- closedWorld);
+ new InterceptorConstantValue(interceptorClass), closedWorld);
node.conditionalConstantInterceptor = constantInstruction;
constantInstruction.usedBy.add(node);
return false;
diff --git a/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart b/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart
index ffdb95b..6dbf37b 100644
--- a/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart
+++ b/pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart
@@ -5,7 +5,8 @@
import '../compiler.dart' show Compiler;
import '../constants/constant_system.dart';
import '../constants/values.dart';
-import '../elements/elements.dart';
+import '../elements/elements.dart' show Name;
+import '../elements/entities.dart';
import '../js_backend/js_backend.dart';
import '../types/types.dart';
import '../universe/call_structure.dart';
@@ -72,9 +73,21 @@
int argumentCount = selector.argumentCount;
if (argumentCount == 0) {
if (name == 'round') return const RoundSpecializer();
+ if (name == 'trim') return const TrimSpecializer();
} else if (argumentCount == 1) {
if (name == 'codeUnitAt') return const CodeUnitAtSpecializer();
if (name == 'remainder') return const RemainderSpecializer();
+ if (name == 'substring') return const SubstringSpecializer();
+ if (name == 'contains') return const PatternMatchSpecializer();
+ if (name == 'indexOf') return const PatternMatchSpecializer();
+ if (name == 'startsWith') return const PatternMatchSpecializer();
+ if (name == 'endsWith') return const PatternMatchSpecializer();
+ } else if (argumentCount == 2) {
+ if (name == 'substring') return const SubstringSpecializer();
+ if (name == 'contains') return const PatternMatchSpecializer();
+ if (name == 'indexOf') return const PatternMatchSpecializer();
+ if (name == 'startsWith') return const PatternMatchSpecializer();
+ if (name == 'endsWith') return const PatternMatchSpecializer();
}
}
}
@@ -385,7 +398,6 @@
HInstruction newBuiltinVariant(
HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
- JavaScriptBackend backend = compiler.backend;
return new HRemainder(
instruction.inputs[1],
instruction.inputs[2],
@@ -746,7 +758,7 @@
if (right.isConstantNull() || left.isPrimitiveOrNull(closedWorld)) {
return newBuiltinVariant(instruction, closedWorld);
}
- Iterable<Element> matches =
+ Iterable<MemberEntity> matches =
closedWorld.allFunctions.filter(instruction.selector, instructionType);
// This test relies the on `Object.==` and `Interceptor.==` always being
// implemented because if the selector matches by subtype, it still will be
@@ -847,6 +859,46 @@
}
}
+class IdempotentStringOperationSpecializer extends InvokeDynamicSpecializer {
+ const IdempotentStringOperationSpecializer();
+
+ HInstruction tryConvertToBuiltin(
+ HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
+ HInstruction receiver = instruction.getDartReceiver(closedWorld);
+ if (receiver.isStringOrNull(closedWorld)) {
+ // String.xxx does not have any side effect (other than throwing), and it
+ // can be GVN'ed.
+ clearAllSideEffects(instruction);
+ }
+ return null;
+ }
+}
+
+class SubstringSpecializer extends IdempotentStringOperationSpecializer {
+ const SubstringSpecializer();
+}
+
+class TrimSpecializer extends IdempotentStringOperationSpecializer {
+ const TrimSpecializer();
+}
+
+class PatternMatchSpecializer extends InvokeDynamicSpecializer {
+ const PatternMatchSpecializer();
+
+ HInstruction tryConvertToBuiltin(
+ HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
+ HInstruction receiver = instruction.getDartReceiver(closedWorld);
+ HInstruction pattern = instruction.inputs[2];
+ if (receiver.isStringOrNull(closedWorld) &&
+ pattern.isStringOrNull(closedWorld)) {
+ // String.contains(String s) does not have any side effect (other than
+ // throwing), and it can be GVN'ed.
+ clearAllSideEffects(instruction);
+ }
+ return null;
+ }
+}
+
class RoundSpecializer extends InvokeDynamicSpecializer {
const RoundSpecializer();
diff --git a/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart b/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart
index a865f1c..10b7855 100644
--- a/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart
+++ b/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart
@@ -424,13 +424,16 @@
ir.Procedure get checkSubtypeOfRuntimeType =>
kernel.functions[_backend.helpers.checkSubtypeOfRuntimeType];
- ir.Procedure get assertHelper =>
- kernel.functions[_backend.helpers.assertHelper];
+ ir.Procedure get throwTypeError =>
+ kernel.functions[_backend.helpers.throwTypeError];
TypeMask get throwTypeErrorType =>
TypeMaskFactory.inferredReturnTypeForElement(
_backend.helpers.throwTypeError, _globalInferenceResults);
+ ir.Procedure get assertHelper =>
+ kernel.functions[_backend.helpers.assertHelper];
+
TypeMask get assertHelperReturnType =>
TypeMaskFactory.inferredReturnTypeForElement(
_backend.helpers.assertHelper, _globalInferenceResults);
@@ -507,7 +510,12 @@
}
ResolutionDartType getDartType(ir.DartType type) {
- return type.accept(_typeConverter);
+ return _typeConverter.convert(type);
+ }
+
+ ResolutionDartType getDartTypeIfValid(ir.DartType type) {
+ if (type is ir.InvalidType) return null;
+ return _typeConverter.convert(type);
}
List<ResolutionDartType> getDartTypes(List<ir.DartType> types) {
@@ -530,6 +538,7 @@
}
ResolutionDartType getFunctionReturnType(ir.FunctionNode node) {
+ if (node.returnType is ir.InvalidType) return const ResolutionDynamicType();
return getDartType(node.returnType);
}
@@ -780,12 +789,23 @@
/// Visitor that converts kernel dart types into [ResolutionDartType].
class DartTypeConverter extends ir.DartTypeVisitor<ResolutionDartType> {
final KernelAstAdapter astAdapter;
+ bool topLevel = true;
DartTypeConverter(this.astAdapter);
- ResolutionDartType visitType(ir.DartType type) => type.accept(this);
+ ResolutionDartType convert(ir.DartType type) {
+ topLevel = true;
+ return type.accept(this);
+ }
+
+ /// Visit a inner type.
+ ResolutionDartType visitType(ir.DartType type) {
+ topLevel = false;
+ return type.accept(this);
+ }
List<ResolutionDartType> visitTypes(List<ir.DartType> types) {
+ topLevel = false;
return new List.generate(
types.length, (int index) => types[index].accept(this));
}
@@ -844,7 +864,12 @@
@override
ResolutionDartType visitInvalidType(ir.InvalidType node) {
- throw new UnimplementedError("Invalid types not currently supported");
+ if (topLevel) {
+ throw new UnimplementedError(
+ "Outermost invalid types not currently supported");
+ }
+ // Nested invalid types are treated as `dynamic`.
+ return const ResolutionDynamicType();
}
}
diff --git a/pkg/compiler/lib/src/ssa/loop_handler.dart b/pkg/compiler/lib/src/ssa/loop_handler.dart
index 7edcfeb..6a22a8d 100644
--- a/pkg/compiler/lib/src/ssa/loop_handler.dart
+++ b/pkg/compiler/lib/src/ssa/loop_handler.dart
@@ -4,7 +4,7 @@
import 'package:kernel/ast.dart' as ir;
-import '../elements/elements.dart';
+import '../elements/elements.dart' show JumpTarget, LabelDefinition;
import '../io/source_information.dart';
import '../tree/tree.dart' as ast;
diff --git a/pkg/compiler/lib/src/ssa/optimize.dart b/pkg/compiler/lib/src/ssa/optimize.dart
index 428bb41..d84aaf3 100644
--- a/pkg/compiler/lib/src/ssa/optimize.dart
+++ b/pkg/compiler/lib/src/ssa/optimize.dart
@@ -101,8 +101,8 @@
// Simplifying interceptors is not strictly just an optimization, it is
// required for implementation correctness because the code generator
// assumes it is always performed.
- runPhase(
- new SsaSimplifyInterceptors(compiler, closedWorld, work.element));
+ runPhase(new SsaSimplifyInterceptors(
+ compiler, closedWorld, work.element.enclosingClass));
SsaDeadCodeEliminator dce = new SsaDeadCodeEliminator(closedWorld, this);
runPhase(dce);
@@ -115,7 +115,8 @@
new SsaInstructionSimplifier(backend, closedWorld, this, registry),
new SsaCheckInserter(
trustPrimitives, backend, closedWorld, boundsChecked),
- new SsaSimplifyInterceptors(compiler, closedWorld, work.element),
+ new SsaSimplifyInterceptors(
+ compiler, closedWorld, work.element.enclosingClass),
new SsaDeadCodeEliminator(closedWorld, this),
];
} else {
@@ -2316,7 +2317,7 @@
memorySet.registerAllocation(instruction);
if (shouldTrackInitialValues(instruction)) {
int argumentIndex = 0;
- compiler.codegenWorld.forEachInstanceField(instruction.element,
+ compiler.codegenWorldBuilder.forEachInstanceField(instruction.element,
(_, FieldEntity member) {
if (compiler.elementHasCompileTimeError(member as Entity)) return;
memorySet.registerFieldValue(
diff --git a/pkg/compiler/lib/src/ssa/types.dart b/pkg/compiler/lib/src/ssa/types.dart
index 21be147..07e99b3 100644
--- a/pkg/compiler/lib/src/ssa/types.dart
+++ b/pkg/compiler/lib/src/ssa/types.dart
@@ -2,11 +2,9 @@
// 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.
-import '../compiler.dart' show Compiler;
import '../core_types.dart' show CommonElements;
import '../elements/elements.dart';
import '../native/native.dart' as native;
-import '../tree/tree.dart' as ast;
import '../types/types.dart';
import '../universe/selector.dart' show Selector;
import '../world.dart' show ClosedWorld;
diff --git a/pkg/compiler/lib/src/ssa/types_propagation.dart b/pkg/compiler/lib/src/ssa/types_propagation.dart
index 0500c92..5b1473a 100644
--- a/pkg/compiler/lib/src/ssa/types_propagation.dart
+++ b/pkg/compiler/lib/src/ssa/types_propagation.dart
@@ -3,7 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
import '../compiler.dart' show Compiler;
-import '../elements/elements.dart';
+import '../elements/entities.dart';
import '../js_backend/js_backend.dart';
import '../types/types.dart';
import '../universe/selector.dart' show Selector;
@@ -276,13 +276,12 @@
HTypeConversion.RECEIVER_TYPE_CHECK);
return true;
} else if (instruction.element == null) {
- Iterable<Element> targets = closedWorld.allFunctions
+ Iterable<MemberEntity> targets = closedWorld.allFunctions
.filter(instruction.selector, instruction.mask);
if (targets.length == 1) {
- MemberElement target = targets.first;
- ClassElement cls = target.enclosingClass;
- TypeMask type =
- new TypeMask.nonNullSubclass(cls.declaration, closedWorld);
+ MemberEntity target = targets.first;
+ ClassEntity cls = target.enclosingClass;
+ TypeMask type = new TypeMask.nonNullSubclass(cls, closedWorld);
// TODO(ngeoffray): We currently only optimize on primitive
// types.
if (!type.satisfies(backend.helpers.jsIndexableClass, closedWorld) &&
diff --git a/pkg/compiler/lib/src/ssa/value_range_analyzer.dart b/pkg/compiler/lib/src/ssa/value_range_analyzer.dart
index 7e53d06..23d5087 100644
--- a/pkg/compiler/lib/src/ssa/value_range_analyzer.dart
+++ b/pkg/compiler/lib/src/ssa/value_range_analyzer.dart
@@ -5,7 +5,6 @@
import '../constant_system_dart.dart';
import '../constants/constant_system.dart';
import '../constants/values.dart';
-import '../js_backend/js_backend.dart';
import '../js_backend/backend_helpers.dart';
import '../world.dart' show ClosedWorld;
import 'nodes.dart';
diff --git a/pkg/compiler/lib/src/tokens/token.dart b/pkg/compiler/lib/src/tokens/token.dart
index af31142..79bf27c 100644
--- a/pkg/compiler/lib/src/tokens/token.dart
+++ b/pkg/compiler/lib/src/tokens/token.dart
@@ -120,7 +120,7 @@
}
/**
- * A [SymbolToken] represents the symbol in its precendence info.
+ * A [SymbolToken] represents the symbol in its precedence info.
* Also used for end of file with EOF_INFO.
*/
class SymbolToken extends Token {
diff --git a/pkg/compiler/lib/src/tree/nodes.dart b/pkg/compiler/lib/src/tree/nodes.dart
index 1e5f9dd..3ef0fb3 100644
--- a/pkg/compiler/lib/src/tree/nodes.dart
+++ b/pkg/compiler/lib/src/tree/nodes.dart
@@ -48,6 +48,10 @@
R visitForIn(ForIn node) => visitLoop(node);
R visitFunctionDeclaration(FunctionDeclaration node) => visitStatement(node);
R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
+ R visitFunctionTypeAnnotation(FunctionTypeAnnotation node) {
+ return visitTypeAnnotation(node);
+ }
+
R visitGotoStatement(GotoStatement node) => visitStatement(node);
R visitIdentifier(Identifier node) => visitExpression(node);
R visitImport(Import node) => visitLibraryDependency(node);
@@ -79,6 +83,10 @@
R visitNewExpression(NewExpression node) => visitExpression(node);
R visitNodeList(NodeList node) => visitNode(node);
+ R visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+ return visitTypeAnnotation(node);
+ }
+
R visitOperator(Operator node) => visitIdentifier(node);
R visitParenthesizedExpression(ParenthesizedExpression node) {
return visitExpression(node);
@@ -176,6 +184,10 @@
return visitExpression(node, arg);
}
+ R visitFunctionTypeAnnotation(FunctionTypeAnnotation node, A arg) {
+ return visitTypeAnnotation(node, arg);
+ }
+
R visitGotoStatement(GotoStatement node, A arg) {
return visitStatement(node, arg);
}
@@ -225,6 +237,10 @@
R visitNewExpression(NewExpression node, A arg) => visitExpression(node, arg);
R visitNodeList(NodeList node, A arg) => visitNode(node, arg);
+ R visitNominalTypeAnnotation(NominalTypeAnnotation node, A arg) {
+ visitTypeAnnotation(node, arg);
+ }
+
R visitOperator(Operator node, A arg) => visitIdentifier(node, arg);
R visitParenthesizedExpression(ParenthesizedExpression node, A arg) {
return visitExpression(node, arg);
@@ -260,8 +276,8 @@
R visitLiteralSymbol(LiteralSymbol node, A arg) => visitExpression(node, arg);
R visitThrow(Throw node, A arg) => visitExpression(node, arg);
R visitTryStatement(TryStatement node, A arg) => visitStatement(node, arg);
- R visitTypeAnnotation(TypeAnnotation node, A arg) => visitNode(node, arg);
R visitTypedef(Typedef node, A arg) => visitNode(node, arg);
+ R visitTypeAnnotation(TypeAnnotation node, A arg) => visitNode(node, arg);
R visitTypeVariable(TypeVariable node, A arg) => visitNode(node, arg);
R visitVariableDefinitions(VariableDefinitions node, A arg) {
return visitStatement(node, arg);
@@ -360,6 +376,7 @@
ForIn asForIn() => null;
FunctionDeclaration asFunctionDeclaration() => null;
FunctionExpression asFunctionExpression() => null;
+ FunctionTypeAnnotation asFunctionTypeAnnotation() => null;
Identifier asIdentifier() => null;
If asIf() => null;
Import asImport() => null;
@@ -383,6 +400,7 @@
NamedMixinApplication asNamedMixinApplication() => null;
NewExpression asNewExpression() => null;
NodeList asNodeList() => null;
+ NominalTypeAnnotation asNominalTypeAnnotation() => null;
Operator asOperator() => null;
ParenthesizedExpression asParenthesizedExpression() => null;
Part asPart() => null;
@@ -401,7 +419,6 @@
SwitchStatement asSwitchStatement() => null;
Throw asThrow() => null;
TryStatement asTryStatement() => null;
- TypeAnnotation asTypeAnnotation() => null;
TypeVariable asTypeVariable() => null;
Typedef asTypedef() => null;
VariableDefinitions asVariableDefinitions() => null;
@@ -486,7 +503,7 @@
}
class MixinApplication extends Node {
- final TypeAnnotation superclass;
+ final NominalTypeAnnotation superclass;
final NodeList mixins;
MixinApplication(this.superclass, this.mixins);
@@ -511,8 +528,6 @@
Token getEndToken() => mixins.getEndToken();
}
-// TODO(kasperl): Let this share some structure with the typedef for function
-// type aliases?
class NamedMixinApplication extends Node implements MixinApplication {
final Identifier name;
final NodeList typeParameters;
@@ -527,7 +542,7 @@
NamedMixinApplication(this.name, this.typeParameters, this.modifiers,
this.mixinApplication, this.interfaces, this.classKeyword, this.endToken);
- TypeAnnotation get superclass => mixinApplication.superclass;
+ NominalTypeAnnotation get superclass => mixinApplication.superclass;
NodeList get mixins => mixinApplication.mixins;
MixinApplication asMixinApplication() => this;
@@ -1720,17 +1735,22 @@
Token getEndToken() => endToken;
}
-class TypeAnnotation extends Node {
+abstract class TypeAnnotation extends Node {
+}
+
+class NominalTypeAnnotation extends TypeAnnotation {
final Expression typeName;
final NodeList typeArguments;
- TypeAnnotation(Expression this.typeName, NodeList this.typeArguments);
+ NominalTypeAnnotation(this.typeName, this.typeArguments);
- TypeAnnotation asTypeAnnotation() => this;
+ NominalTypeAnnotation asNominalTypeAnnotation() => this;
- accept(Visitor visitor) => visitor.visitTypeAnnotation(this);
+ accept(Visitor visitor) => visitor.visitNominalTypeAnnotation(this);
- accept1(Visitor1 visitor, arg) => visitor.visitTypeAnnotation(this, arg);
+ accept1(Visitor1 visitor, arg) {
+ return visitor.visitNominalTypeAnnotation(this, arg);
+ }
visitChildren(Visitor visitor) {
typeName.accept(visitor);
@@ -1826,7 +1846,13 @@
return token;
}
- Token getEndToken() => definitions.getEndToken();
+ Token getEndToken() {
+ var result = definitions.getEndToken();
+ if (result != null) return result;
+ assert(definitions.nodes.length == 1);
+ assert(definitions.nodes.last == null);
+ return type.getEndToken();
+ }
}
abstract class Loop extends Statement {
@@ -2854,16 +2880,30 @@
}
class Typedef extends Node {
+ final bool isGeneralizedTypeAlias;
+
+ /// Parameters to the template.
+ ///
+ /// For example, `T` and `S` are template parameters in the following
+ /// typedef: `typedef F<S, T> = Function(S, T)`, or, in the inlined syntax,
+ /// `typedef F<S, T>(S x, T y)`.
+ final NodeList templateParameters;
+
final TypeAnnotation returnType;
final Identifier name;
+ /// The generic type parameters to the function type.
+ ///
+ /// For example `A` and `B` (but not `T`) are type parameters in
+ /// `typedef F<T> = Function<A, B>(A, B, T)`;
final NodeList typeParameters;
final NodeList formals;
final Token typedefKeyword;
final Token endToken;
- Typedef(this.returnType, this.name, this.typeParameters, this.formals,
- this.typedefKeyword, this.endToken);
+ Typedef(this.isGeneralizedTypeAlias, this.templateParameters, this.returnType,
+ this.name, this.typeParameters, this.formals, this.typedefKeyword,
+ this.endToken);
Typedef asTypedef() => this;
@@ -2872,6 +2912,7 @@
accept1(Visitor1 visitor, arg) => visitor.visitTypedef(this, arg);
visitChildren(Visitor visitor) {
+ if (templateParameters != null) templateParameters.accept(visitor);
if (returnType != null) returnType.accept(visitor);
name.accept(visitor);
if (typeParameters != null) typeParameters.accept(visitor);
@@ -2879,6 +2920,7 @@
}
visitChildren1(Visitor1 visitor, arg) {
+ if (templateParameters != null) templateParameters.accept1(visitor, arg);
if (returnType != null) returnType.accept1(visitor, arg);
name.accept1(visitor, arg);
if (typeParameters != null) typeParameters.accept1(visitor, arg);
@@ -2890,6 +2932,43 @@
Token getEndToken() => endToken;
}
+class FunctionTypeAnnotation extends TypeAnnotation {
+ final TypeAnnotation returnType;
+ final Token functionToken;
+ final NodeList typeParameters;
+ final NodeList formals;
+
+ FunctionTypeAnnotation(
+ this.returnType, this.functionToken, this.typeParameters, this.formals);
+
+ FunctionTypeAnnotation asFunctionTypeAnnotation() => this;
+
+ accept(Visitor visitor) => visitor.visitFunctionTypeAnnotation(this);
+
+ accept1(Visitor1 visitor, arg) {
+ return visitor.visitFunctionTypeAnnotation(this, arg);
+ }
+
+ visitChildren(Visitor visitor) {
+ if (returnType != null) returnType.accept(visitor);
+ if (typeParameters != null) typeParameters.accept(visitor);
+ formals.accept(visitor);
+ }
+
+ visitChildren1(Visitor1 visitor, arg) {
+ if (returnType != null) returnType.accept1(visitor, arg);
+ if (typeParameters != null) typeParameters.accept1(visitor, arg);
+ formals.accept1(visitor, arg);
+ }
+
+ Token getBeginToken() {
+ if (returnType != null) return returnType.getBeginToken();
+ return functionToken;
+ }
+
+ Token getEndToken() => formals.getEndToken();
+}
+
class TryStatement extends Statement {
final Block tryBlock;
final NodeList catchBlocks;
@@ -3134,6 +3213,8 @@
get type => null;
// Typedef.
+ get isGeneralizedTypeAlias => null;
+ get templateParameters => null;
get typeParameters => null;
get formals => null;
get typedefKeyword => null;
diff --git a/pkg/compiler/lib/src/tree/prettyprint.dart b/pkg/compiler/lib/src/tree/prettyprint.dart
index 837db37..1549d4d 100644
--- a/pkg/compiler/lib/src/tree/prettyprint.dart
+++ b/pkg/compiler/lib/src/tree/prettyprint.dart
@@ -153,6 +153,14 @@
closeNode();
}
+ visitFunctionTypeAnnotation(FunctionTypeAnnotation node) {
+ openNode(node, "FunctionTypeAnnotation");
+ visitChildNode(node.returnType, "returnType");
+ visitChildNode(node.typeParameters, "typeParameters");
+ visitChildNode(node.formals, "formals");
+ closeNode();
+ }
+
visitIdentifier(Identifier node) {
openAndCloseNode(node, "Identifier", {"token": node.token});
}
@@ -244,6 +252,13 @@
}
}
+ visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+ openNode(node, "NominalTypeAnnotation");
+ visitChildNode(node.typeName, "typeName");
+ visitChildNode(node.typeArguments, "typeArguments");
+ closeNode();
+ }
+
visitOperator(Operator node) {
openAndCloseNode(node, "Operator", {"value": node.token});
}
@@ -345,13 +360,6 @@
visitNodeWithChildren(node, "TryStatement");
}
- visitTypeAnnotation(TypeAnnotation node) {
- openNode(node, "TypeAnnotation");
- visitChildNode(node.typeName, "typeName");
- visitChildNode(node.typeArguments, "typeArguments");
- closeNode();
- }
-
visitTypedef(Typedef node) {
visitNodeWithChildren(node, "Typedef");
}
@@ -472,6 +480,10 @@
unimplemented('visitNode', node: node);
}
+ visitTypeAnnotation(TypeAnnotation node) {
+ unimplemented('visitNode', node: node);
+ }
+
unimplemented(String message, {Node node}) {
throw message;
}
diff --git a/pkg/compiler/lib/src/tree/unparser.dart b/pkg/compiler/lib/src/tree/unparser.dart
index 5d1d154..f2cef05 100644
--- a/pkg/compiler/lib/src/tree/unparser.dart
+++ b/pkg/compiler/lib/src/tree/unparser.dart
@@ -548,11 +548,18 @@
visit(node.expression);
}
- visitTypeAnnotation(TypeAnnotation node) {
+ visitNominalTypeAnnotation(NominalTypeAnnotation node) {
visit(node.typeName);
visit(node.typeArguments);
}
+ visitFunctionTypeAnnotation(FunctionTypeAnnotation node) {
+ visit(node.returnType);
+ write(' Function');
+ visit(node.typeParameters);
+ visit(node.formals);
+ }
+
visitTypeVariable(TypeVariable node) {
visit(node.name);
if (node.bound != null) {
@@ -771,8 +778,8 @@
write(' ');
}
visit(node.name);
- if (node.typeParameters != null) {
- visit(node.typeParameters);
+ if (node.templateParameters != null) {
+ visit(node.templateParameters);
}
visit(node.formals);
write(node.endToken.value);
@@ -904,4 +911,8 @@
visitStringNode(StringNode node) {
throw 'internal error'; // Should not be called.
}
+
+ visitTypeAnnotation(TypeAnnotation node) {
+ throw 'internal error'; // Should not be called.
+ }
}
diff --git a/pkg/compiler/lib/src/typechecker.dart b/pkg/compiler/lib/src/typechecker.dart
index 0660e3d..cb6557c 100644
--- a/pkg/compiler/lib/src/typechecker.dart
+++ b/pkg/compiler/lib/src/typechecker.dart
@@ -808,12 +808,13 @@
void findPrivateMember(MemberSignature member) {
if (memberName.isSimilarTo(member.name)) {
PrivateName privateName = member.name;
+ LibraryElement library = privateName.library;
reportMessage(
node,
MessageKind.PRIVATE_ACCESS,
{
'name': name,
- 'libraryName': privateName.library.libraryOrScriptName
+ 'libraryName': library.libraryOrScriptName
},
isHint: isHint);
foundPrivateMember = true;
diff --git a/pkg/compiler/lib/src/types/container_type_mask.dart b/pkg/compiler/lib/src/types/container_type_mask.dart
index 908996b..edad3af 100644
--- a/pkg/compiler/lib/src/types/container_type_mask.dart
+++ b/pkg/compiler/lib/src/types/container_type_mask.dart
@@ -13,8 +13,8 @@
// The [Node] where this type mask was created.
final Node allocationNode;
- // The [Element] where this type mask was created.
- final Element allocationElement;
+ // The [Entity] where this type mask was created.
+ final Entity allocationElement;
// The element type of this container.
final TypeMask elementType;
diff --git a/pkg/compiler/lib/src/types/flat_type_mask.dart b/pkg/compiler/lib/src/types/flat_type_mask.dart
index 15caf64..5b93e4d 100644
--- a/pkg/compiler/lib/src/types/flat_type_mask.dart
+++ b/pkg/compiler/lib/src/types/flat_type_mask.dart
@@ -14,15 +14,17 @@
static const int SUBCLASS = 2;
static const int SUBTYPE = 3;
- final Entity base;
+ final ClassEntity base;
final int flags;
- FlatTypeMask(Entity base, int kind, bool isNullable)
+ FlatTypeMask(ClassEntity base, int kind, bool isNullable)
: this.internal(base, (kind << 1) | (isNullable ? 1 : 0));
- FlatTypeMask.exact(Entity base) : this.internal(base, (EXACT << 1) | 1);
- FlatTypeMask.subclass(Entity base) : this.internal(base, (SUBCLASS << 1) | 1);
- FlatTypeMask.subtype(Entity base) : this.internal(base, (SUBTYPE << 1) | 1);
+ FlatTypeMask.exact(ClassEntity base) : this.internal(base, (EXACT << 1) | 1);
+ FlatTypeMask.subclass(ClassEntity base)
+ : this.internal(base, (SUBCLASS << 1) | 1);
+ FlatTypeMask.subtype(ClassEntity base)
+ : this.internal(base, (SUBTYPE << 1) | 1);
const FlatTypeMask.nonNullEmpty()
: base = null,
@@ -31,22 +33,24 @@
: base = null,
flags = 1;
- FlatTypeMask.nonNullExact(Entity base) : this.internal(base, EXACT << 1);
- FlatTypeMask.nonNullSubclass(Entity base)
+ FlatTypeMask.nonNullExact(ClassEntity base) : this.internal(base, EXACT << 1);
+ FlatTypeMask.nonNullSubclass(ClassEntity base)
: this.internal(base, SUBCLASS << 1);
- FlatTypeMask.nonNullSubtype(Entity base) : this.internal(base, SUBTYPE << 1);
+ FlatTypeMask.nonNullSubtype(ClassEntity base)
+ : this.internal(base, SUBTYPE << 1);
- bool _validateBase(ClassElement element) => element.isDeclaration;
+ ClassQuery get _classQuery => isExact
+ ? ClassQuery.EXACT
+ : (isSubclass ? ClassQuery.SUBCLASS : ClassQuery.SUBTYPE);
- FlatTypeMask.internal(this.base, this.flags) {
- assert(base == null || _validateBase(base));
- }
+ FlatTypeMask.internal(this.base, this.flags);
/**
* Ensures that the generated mask is normalized, i.e., a call to
* [TypeMask.assertIsNormalized] with the factory's result returns `true`.
*/
- factory FlatTypeMask.normalized(Entity base, int flags, ClosedWorld world) {
+ factory FlatTypeMask.normalized(
+ ClassEntity base, int flags, ClosedWorld world) {
if ((flags >> 1) == EMPTY || ((flags >> 1) == EXACT)) {
return new FlatTypeMask.internal(base, flags);
}
@@ -89,8 +93,7 @@
return isNullable ? new FlatTypeMask.internal(base, flags & ~1) : this;
}
- bool contains(Entity other, ClosedWorld closedWorld) {
- assert(_validateBase(other));
+ bool contains(ClassEntity other, ClosedWorld closedWorld) {
if (isEmptyOrNull) {
return false;
} else if (identical(base, other)) {
@@ -105,7 +108,7 @@
}
}
- bool isSingleImplementationOf(Entity cls, ClosedWorld closedWorld) {
+ bool isSingleImplementationOf(ClassEntity cls, ClosedWorld closedWorld) {
// Special case basic types so that, for example, JSString is the
// single implementation of String.
// The general optimization is to realize there is only one class that
@@ -145,7 +148,7 @@
if (other is! FlatTypeMask) return other.containsMask(this, closedWorld);
// The other must be flat, so compare base and flags.
FlatTypeMask flatOther = other;
- Entity otherBase = flatOther.base;
+ ClassEntity otherBase = flatOther.base;
// If other is exact, it only contains its base.
// TODO(herhut): Get rid of isSingleImplementationOf.
if (flatOther.isExact) {
@@ -206,13 +209,11 @@
base == backendClasses.stringImplementation;
}
- bool containsOnly(Entity cls) {
- assert(_validateBase(cls));
+ bool containsOnly(ClassEntity cls) {
return base == cls;
}
- bool satisfies(Entity cls, ClosedWorld closedWorld) {
- assert(_validateBase(cls));
+ bool satisfies(ClassEntity cls, ClosedWorld closedWorld) {
if (isEmptyOrNull) return false;
if (closedWorld.isSubtypeOf(base, cls)) return true;
return false;
@@ -220,7 +221,7 @@
/// Returns the [Entity] if this type represents a single class, otherwise
/// returns `null`. This method is conservative.
- Entity singleClass(ClosedWorld closedWorld) {
+ ClassEntity singleClass(ClosedWorld closedWorld) {
if (isEmptyOrNull) return null;
if (isNullable) return null; // It is Null and some other class.
if (isExact) {
@@ -469,33 +470,14 @@
if (isSubclass && other.isSubclass) return intersectionEmpty(other);
assert(isSubtype || other.isSubtype);
int kind = (isSubclass || other.isSubclass) ? SUBCLASS : SUBTYPE;
- // TODO(johnniwinther): Move this computation to [ClosedWorld].
- // Compute the set of classes that are contained in both type masks.
- Set<ClassElement> common = commonContainedClasses(this, other, closedWorld);
- if (common == null || common.isEmpty) return intersectionEmpty(other);
- // Narrow down the candidates by only looking at common classes
- // that do not have a superclass or supertype that will be a
- // better candidate.
- Iterable<ClassElement> candidates = common.where((ClassElement each) {
- bool containsSuperclass = common.contains(each.supertype.element);
- // If the superclass is also a candidate, then we don't want to
- // deal with this class. If we're only looking for a subclass we
- // know we don't have to look at the list of interfaces because
- // they can never be in the common set.
- if (containsSuperclass || kind == SUBCLASS) return !containsSuperclass;
- // Run through the direct supertypes of the class. If the common
- // set contains the direct supertype of the class, we ignore the
- // the class because the supertype is a better candidate.
- for (Link link = each.interfaces; !link.isEmpty; link = link.tail) {
- if (common.contains(link.head.element)) return false;
- }
- return true;
- });
+ Iterable<ClassEntity> candidates = closedWorld.commonSubclasses(
+ base, _classQuery, other.base, other._classQuery);
+ if (candidates.isEmpty) return intersectionEmpty(other);
// Run through the list of candidates and compute the union. The
// result will only be nullable if both masks are nullable. We have
// to normalize here, as we generate types based on new base classes.
int combined = (kind << 1) | (flags & other.flags & 1);
- Iterable<TypeMask> masks = candidates.map((Entity cls) {
+ Iterable<TypeMask> masks = candidates.map((ClassEntity cls) {
return new FlatTypeMask.normalized(cls, combined, closedWorld);
});
return UnionTypeMask.unionOf(masks, closedWorld);
@@ -513,7 +495,7 @@
* privacy is taken into account.
*/
bool canHit(
- MemberElement element, Selector selector, ClosedWorld closedWorld) {
+ MemberEntity element, Selector selector, ClosedWorld closedWorld) {
BackendClasses backendClasses = closedWorld.backendClasses;
assert(element.name == selector.name);
if (isEmpty) return false;
@@ -522,7 +504,7 @@
backendClasses.nullImplementation, selector, element);
}
- ClassEntity other = element.enclosingClass.declaration;
+ ClassEntity other = element.enclosingClass;
if (other == backendClasses.nullImplementation) {
return isNullable;
} else if (isExact) {
@@ -558,22 +540,16 @@
// usage).
if (isExact && closedWorld.isAbstract(base)) return false;
- return closedWorld.needsNoSuchMethod(
- base,
- selector,
- isExact
- ? ClassQuery.EXACT
- : (isSubclass ? ClassQuery.SUBCLASS : ClassQuery.SUBTYPE));
+ return closedWorld.needsNoSuchMethod(base, selector, _classQuery);
}
- MemberElement locateSingleElement(
- Selector selector, ClosedWorld closedWorld) {
+ MemberEntity locateSingleElement(Selector selector, ClosedWorld closedWorld) {
if (isEmptyOrNull) return null;
- Iterable<MemberElement> targets =
+ Iterable<MemberEntity> targets =
closedWorld.allFunctions.filter(selector, this);
if (targets.length != 1) return null;
- Element result = targets.first;
- ClassElement enclosing = result.enclosingClass.declaration;
+ MemberEntity result = targets.first;
+ ClassEntity enclosing = result.enclosingClass;
// We only return the found element if it is guaranteed to be implemented on
// all classes in the receiver type [this]. It could be found only in a
// subclass or in an inheritance-wise unrelated class in case of subtype
@@ -613,26 +589,4 @@
buffer.write(base.name);
return "[$buffer]";
}
-
- static Set<ClassElement> commonContainedClasses(
- FlatTypeMask x, FlatTypeMask y, ClosedWorld closedWorld) {
- Iterable<ClassElement> xSubset = containedSubset(x, closedWorld);
- if (xSubset == null) return null;
- Iterable<ClassElement> ySubset = containedSubset(y, closedWorld);
- if (ySubset == null) return null;
- return xSubset.toSet().intersection(ySubset.toSet());
- }
-
- static Iterable<ClassElement> containedSubset(
- FlatTypeMask x, ClosedWorld closedWorld) {
- ClassElement element = x.base;
- if (x.isExact) {
- return null;
- } else if (x.isSubclass) {
- return closedWorld.strictSubclassesOf(element);
- } else {
- assert(x.isSubtype);
- return closedWorld.strictSubtypesOf(element);
- }
- }
}
diff --git a/pkg/compiler/lib/src/types/forwarding_type_mask.dart b/pkg/compiler/lib/src/types/forwarding_type_mask.dart
index 73ac59d..04ee5c0 100644
--- a/pkg/compiler/lib/src/types/forwarding_type_mask.dart
+++ b/pkg/compiler/lib/src/types/forwarding_type_mask.dart
@@ -54,15 +54,15 @@
return forwardTo.containsOnlyString(closedWorld);
}
- bool containsOnly(Entity cls) {
+ bool containsOnly(ClassEntity cls) {
return forwardTo.containsOnly(cls);
}
- bool satisfies(Entity cls, ClosedWorld closedWorld) {
+ bool satisfies(ClassEntity cls, ClosedWorld closedWorld) {
return forwardTo.satisfies(cls, closedWorld);
}
- bool contains(Entity cls, ClosedWorld closedWorld) {
+ bool contains(ClassEntity cls, ClosedWorld closedWorld) {
return forwardTo.contains(cls, closedWorld);
}
@@ -70,7 +70,7 @@
return forwardTo.containsAll(closedWorld);
}
- Entity singleClass(ClosedWorld closedWorld) {
+ ClassEntity singleClass(ClosedWorld closedWorld) {
return forwardTo.singleClass(closedWorld);
}
diff --git a/pkg/compiler/lib/src/types/map_type_mask.dart b/pkg/compiler/lib/src/types/map_type_mask.dart
index 230db17..148fdbf 100644
--- a/pkg/compiler/lib/src/types/map_type_mask.dart
+++ b/pkg/compiler/lib/src/types/map_type_mask.dart
@@ -15,8 +15,8 @@
// The [Node] where this type mask was created.
final Node allocationNode;
- // The [Element] where this type mask was created.
- final Element allocationElement;
+ // The [Entity] where this type mask was created.
+ final Entity allocationElement;
// The value type of this map.
final TypeMask valueType;
diff --git a/pkg/compiler/lib/src/types/masks.dart b/pkg/compiler/lib/src/types/masks.dart
index 8e86799..827e3f4 100644
--- a/pkg/compiler/lib/src/types/masks.dart
+++ b/pkg/compiler/lib/src/types/masks.dart
@@ -7,7 +7,7 @@
import '../common.dart';
import '../common/backend_api.dart' show BackendClasses;
import '../constants/values.dart' show PrimitiveConstantValue;
-import '../elements/elements.dart';
+import '../elements/elements.dart' show Entity;
import '../elements/entities.dart';
import '../inferrer/type_graph_inferrer.dart' show TypeGraphInferrer;
import '../tree/tree.dart';
@@ -173,7 +173,7 @@
// Just checking for [:TypedData:] is not sufficient, as it is an
// abstract class any user-defined class can implement. So we also
// check for the interface [JavaScriptIndexingBehavior].
- ClassElement typedDataClass = closedWorld.commonElements.typedDataClass;
+ ClassEntity typedDataClass = closedWorld.commonElements.typedDataClass;
return typedDataClass != null &&
closedWorld.isInstantiated(typedDataClass) &&
mask.satisfies(typedDataClass, closedWorld) &&
@@ -187,7 +187,7 @@
!type1.intersection(type2, closedWorld).isEmpty;
// TODO(herhut): Maybe cache the TypeMask for typedDataClass and
// jsIndexingBehaviourInterface.
- ClassElement typedDataClass = closedWorld.commonElements.typedDataClass;
+ ClassEntity typedDataClass = closedWorld.commonElements.typedDataClass;
return typedDataClass != null &&
closedWorld.isInstantiated(typedDataClass) &&
intersects(mask, new TypeMask.subtype(typedDataClass, closedWorld)) &&
@@ -198,11 +198,11 @@
closedWorld));
}
- TypeMask createNonNullExact(ClassElement cls) {
- return new TypeMask.nonNullExact(cls.declaration, closedWorld);
+ TypeMask createNonNullExact(ClassEntity cls) {
+ return new TypeMask.nonNullExact(cls, closedWorld);
}
- TypeMask createNonNullSubtype(ClassElement cls) {
- return new TypeMask.nonNullSubtype(cls.declaration, closedWorld);
+ TypeMask createNonNullSubtype(ClassEntity cls) {
+ return new TypeMask.nonNullSubtype(cls, closedWorld);
}
}
diff --git a/pkg/compiler/lib/src/types/type_mask.dart b/pkg/compiler/lib/src/types/type_mask.dart
index d6e68da..90bb911 100644
--- a/pkg/compiler/lib/src/types/type_mask.dart
+++ b/pkg/compiler/lib/src/types/type_mask.dart
@@ -12,7 +12,7 @@
Set<TypeMask> _masks;
@override
- bool applies(MemberElement element, Selector selector, ClosedWorld world) {
+ bool applies(MemberEntity element, Selector selector, ClosedWorld world) {
if (isAll) return true;
if (_masks == null) return false;
for (TypeMask mask in _masks) {
@@ -77,7 +77,7 @@
*/
abstract class TypeMask implements ReceiverConstraint, AbstractValue {
factory TypeMask(
- Entity base, int kind, bool isNullable, ClosedWorld closedWorld) {
+ ClassEntity base, int kind, bool isNullable, ClosedWorld closedWorld) {
return new FlatTypeMask.normalized(
base, (kind << 1) | (isNullable ? 1 : 0), closedWorld);
}
@@ -100,7 +100,7 @@
assert(invariant(base, closedWorld.isInstantiated(base),
message: () => "Cannot create subclass type mask for uninstantiated "
"class $base.\n${closedWorld.dump(base)}"));
- Entity topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
+ ClassEntity topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
if (topmost == null) {
return new TypeMask.empty();
} else if (closedWorld.hasAnyStrictSubclass(topmost)) {
@@ -111,7 +111,7 @@
}
factory TypeMask.subtype(ClassEntity base, ClosedWorld closedWorld) {
- Entity topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
+ ClassEntity topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
if (topmost == null) {
return new TypeMask.empty();
}
@@ -287,7 +287,7 @@
bool containsOnlyNum(ClosedWorld closedWorld);
bool containsOnlyBool(ClosedWorld closedWorld);
bool containsOnlyString(ClosedWorld closedWorld);
- bool containsOnly(Entity cls);
+ bool containsOnly(ClassEntity cls);
/**
* Compares two [TypeMask] objects for structural equality.
@@ -316,12 +316,12 @@
/**
* Returns whether this type mask is an instance of [cls].
*/
- bool satisfies(Entity cls, ClosedWorld closedWorld);
+ bool satisfies(ClassEntity cls, ClosedWorld closedWorld);
/**
* Returns whether or not this type mask contains the given class [cls].
*/
- bool contains(Entity cls, ClosedWorld closedWorld);
+ bool contains(ClassEntity cls, ClosedWorld closedWorld);
/**
* Returns whether or not this type mask contains all types.
diff --git a/pkg/compiler/lib/src/types/union_type_mask.dart b/pkg/compiler/lib/src/types/union_type_mask.dart
index 40305cc..2832b75 100644
--- a/pkg/compiler/lib/src/types/union_type_mask.dart
+++ b/pkg/compiler/lib/src/types/union_type_mask.dart
@@ -97,13 +97,14 @@
bool isNullable = masks.any((e) => e.isNullable);
List masksBases = masks.map((mask) => mask.base).toList();
- Iterable<Entity> candidates = closedWorld.commonSupertypesOf(masksBases);
+ Iterable<ClassEntity> candidates =
+ closedWorld.commonSupertypesOf(masksBases);
// Compute the best candidate and its kind.
- Entity bestElement;
+ ClassEntity bestElement;
int bestKind;
int bestSize;
- for (Entity candidate in candidates) {
+ for (ClassEntity candidate in candidates) {
bool isInstantiatedStrictSubclass(cls) =>
cls != candidate &&
closedWorld.isExplicitlyInstantiated(cls) &&
@@ -232,14 +233,14 @@
// Check we cover the base class.
if (!contains(flat.base, closedWorld)) return false;
// Check for other members.
- Iterable<Entity> members;
+ Iterable<ClassEntity> members;
if (flat.isSubclass) {
members = closedWorld.strictSubclassesOf(flat.base);
} else {
assert(flat.isSubtype);
members = closedWorld.strictSubtypesOf(flat.base);
}
- return members.every((Entity cls) => this.contains(cls, closedWorld));
+ return members.every((ClassEntity cls) => this.contains(cls, closedWorld));
}
bool isInMask(TypeMask other, ClosedWorld closedWorld) {
@@ -307,15 +308,15 @@
return disjointMasks.every((mask) => mask.containsOnlyString(closedWorld));
}
- bool containsOnly(Entity element) {
+ bool containsOnly(ClassEntity element) {
return disjointMasks.every((mask) => mask.containsOnly(element));
}
- bool satisfies(Entity cls, ClosedWorld closedWorld) {
+ bool satisfies(ClassEntity cls, ClosedWorld closedWorld) {
return disjointMasks.every((mask) => mask.satisfies(cls, closedWorld));
}
- bool contains(Entity cls, ClosedWorld closedWorld) {
+ bool contains(ClassEntity cls, ClosedWorld closedWorld) {
return disjointMasks.any((e) => e.contains(cls, closedWorld));
}
@@ -323,7 +324,7 @@
return disjointMasks.any((mask) => mask.containsAll(closedWorld));
}
- Entity singleClass(ClosedWorld closedWorld) => null;
+ ClassEntity singleClass(ClosedWorld closedWorld) => null;
bool needsNoSuchMethodHandling(Selector selector, ClosedWorld closedWorld) {
return disjointMasks
@@ -331,15 +332,14 @@
}
bool canHit(
- MemberElement element, Selector selector, ClosedWorld closedWorld) {
+ MemberEntity element, Selector selector, ClosedWorld closedWorld) {
return disjointMasks.any((e) => e.canHit(element, selector, closedWorld));
}
- MemberElement locateSingleElement(
- Selector selector, ClosedWorld closedWorld) {
- MemberElement candidate;
+ MemberEntity locateSingleElement(Selector selector, ClosedWorld closedWorld) {
+ MemberEntity candidate;
for (FlatTypeMask mask in disjointMasks) {
- MemberElement current = mask.locateSingleElement(selector, closedWorld);
+ MemberEntity current = mask.locateSingleElement(selector, closedWorld);
if (current == null) {
return null;
} else if (candidate == null) {
diff --git a/pkg/compiler/lib/src/universe/function_set.dart b/pkg/compiler/lib/src/universe/function_set.dart
index 385e89c..3dc566a 100644
--- a/pkg/compiler/lib/src/universe/function_set.dart
+++ b/pkg/compiler/lib/src/universe/function_set.dart
@@ -295,7 +295,7 @@
if (_mask != null) return _mask;
return _mask = new TypeMask.unionOf(
functions.expand((MemberElement element) {
- ClassEntity cls = element.enclosingClass.declaration;
+ ClassEntity cls = element.enclosingClass;
return [cls]..addAll(closedWorld.mixinUsesOf(cls));
}).map((cls) {
if (closedWorld.backendClasses.nullImplementation == cls) {
diff --git a/pkg/compiler/lib/src/universe/world_builder.dart b/pkg/compiler/lib/src/universe/world_builder.dart
index 651d62a..8302d84 100644
--- a/pkg/compiler/lib/src/universe/world_builder.dart
+++ b/pkg/compiler/lib/src/universe/world_builder.dart
@@ -159,8 +159,8 @@
/// All types that are checked either through is, as or checked mode checks.
Iterable<ResolutionDartType> get isChecks;
- /// Registers that [type] is checked in this universe. The unaliased type is
- /// returned.
+ /// Registers that [type] is checked in this world builder. The unaliased type
+ /// is returned.
ResolutionDartType registerIsCheck(ResolutionDartType type);
/// All directly instantiated types, that is, the types of the directly
@@ -1069,7 +1069,7 @@
return _closedWorldCache = new ClosedWorldImpl(
backend: _backend,
commonElements: commonElements,
- resolverWorld: this,
+ resolutionWorldBuilder: this,
functionSetBuilder: _allFunctions,
allTypedefs: _allTypedefs,
mixinUses: _mixinUses,
diff --git a/pkg/compiler/lib/src/use_unused_api.dart b/pkg/compiler/lib/src/use_unused_api.dart
index de79fb6..ddd2685 100644
--- a/pkg/compiler/lib/src/use_unused_api.dart
+++ b/pkg/compiler/lib/src/use_unused_api.dart
@@ -157,7 +157,7 @@
..asSwitchStatement()
..asSyncForIn()
..asTryStatement()
- ..asTypeAnnotation()
+ ..asNominalTypeAnnotation()
..asTypeVariable()
..asTypedef()
..asWhile()
diff --git a/pkg/compiler/lib/src/world.dart b/pkg/compiler/lib/src/world.dart
index 845e568..7f5039d 100644
--- a/pkg/compiler/lib/src/world.dart
+++ b/pkg/compiler/lib/src/world.dart
@@ -160,6 +160,27 @@
/// Returns an iterable over the common supertypes of the [classes].
Iterable<ClassEntity> commonSupertypesOf(Iterable<ClassEntity> classes);
+ /// Returns an iterable of the classes that are contained in the
+ /// strict subclass/subtype sets of both [cls1] and [cls2].
+ ///
+ /// Classes that are implied by included superclasses/supertypes are not
+ /// returned.
+ ///
+ /// For instance for this hierarchy
+ ///
+ /// class A {}
+ /// class B {}
+ /// class C implements A, B {}
+ /// class D extends C {}
+ ///
+ /// the query
+ ///
+ /// commonSubclasses(A, ClassQuery.SUBTYPE, B, ClassQuery.SUBTYPE)
+ ///
+ /// return the set {C} because [D] is implied by [C].
+ Iterable<ClassEntity> commonSubclasses(ClassElement cls1, ClassQuery query1,
+ ClassElement cls2, ClassQuery query2);
+
/// Returns an iterable over the live mixin applications that mixin [cls].
Iterable<ClassEntity> mixinUsesOf(ClassEntity cls);
@@ -403,7 +424,7 @@
ClosedWorldImpl(
{JavaScriptBackend backend,
this.commonElements,
- ResolutionWorldBuilder resolverWorld,
+ ResolutionWorldBuilder resolutionWorldBuilder,
FunctionSetBuilder functionSetBuilder,
Iterable<TypedefElement> allTypedefs,
Map<ClassElement, Set<MixinApplicationElement>> mixinUses,
@@ -411,7 +432,7 @@
Map<ClassElement, ClassHierarchyNode> classHierarchyNodes,
Map<ClassElement, ClassSet> classSets})
: this._backend = backend,
- this._resolverWorld = resolverWorld,
+ this._resolverWorld = resolutionWorldBuilder,
this._allTypedefs = allTypedefs,
this._mixinUses = mixinUses,
this._typesImplementedBySubclasses = typesImplementedBySubclasses,
@@ -748,6 +769,58 @@
return commonSupertypes;
}
+ Iterable<ClassElement> commonSubclasses(ClassElement cls1, ClassQuery query1,
+ ClassElement cls2, ClassQuery query2) {
+ // TODO(johnniwinther): Use [ClassSet] to compute this.
+ // Compute the set of classes that are contained in both class subsets.
+ Set<ClassEntity> common =
+ _commonContainedClasses(cls1, query1, cls2, query2);
+ if (common == null || common.isEmpty) return const <ClassElement>[];
+ // Narrow down the candidates by only looking at common classes
+ // that do not have a superclass or supertype that will be a
+ // better candidate.
+ return common.where((ClassElement each) {
+ bool containsSuperclass = common.contains(each.supertype.element);
+ // If the superclass is also a candidate, then we don't want to
+ // deal with this class. If we're only looking for a subclass we
+ // know we don't have to look at the list of interfaces because
+ // they can never be in the common set.
+ if (containsSuperclass ||
+ query1 == ClassQuery.SUBCLASS ||
+ query2 == ClassQuery.SUBCLASS) {
+ return !containsSuperclass;
+ }
+ // Run through the direct supertypes of the class. If the common
+ // set contains the direct supertype of the class, we ignore the
+ // the class because the supertype is a better candidate.
+ for (Link link = each.interfaces; !link.isEmpty; link = link.tail) {
+ if (common.contains(link.head.element)) return false;
+ }
+ return true;
+ });
+ }
+
+ Set<ClassElement> _commonContainedClasses(ClassElement cls1,
+ ClassQuery query1, ClassElement cls2, ClassQuery query2) {
+ Iterable<ClassElement> xSubset = _containedSubset(cls1, query1);
+ if (xSubset == null) return null;
+ Iterable<ClassElement> ySubset = _containedSubset(cls2, query2);
+ if (ySubset == null) return null;
+ return xSubset.toSet().intersection(ySubset.toSet());
+ }
+
+ Iterable<ClassElement> _containedSubset(ClassElement cls, ClassQuery query) {
+ switch (query) {
+ case ClassQuery.EXACT:
+ return null;
+ case ClassQuery.SUBCLASS:
+ return strictSubclassesOf(cls);
+ case ClassQuery.SUBTYPE:
+ return strictSubtypesOf(cls);
+ }
+ throw new ArgumentError('Unexpected query: $query.');
+ }
+
/// Returns an iterable over the live mixin applications that mixin [cls].
Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls) {
assert(isClosed);
diff --git a/pkg/dart2js_incremental/lib/caching_compiler.dart b/pkg/dart2js_incremental/lib/caching_compiler.dart
index 44d56a6..4b530c8 100644
--- a/pkg/dart2js_incremental/lib/caching_compiler.dart
+++ b/pkg/dart2js_incremental/lib/caching_compiler.dart
@@ -74,7 +74,7 @@
return compiler.libraryLoader.loadLibrary(core).then((_) {
// Likewise, always be prepared for runtimeType support.
// TODO(johnniwinther): Add global switch to force RTI.
- compiler.resolverWorld.hasRuntimeTypeSupport = true;
+ compiler.resolutionWorldBuilder.hasRuntimeTypeSupport = true;
compiler.enqueuer.resolution.applyImpact(backend.registerRuntimeType());
return compiler;
});
diff --git a/pkg/dev_compiler/lib/js/legacy/dart_library.js b/pkg/dev_compiler/lib/js/legacy/dart_library.js
index f72cf9e..3b89a88 100644
--- a/pkg/dev_compiler/lib/js/legacy/dart_library.js
+++ b/pkg/dev_compiler/lib/js/legacy/dart_library.js
@@ -4,8 +4,9 @@
/* This file defines the module loader for the dart runtime.
*/
-
-var dart_library =
+var dart_library;
+if (!dart_library) {
+dart_library =
typeof module != "undefined" && module.exports || {};
(function (dart_library) {
@@ -93,7 +94,12 @@
};
function library(name, defaultValue, imports, loader) {
- let result = new LibraryLoader(name, defaultValue, imports, loader);
+ let result = libraries.get(name);
+ if (result) {
+ console.warn('Already loaded ' + name);
+ return result;
+ }
+ result = new LibraryLoader(name, defaultValue, imports, loader);
libraries.set(name, result);
return result;
}
@@ -109,11 +115,20 @@
}
dart_library.import = import_;
+ var _currentIsolate = false;
+
function start(moduleName, libraryName) {
if (libraryName == null) libraryName = moduleName;
let library = import_(moduleName)[libraryName];
let dart_sdk = import_('dart_sdk');
- dart_sdk._isolate_helper.startRootIsolate(library.main, []);
+ if (!_currentIsolate) {
+ // Create isolate and run main.
+ _currentIsolate = true;
+ dart_sdk._isolate_helper.startRootIsolate(library.main, []);
+ } else {
+ // Main isolate is already initialized - just run main.
+ library.main();
+ }
}
dart_library.start = start;
@@ -179,3 +194,4 @@
}
})(dart_library);
+}
diff --git a/pkg/dev_compiler/test/browser/language_tests.js b/pkg/dev_compiler/test/browser/language_tests.js
index 4e1a6ad..694ee01 100644
--- a/pkg/dev_compiler/test/browser/language_tests.js
+++ b/pkg/dev_compiler/test/browser/language_tests.js
@@ -8,7 +8,7 @@
async_helper = async_helper.async_helper;
let minitest = expect.minitest;
-
+ let mochaOnError = window.onerror;
dart_sdk.dart.trapRuntimeErrors(false);
dart_sdk._isolate_helper.startRootIsolate(function() {}, []);
let html_config = unittest.html_config;
@@ -26,7 +26,6 @@
// Common combinations:
const pass = 'pass';
const fail = 'fail';
- const skip_fail = ['skip', 'fail'];
const skip_timeout = ['skip', 'timeout'];
// Browsers
@@ -48,126 +47,103 @@
// TODO(jmesserly): separate StrongModeError from other errors.
let all_status = {
'language': {
- 'assert_with_type_test_or_cast_test': skip_fail,
- 'assertion_test': skip_fail,
+ 'assertion_test': fail,
'async_await_test_none_multi': 'unittest',
'async_await_test_02_multi': 'unittest',
// Flaky on travis (https://github.com/dart-lang/sdk/issues/27224)
- 'async_await_test_03_multi': skip_fail,
+ 'async_await_test_03_multi': async_unittest,
- 'async_star_await_pauses_test': skip_fail,
+ 'async_star_await_pauses_test': skip_timeout,
// TODO(jmesserly): figure out why this test is hanging.
'async_star_cancel_and_throw_in_finally_test': skip_timeout,
- 'async_star_cancel_while_paused_test': skip_fail,
- 'async_star_regression_fisk_test': skip_fail,
+ 'async_star_cancel_while_paused_test': fail,
// TODO(vsm): Re-enable (https://github.com/dart-lang/sdk/issues/28319)
- 'async_star_test_none_multi': ['unittest', 'skip', 'fail'],
- 'async_star_test_01_multi': ['unittest', 'skip', 'fail'],
- 'async_star_test_02_multi': ['unittest', 'skip', 'fail'],
- 'async_star_test_03_multi': ['unittest', 'skip', 'fail'],
- 'async_star_test_04_multi': ['unittest', 'skip', 'fail'],
- 'async_star_test_05_multi': ['unittest', 'skip', 'fail'],
+ 'async_star_test_none_multi': async_unittest,
+ 'async_star_test_01_multi': async_unittest,
+ 'async_star_test_02_multi': async_unittest,
+ 'async_star_test_03_multi': async_unittest,
+ 'async_star_test_04_multi': async_unittest,
+ 'async_star_test_05_multi': async_unittest,
- 'async_switch_test': skip_fail,
- 'asyncstar_throw_in_catch_test': skip_fail,
- 'await_future_test': skip_fail,
- 'bit_operations_test_none_multi': skip_fail, // DDC/dart2js canonicalize bitop results to unsigned
- 'bool_test': skip_fail,
- 'branch_canonicalization_test': skip_fail, // JS bit operations truncate to 32 bits.
+ 'async_switch_test': fail,
+ 'asyncstar_throw_in_catch_test': fail,
+ 'await_future_test': skip_timeout,
+ 'bit_operations_test_none_multi': fail, // DDC/dart2js canonicalize bitop results to unsigned
+ 'branch_canonicalization_test': fail, // JS bit operations truncate to 32 bits.
'call_closurization_test': fail, // Functions do not expose a "call" method.
'call_function_apply_test': fail, // Function.apply not really implemented.
'call_through_null_getter_test': fail, // null errors are not converted to NoSuchMethodErrors.
'call_with_no_such_method_test': fail, // Function.apply not really implemented.
- 'canonical_const2_test': skip_fail,
- 'canonical_const_test': skip_fail,
- 'cascade_precedence_test': skip_fail,
- 'cast_test_01_multi': skip_fail,
- 'cast_test_02_multi': skip_fail,
- 'cast_test_03_multi': skip_fail,
- 'cast_test_07_multi': skip_fail,
- 'cast_test_10_multi': skip_fail,
- 'cast_test_12_multi': skip_fail,
- 'cast_test_13_multi': skip_fail,
- 'cast_test_14_multi': skip_fail,
- 'cast_test_15_multi': skip_fail,
- 'cha_deopt1_test': skip_fail,
- 'cha_deopt2_test': skip_fail,
- 'cha_deopt3_test': skip_fail,
- 'class_syntax2_test': skip_fail,
- 'classes_static_method_clash_test': skip_fail,
- 'closure_call_wrong_argument_count_negative_test': skip_fail,
- 'closure_in_constructor_test': skip_fail,
- 'closures_initializer_test': skip_fail,
- 'code_after_try_is_executed_test_01_multi': skip_fail,
- 'compile_time_constant10_test_none_multi': skip_fail,
- 'compile_time_constant_a_test': skip_fail,
- 'compile_time_constant_b_test': skip_fail,
- 'compile_time_constant_d_test': skip_fail,
- 'compile_time_constant_i_test': skip_fail,
- 'compile_time_constant_k_test_none_multi': skip_fail,
- 'compile_time_constant_o_test_none_multi': skip_fail,
- 'const_constructor3_test_03_multi': skip_fail,
- 'const_escape_frog_test': skip_fail,
- 'const_evaluation_test_01_multi': skip_fail,
- 'const_switch_test_02_multi': skip_fail,
- 'const_switch_test_04_multi': skip_fail,
- 'constructor11_test': skip_fail,
- 'constructor12_test': skip_fail,
- 'custom_await_stack_trace_test': skip_fail,
- 'cyclic_type2_test': skip_fail,
- 'cyclic_type_test_00_multi': skip_fail,
- 'cyclic_type_test_01_multi': skip_fail,
- 'cyclic_type_test_02_multi': skip_fail,
- 'cyclic_type_test_03_multi': skip_fail,
- 'cyclic_type_test_04_multi': skip_fail,
- 'cyclic_type_variable_test_none_multi': skip_fail,
+ 'canonical_const2_test': fail,
+ 'canonical_const_test': fail,
+ 'cast_test_01_multi': fail,
+ 'cast_test_02_multi': fail,
+ 'cast_test_03_multi': fail,
+ 'cast_test_07_multi': fail,
+ 'cast_test_10_multi': fail,
+ 'cast_test_12_multi': fail,
+ 'cast_test_13_multi': fail,
+ 'cast_test_14_multi': fail,
+ 'cast_test_15_multi': fail,
+ 'classes_static_method_clash_test': fail,
+ 'code_after_try_is_executed_test_01_multi': fail,
+ 'compile_time_constant10_test_none_multi': fail,
+ 'compile_time_constant_a_test': fail,
+ 'compile_time_constant_b_test': fail,
+ 'compile_time_constant_d_test': fail,
+ 'compile_time_constant_k_test_none_multi': fail,
+ 'compile_time_constant_o_test_none_multi': fail,
+ 'const_evaluation_test_01_multi': fail,
+ 'const_switch_test_02_multi': fail,
+ 'const_switch_test_04_multi': fail,
+ 'constructor12_test': fail,
+ 'cyclic_type2_test': fail,
+ 'cyclic_type_test_00_multi': fail,
+ 'cyclic_type_test_01_multi': fail,
+ 'cyclic_type_test_02_multi': fail,
+ 'cyclic_type_test_03_multi': fail,
+ 'cyclic_type_test_04_multi': fail,
// Deferred libraries are not actually deferred. These tests all test
// that synchronous access to the library fails.
- 'deferred_call_empty_before_load_test': skip_fail,
- 'deferred_not_loaded_check_test': skip_fail,
- 'deferred_redirecting_factory_test': skip_fail,
- 'deferred_static_seperate_test': skip_fail,
+ 'deferred_call_empty_before_load_test': fail,
+ 'deferred_not_loaded_check_test': fail,
+ 'deferred_redirecting_factory_test': fail,
+ 'deferred_static_seperate_test': fail,
- 'deferred_regression_22995_test': skip_fail, // Strong mode "is" rejects some type tests.
- 'double_int_to_string_test': skip_fail,
- 'double_to_string_test': skip_fail,
- 'dynamic_test': skip_fail,
- 'enum_mirror_test': skip_fail,
+ 'deferred_regression_22995_test': fail, // Strong mode "is" rejects some type tests.
+ 'double_int_to_string_test': fail,
+ 'dynamic_test': fail,
'exception_test': fail,
- 'execute_finally6_test': skip_fail,
- 'expect_test': skip_fail,
- 'extends_test_lib': skip_fail,
- 'external_test_10_multi': skip_fail,
- 'external_test_13_multi': skip_fail,
- 'external_test_20_multi': skip_fail,
- 'f_bounded_quantification3_test': skip_fail,
- 'factory_type_parameter_test': skip_fail,
- 'fast_method_extraction_test': skip_fail,
+ 'execute_finally6_test': fail,
+ 'expect_test': fail,
+ 'extends_test_lib': fail,
+ 'external_test_10_multi': fail,
+ 'external_test_13_multi': fail,
+ 'external_test_20_multi': fail,
+ 'f_bounded_quantification3_test': fail,
+ 'fast_method_extraction_test': fail,
'field_increment_bailout_test': fail,
- 'field_optimization3_test': skip_fail,
- 'final_syntax_test_08_multi': skip_fail,
- 'first_class_types_test': skip_fail,
- 'flatten_test_01_multi': skip_fail,
- 'flatten_test_04_multi': skip_fail,
- 'for_in2_test': skip_fail,
- 'for_variable_capture_test': skip_fail,
- 'function_subtype0_test': skip_fail,
- 'function_subtype1_test': skip_fail,
- 'function_subtype2_test': skip_fail,
- 'function_subtype3_test': skip_fail,
- 'function_subtype_bound_closure0_test': skip_fail,
- 'function_subtype_bound_closure1_test': skip_fail,
- 'function_subtype_bound_closure2_test': skip_fail,
- 'function_subtype_bound_closure3_test': skip_fail,
- 'function_subtype_bound_closure4_test': skip_fail,
- 'function_subtype_bound_closure5_test': skip_fail,
- 'function_subtype_bound_closure5a_test': skip_fail,
- 'function_subtype_bound_closure6_test': skip_fail,
+ 'field_optimization3_test': fail,
+ 'final_syntax_test_08_multi': fail,
+ 'first_class_types_test': fail,
+ 'for_variable_capture_test': chrome_fail,
+ 'function_subtype0_test': fail,
+ 'function_subtype1_test': fail,
+ 'function_subtype2_test': fail,
+ 'function_subtype3_test': fail,
+ 'function_subtype_bound_closure0_test': fail,
+ 'function_subtype_bound_closure1_test': fail,
+ 'function_subtype_bound_closure2_test': fail,
+ 'function_subtype_bound_closure3_test': fail,
+ 'function_subtype_bound_closure4_test': fail,
+ 'function_subtype_bound_closure5_test': fail,
+ 'function_subtype_bound_closure5a_test': fail,
+ 'function_subtype_bound_closure6_test': fail,
'function_subtype_call0_test': fail, // Strong mode "is" rejects some type tests.
'function_subtype_call1_test': fail,
'function_subtype_call2_test': fail,
@@ -175,157 +151,118 @@
'function_subtype_cast1_test': fail,
'function_subtype_cast2_test': fail,
'function_subtype_cast3_test': fail,
- 'function_subtype_factory0_test': skip_fail,
- 'function_subtype_inline0_test': skip_fail,
- 'function_subtype_local0_test': skip_fail,
- 'function_subtype_local1_test': skip_fail,
- 'function_subtype_local2_test': skip_fail,
- 'function_subtype_local3_test': skip_fail,
- 'function_subtype_local4_test': skip_fail,
- 'function_subtype_local5_test': skip_fail,
- 'function_subtype_named1_test': skip_fail,
- 'function_subtype_named2_test': skip_fail,
- 'function_subtype_not0_test': skip_fail,
- 'function_subtype_not1_test': skip_fail,
- 'function_subtype_not2_test': skip_fail,
- 'function_subtype_not3_test': skip_fail,
- 'function_subtype_optional1_test': skip_fail,
- 'function_subtype_optional2_test': skip_fail,
- 'function_subtype_top_level0_test': skip_fail,
- 'function_subtype_top_level1_test': skip_fail,
- 'function_subtype_typearg0_test': skip_fail,
- 'function_subtype_typearg2_test': skip_fail,
- 'function_subtype_typearg4_test': skip_fail,
- 'function_type_alias2_test': skip_fail,
- 'function_type_alias3_test': skip_fail,
- 'function_type_alias4_test': skip_fail,
- 'function_type_alias6_test_none_multi': skip_fail,
- 'gc_test': skip_fail,
- 'generic_field_mixin2_test': skip_fail,
- 'generic_field_mixin3_test': skip_fail,
- 'generic_field_mixin4_test': skip_fail,
- 'generic_field_mixin5_test': skip_fail,
- 'generic_field_mixin_test': skip_fail,
+ 'function_subtype_factory0_test': fail,
+ 'function_subtype_inline0_test': fail,
+ 'function_subtype_local0_test': fail,
+ 'function_subtype_local1_test': fail,
+ 'function_subtype_local2_test': fail,
+ 'function_subtype_local3_test': fail,
+ 'function_subtype_local4_test': fail,
+ 'function_subtype_local5_test': fail,
+ 'function_subtype_named1_test': fail,
+ 'function_subtype_named2_test': fail,
+ 'function_subtype_not0_test': fail,
+ 'function_subtype_not1_test': fail,
+ 'function_subtype_not2_test': fail,
+ 'function_subtype_not3_test': fail,
+ 'function_subtype_optional1_test': fail,
+ 'function_subtype_optional2_test': fail,
+ 'function_subtype_top_level0_test': fail,
+ 'function_subtype_top_level1_test': fail,
+ 'function_subtype_typearg2_test': fail,
+ 'function_subtype_typearg4_test': fail,
+ 'function_type_alias2_test': fail,
+ 'function_type_alias3_test': fail,
+ 'function_type_alias4_test': fail,
+ 'function_type_alias6_test_none_multi': fail,
'generic_instanceof_test': fail, // runtime strong mode reject
- 'generic_instanceof2_test': skip_fail,
- 'generic_is_check_test': skip_fail,
- 'getter_closure_execution_order_test': skip_fail,
- 'hash_code_mangling_test': skip_fail,
- 'identical_closure2_test': skip_fail,
- 'infinite_switch_label_test': skip_fail,
- 'infinity_test': skip_fail,
- 'initializing_formal_final_test': skip_fail,
- 'instance_creation_in_function_annotation_test': skip_fail,
+ 'generic_instanceof2_test': fail,
+ 'generic_is_check_test': fail,
+ 'getter_closure_execution_order_test': fail,
+ 'hash_code_mangling_test': fail,
+ 'identical_closure2_test': fail,
+ 'infinite_switch_label_test': fail,
+ 'infinity_test': fail,
+ 'initializing_formal_final_test': fail,
+ 'instance_creation_in_function_annotation_test': fail,
'instanceof2_test': fail,
'instanceof4_test_01_multi': fail,
'instanceof4_test_none_multi': fail,
- 'instanceof_optimized_test': skip_fail,
+ 'instanceof_optimized_test': fail,
'integer_division_by_zero_test': fail,
'is_nan_test': fail,
- 'issue10747_test': skip_fail,
- 'issue13179_test': skip_fail,
- 'issue21079_test': skip_fail,
- 'issue21957_test': skip_fail,
- 'issue23244_test': skip_fail,
- 'issue_1751477_test': skip_fail,
- 'issue_22780_test_01_multi': skip_fail,
- 'issue_23914_test': skip_fail,
- 'js_properties_test': skip_fail,
- 'lazy_static3_test': skip_fail,
- 'least_upper_bound_expansive_test_none_multi': skip_fail,
- 'left_shift_test': skip_fail,
- 'list_is_test': skip_fail,
- 'list_literal3_test': skip_fail,
- 'many_generic_instanceof_test': skip_fail,
- 'map_literal10_test': skip_fail,
- 'map_literal7_test': skip_fail,
- 'memory_swap_test': skip_fail,
- 'method_invocation_test': skip_fail,
- 'mint_arithmetic_test': skip_fail,
- 'mixin_forwarding_constructor3_test': skip_fail,
- 'mixin_generic_test': skip_fail,
- 'mixin_implements_test': skip_fail,
- 'mixin_invalid_inheritance1_test_none_multi': skip_fail,
- 'mixin_issue10216_2_test': skip_fail,
- 'mixin_mixin2_test': skip_fail,
- 'mixin_mixin3_test': skip_fail,
- 'mixin_mixin4_test': skip_fail,
- 'mixin_mixin5_test': skip_fail,
- 'mixin_mixin6_test': skip_fail,
- 'mixin_mixin7_test': skip_fail,
- 'mixin_mixin_bound2_test': skip_fail,
- 'mixin_mixin_bound_test': skip_fail,
- 'mixin_mixin_test': skip_fail,
- 'mixin_regress_13688_test': skip_fail,
- 'mixin_type_parameter1_test': skip_fail,
- 'mixin_type_parameter2_test': skip_fail,
- 'mixin_type_parameter3_test': skip_fail,
+ 'issue_22780_test_01_multi': fail,
+ 'lazy_static3_test': fail,
+ 'least_upper_bound_expansive_test_none_multi': fail,
+ 'left_shift_test': fail,
+ 'list_is_test': fail,
+ 'list_literal3_test': fail,
+ 'many_generic_instanceof_test': fail,
+ 'map_literal10_test': fail,
+ 'map_literal7_test': fail,
+ 'method_invocation_test': fail,
+ 'mint_arithmetic_test': fail,
+ 'mixin_forwarding_constructor3_test': fail,
+ 'mixin_implements_test': fail,
+ 'mixin_issue10216_2_test': fail,
+ 'mixin_mixin2_test': fail,
+ 'mixin_mixin3_test': fail,
+ 'mixin_mixin4_test': fail,
+ 'mixin_mixin5_test': fail,
+ 'mixin_mixin6_test': fail,
+ 'mixin_mixin7_test': fail,
+ 'mixin_mixin_bound2_test': fail,
+ 'mixin_mixin_bound_test': fail,
+ 'mixin_mixin_test': fail,
+ 'mixin_regress_13688_test': fail,
'modulo_test': fail,
- 'named_parameter_clash_test': skip_fail,
+ 'named_parameter_clash_test': fail,
'named_parameters_passing_falsy_test': firefox_fail,
- 'nan_identical_test': skip_fail,
- 'nested_switch_label_test': skip_fail,
- 'number_identifier_test_05_multi': skip_fail,
- 'number_identity2_test': skip_fail,
- 'numbers_test': skip_fail,
- 'optimized_hoisting_checked_mode_assert_test': skip_fail,
- 'redirecting_factory_reflection_test': skip_fail,
- 'regress_13462_0_test': skip_fail,
- 'regress_13462_1_test': skip_fail,
- 'regress_14105_test': skip_fail,
- 'regress_16640_test': skip_fail,
+ 'nan_identical_test': fail,
+ 'nested_switch_label_test': fail,
+ 'number_identifier_test_05_multi': fail,
+ 'number_identity2_test': fail,
+ 'numbers_test': fail,
+ 'redirecting_factory_reflection_test': fail,
+ 'regress_16640_test': fail,
'regress_18535_test': fail,
- 'regress_21795_test': skip_fail,
- 'regress_22443_test': skip_fail,
- 'regress_22666_test': skip_fail,
- 'setter_no_getter_test_01_multi': skip_fail,
- 'stack_overflow_stacktrace_test': skip_fail,
- 'stack_overflow_test': skip_fail,
- 'stacktrace_rethrow_error_test_none_multi': skip_fail,
- 'stacktrace_rethrow_error_test_withtraceparameter_multi': skip_fail,
- 'stacktrace_test': skip_fail,
- 'string_interpolate_null_test': skip_fail,
- 'super_operator_index3_test': skip_fail,
- 'super_operator_index4_test': skip_fail,
- 'switch_label2_test': skip_fail,
- 'switch_label_test': skip_fail,
- 'switch_try_catch_test': skip_fail,
- 'sync_generator1_test_none_multi': skip_fail,
- 'throwing_lazy_variable_test': skip_fail,
- 'top_level_non_prefixed_library_test': skip_fail,
+ 'regress_22666_test': fail,
+ 'regress_22777_test': fail,
+ 'setter_no_getter_test_01_multi': fail,
+ 'stack_overflow_stacktrace_test': fail,
+ 'stack_overflow_test': fail,
+ 'stacktrace_rethrow_error_test_none_multi': fail,
+ 'stacktrace_rethrow_error_test_withtraceparameter_multi': fail,
+ 'stacktrace_test': chrome_fail,
+ 'string_interpolate_null_test': fail,
+ 'switch_label2_test': fail,
+ 'switch_label_test': fail,
+ 'switch_try_catch_test': fail,
+ 'throwing_lazy_variable_test': fail,
'truncdiv_test': fail, // did not throw
- 'type_variable_nested_test': skip_fail, // unsound is-check
- 'type_variable_typedef_test': skip_fail, // unsound is-check
+ 'type_variable_nested_test': fail, // unsound is-check
+ 'type_variable_typedef_test': fail, // unsound is-check
- 'bit_operations_test_01_multi': skip_fail,
- 'bit_operations_test_02_multi': skip_fail,
- 'bit_operations_test_03_multi': skip_fail,
- 'bit_operations_test_04_multi': skip_fail,
- 'bool_condition_check_test_01_multi': skip_fail,
- 'deferred_constraints_constants_test_none_multi': skip_fail,
- 'deferred_constraints_constants_test_reference_after_load_multi': skip_fail,
- 'deferred_constraints_type_annotation_test_new_generic1_multi': skip_fail,
- 'deferred_constraints_type_annotation_test_new_multi': skip_fail,
- 'deferred_constraints_type_annotation_test_none_multi': skip_fail,
- 'deferred_constraints_type_annotation_test_static_method_multi': skip_fail,
- 'deferred_constraints_type_annotation_test_type_annotation_non_deferred_multi': skip_fail,
- 'deferred_load_constants_test_none_multi': skip_fail,
- 'deferred_load_library_wrong_args_test_01_multi': skip_fail,
- 'deferred_load_library_wrong_args_test_none_multi': skip_fail,
- 'external_test_21_multi': skip_fail,
- 'external_test_24_multi': skip_fail,
- 'main_not_a_function_test_01_multi': skip_fail,
- 'multiline_newline_test_04_multi': skip_fail,
- 'multiline_newline_test_05_multi': skip_fail,
- 'multiline_newline_test_06_multi': skip_fail,
- 'multiline_newline_test_none_multi': skip_fail,
- 'no_main_test_01_multi': skip_fail,
+ 'bit_operations_test_01_multi': fail,
+ 'bit_operations_test_02_multi': fail,
+ 'bit_operations_test_03_multi': fail,
+ 'bit_operations_test_04_multi': fail,
+ 'bool_condition_check_test_01_multi': fail,
+ 'deferred_load_constants_test_none_multi': fail,
+ 'external_test_21_multi': fail,
+ 'external_test_24_multi': fail,
+ 'main_not_a_function_test_01_multi': fail,
+ 'multiline_newline_test_04_multi': fail,
+ 'multiline_newline_test_05_multi': fail,
+ 'multiline_newline_test_06_multi': fail,
+ 'multiline_newline_test_none_multi': fail,
+ 'no_main_test_01_multi': fail,
// https://github.com/dart-lang/sdk/issues/26123
- 'bad_raw_string_negative_test': skip_fail,
+ 'bad_raw_string_negative_test': fail,
// https://github.com/dart-lang/sdk/issues/26124
- 'prefix10_negative_test': skip_fail,
+ 'prefix10_negative_test': fail,
'library_prefixes_test1': 'helper',
'library_prefixes_test2': 'helper',
@@ -558,19 +495,17 @@
'lib/math': {
// TODO(het): triage
- 'double_pow_test': skip_fail,
- 'low_test': skip_fail,
- 'math_test': skip_fail,
- 'math2_test': skip_fail,
+ 'double_pow_test': fail,
+ 'low_test': fail,
'pi_test': skip_timeout,
- 'random_big_test': skip_fail,
+ 'random_big_test': fail,
},
'lib/typed_data': {
// No bigint or int64 support
- 'int32x4_bigint_test': skip_fail,
- 'int64_list_load_store_test': skip_fail,
- 'typed_data_hierarchy_int64_test': skip_fail,
+ 'int32x4_bigint_test': fail,
+ 'int64_list_load_store_test': fail,
+ 'typed_data_hierarchy_int64_test': fail,
'typed_data_list_test': fail,
},
@@ -694,7 +629,6 @@
'relation_assignable_test': fail,
'relation_subtype_test': fail,
'set_field_with_final_test': fail,
- 'spawn_function_root_library_test': skip_fail,
'symbol_validation_test_01_multi': fail,
'symbol_validation_test_none_multi': fail,
'to_string_test': fail,
@@ -702,7 +636,7 @@
'type_variable_is_static_test': fail,
'type_variable_owner_test_01_multi': fail,
'type_variable_owner_test_none_multi': fail,
- 'typedef_deferred_library_test': skip_fail, // Isolate spawn not support
+ 'typedef_deferred_library_test': fail, // Isolate spawn not support
'typedef_library_test': fail,
'typedef_metadata_test': fail,
'typedef_test': fail,
@@ -721,6 +655,7 @@
}
let unittest_tests = [];
+ let unittestAccidentallyInitialized = false;
let languageTestPattern =
new RegExp('gen/codegen_output/(.*)/([^/]*_test[^/]*)');
@@ -766,63 +701,125 @@
let protect = (f) => { // Returns the exception, or `null`.
try {
- f();
- return null;
+ return f();
} catch (e) {
return e;
}
};
test(name, function(done) { // 'function' to allow `this.timeout`.
- async_helper.asyncTestInitialize(done);
console.debug('Running test: ' + name);
- var result = null;
+ // Many tests are async. Currently, tests can indicate this in
+ // two different ways. First, `main` can call (in Dart)
+ // `async_helper.asyncStart`. We can check if this happened by
+ // querying `async_helper.asyncTestStarted` afterward and waiting for
+ // the callback if so. Second, `main` can return a `Future`. If so,
+ // we wait for that to complete. If neither is true, we assume the
+ // test is synchronous.
+ //
+ // A 'failing' test will throw an exception. This exception may be
+ // synchronous (i.e., during `main`) or asynchronous (after `main` in
+ // lieu of the callback/future). The latter exceptions are not
+ // directly caught. Instead, we intercept `window.onerror` to detect
+ // them.
+ //
+ // Note, if the test is marked 'negative' or 'fail', than pass and fail
+ // are effectively inverted: only a success is reported.
+ //
+ // In all cases, we funnel test completion through the `finish` handler
+ // below to handle reporting (based on status) and cleanup state.
+ //
+ // A test can finish in one of several ways:
+ // 1. Synchronous without an error. In this case, `main` returns
+ // null and did not set `async_helper`. `finish` is invoked
+ // immediately.
+ // 2. Synchronous error. `main` throws an error. `finish`
+ // is invoked immediately with the error.
+ // 3. `Future` without an error. In this case, the future completes
+ // and asynchronously invokes `finish`.
+ // 4. Via `async_helper` without an error. In this case, the
+ // `async_helper` library triggers `finish` via its callback.
+ // 5. Asynchronously with an error. In this case, `window.onerror`
+ // triggers `finish` with the error.
+ // 6. Hangs. In this case, we rely on the underlying mocha framework
+ // timeout.
+ //
+ // TODO(vsm): This currently doesn't handle tests that trigger multiple
+ // asynchronous exceptions.
+
let mainLibrary = require(module)[libraryName(name)];
let negative = /negative_test/.test(name);
- if (has('slow')) this.timeout(10000);
- if (has('fail')) {
- let e = protect(mainLibrary.main);
- if (negative) {
- if (e != null) {
- throw new Error(
- "negative test marked as 'fail' " +
- "but passed by throwing:\n" + e);
- }
- } else {
- if (e == null) {
- throw new Error("test marked as 'fail' but passed");
- }
- }
- } else {
- try {
+ let fail = has('fail');
+
+ function finish(error) {
+ // If the test left any lingering detritus in the DOM, blow it away
+ // so it doesn't interfere with later tests.
+ if (fail) {
if (negative) {
- assert.throws(mainLibrary.main);
+ if (error) {
+ error = new Error(
+ "negative test marked as 'fail' " +
+ "but passed by throwing:\n" + error);
+ }
+ } else if (error) {
+ error = null
} else {
- result = mainLibrary.main();
+ error = new Error("test marked as 'fail' but passed");
}
- } finally {
- minitest.finishTests();
+ } else if (negative) {
+ if (!error) {
+ error = new Error("test marked as 'negative' but did not throw");
+ } else {
+ error = null;
+ }
}
+ minitest.finishTests();
+ document.body.innerHTML = '';
+ console.log("cleared");
+ if (error && !(error instanceof Error)) error = new Error(error);
+ done(error);
}
- // If the test left any lingering detritus in the DOM, blow it away
- // so it doesn't interfere with later tests.
- document.body.innerHTML = '';
- console.log("cleared");
+ // Intercept uncaught exceptions
+ window.onerror = function(message, url, line, column, error) {
+ console.warn('Asynchronous error in ' + name + ': ' + message);
+ if (!error) {
+ error = new Error(message);
+ }
+ finish(error);
+ };
- if (!async_helper.asyncTestStarted) {
+ async_helper.asyncTestInitialize(finish);
+ if (has('slow')) this.timeout(10000);
+
+ var result;
+ try {
+ var result = mainLibrary.main();
+ if (result && !(result instanceof dart_sdk.async.Future)) {
+ result = null;
+ }
+ } catch (e) {
+ finish(e);
+ }
+
+ // Ensure this isn't a unittest
+ if (!unittestAccidentallyInitialized &&
+ unittest.src__test_environment.environment.initialized) {
+ // This suppresses duplicate messages for later tests
+ unittestAccidentallyInitialized = true;
+ finish(new Error('Test ' + name + ' must be marked as a unittest'));
+ } else if (!async_helper.asyncTestStarted) {
if (!result) {
- done();
+ finish();
} else {
- result.then(dart_sdk.dart.dynamic)(() => done());
+ result.then(dart_sdk.dart.dynamic)(() => finish());
}
}
});
}
}
- let mochaOnError;
// We run these tests in a mocha test wrapper to avoid the confusing failure
// case of dart unittests being interleaved with mocha tests.
// In practice we are really just suppressing all mocha test behavior while
@@ -847,7 +844,6 @@
this.timeout(100000000);
this.enableTimeouts(false);
// Suppress mocha on-error handling because it will mess up unittests.
- mochaOnError = window.onerror;
window.onerror = function(err, url, line) {
console.error(err, url, line);
};
diff --git a/pkg/dev_compiler/test/codegen_test.dart b/pkg/dev_compiler/test/codegen_test.dart
index 4c4446c..7ac885d 100644
--- a/pkg/dev_compiler/test/codegen_test.dart
+++ b/pkg/dev_compiler/test/codegen_test.dart
@@ -158,19 +158,29 @@
if (analyzerOptions.declaredVariables.isNotEmpty) {
compiler = new ModuleCompiler(analyzerOptions);
}
- var module = compiler.compile(unit, options);
+ JSModuleFile module = null;
+ try {
+ module = compiler.compile(unit, options);
+ } catch (e) {}
bool notStrong = notYetStrongTests.contains(name);
- if (module.isValid) {
+ bool crashing = _crashingTests.contains(name);
+
+ if (module == null) {
+ expect(crashing, isTrue,
+ reason: "test $name crashes during compilation.");
+ } else if (module.isValid) {
_writeModule(
path.join(codegenOutputDir, name),
isTopLevelTest ? path.join(codegenExpectDir, name) : null,
moduleFormat,
module);
+ expect(crashing, isFalse, reason: "test $name no longer crashes.");
expect(notStrong, isFalse,
reason: "test $name expected strong mode errors, but compiled.");
} else {
+ expect(crashing, isFalse, reason: "test $name no longer crashes.");
expect(notStrong, isTrue,
reason: "test $name failed to compile due to strong mode errors:"
"\n\n${module.errors.join('\n')}.");
@@ -365,3 +375,21 @@
? uriContent
: null;
}
+
+final _crashingTests = new Set<String>.from([
+ 'language/mixin_illegal_syntax_test_none_multi',
+ 'language/mixin_illegal_syntax_test_01_multi',
+ 'language/mixin_illegal_syntax_test_02_multi',
+ 'language/mixin_illegal_syntax_test_03_multi',
+ 'language/mixin_illegal_syntax_test_04_multi',
+ 'language/mixin_illegal_syntax_test_05_multi',
+ 'language/mixin_illegal_syntax_test_06_multi',
+ 'language/mixin_illegal_syntax_test_07_multi',
+ 'language/mixin_illegal_syntax_test_08_multi',
+ 'language/mixin_illegal_syntax_test_09_multi',
+ 'language/mixin_illegal_syntax_test_10_multi',
+ 'language/mixin_illegal_syntax_test_11_multi',
+ 'language/mixin_illegal_syntax_test_12_multi',
+ 'language/mixin_illegal_syntax_test_13_multi',
+ 'language/mixin_illegal_syntax_test_14_multi'
+]);
diff --git a/pkg/front_end/lib/physical_file_system.dart b/pkg/front_end/lib/physical_file_system.dart
index 757eb60..f90abc9 100644
--- a/pkg/front_end/lib/physical_file_system.dart
+++ b/pkg/front_end/lib/physical_file_system.dart
@@ -28,34 +28,28 @@
if (uri.scheme != 'file' && uri.scheme != '') {
throw new ArgumentError('File URI expected');
}
- // Note: we don't have to verify that the URI's path is absolute, because
- // URIs with non-empty schemes always have absolute paths.
- var path = context.fromUri(uri);
- return new _PhysicalFileSystemEntity(
- context.normalize(context.absolute(path)));
+ return new _PhysicalFileSystemEntity(Uri.base.resolveUri(uri));
}
}
/// Concrete implementation of [FileSystemEntity] for use by
/// [PhysicalFileSystem].
class _PhysicalFileSystemEntity implements FileSystemEntity {
- final String _path;
+ @override
+ final Uri uri;
- _PhysicalFileSystemEntity(this._path);
+ _PhysicalFileSystemEntity(this.uri);
@override
- int get hashCode => _path.hashCode;
-
- @override
- Uri get uri => p.toUri(_path);
+ int get hashCode => uri.hashCode;
@override
bool operator ==(Object other) =>
- other is _PhysicalFileSystemEntity && other._path == _path;
+ other is _PhysicalFileSystemEntity && other.uri == uri;
@override
- Future<List<int>> readAsBytes() => new io.File(_path).readAsBytes();
+ Future<List<int>> readAsBytes() => new io.File.fromUri(uri).readAsBytes();
@override
- Future<String> readAsString() => new io.File(_path).readAsString();
+ Future<String> readAsString() => new io.File.fromUri(uri).readAsString();
}
diff --git a/pkg/front_end/test/physical_file_system_test.dart b/pkg/front_end/test/physical_file_system_test.dart
index 2a8cbb6..d1a026b 100644
--- a/pkg/front_end/test/physical_file_system_test.dart
+++ b/pkg/front_end/test/physical_file_system_test.dart
@@ -120,14 +120,14 @@
test_entityForUri() {
expect(
PhysicalFileSystem.instance
- .entityForUri(Uri.parse('$tempUri/file.txt'))
+ .entityForUri(Uri.parse('${tempUri}file.txt'))
.uri,
p.toUri(p.join(tempPath, 'file.txt')));
}
test_entityForUri_bareUri_absolute() {
expect(PhysicalFileSystem.instance.entityForUri(Uri.parse('/file.txt')).uri,
- p.toUri(p.fromUri('/file.txt')));
+ Uri.parse('file:///file.txt'));
}
test_entityForUri_fileUri_relative() {
@@ -159,7 +159,7 @@
test_entityForUri_normalize_dot() {
expect(
PhysicalFileSystem.instance
- .entityForUri(Uri.parse('$tempUri/./file.txt'))
+ .entityForUri(Uri.parse('${tempUri}./file.txt'))
.uri,
p.toUri(p.join(tempPath, 'file.txt')));
}
@@ -167,7 +167,7 @@
test_entityForUri_normalize_dotDot() {
expect(
PhysicalFileSystem.instance
- .entityForUri(Uri.parse('$tempUri/foo/../file.txt'))
+ .entityForUri(Uri.parse('${tempUri}foo/../file.txt'))
.uri,
p.toUri(p.join(tempPath, 'file.txt')));
}
diff --git a/pkg/front_end/test/subpackage_relationships_test.dart b/pkg/front_end/test/subpackage_relationships_test.dart
new file mode 100644
index 0000000..9df8ff4
--- /dev/null
+++ b/pkg/front_end/test/subpackage_relationships_test.dart
@@ -0,0 +1,141 @@
+// Copyright (c) 2017, 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.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:front_end/compiler_options.dart';
+import 'package:front_end/dependency_grapher.dart';
+import 'package:path/path.dart' as pathos;
+
+main() async {
+ exit(await new _SubpackageRelationshipsTest().run());
+}
+
+/// Map from subpackage name to the rules for what the subpackage is allowed to
+/// depend directly on.
+///
+/// Each subdirectory of `lib/src` is considered a subpackage. Files in
+/// `lib/src` but not in a subdirectory are considered to be in the `lib/src`
+/// subpackage. Files outside of `lib/src` (but still in `lib`) are considered
+/// to be in the `lib` subpackage.
+///
+/// TODO(paulberry): stuff in lib/src shouldn't depend on lib; lib should just
+/// re-export stuff in lib/src.
+/// TODO(paulberry): remove dependencies on analyzer.
+final subpackageRules = {
+ 'lib': new SubpackageRules(
+ mayImportAnalyzer: true,
+ allowedDependencies: ['lib/src', 'lib/src/base']),
+ 'lib/src': new SubpackageRules(
+ mayImportAnalyzer: true,
+ allowedDependencies: ['lib', 'lib/src/base', 'lib/src/scanner']),
+ 'lib/src/base': new SubpackageRules(
+ mayImportAnalyzer: true, allowedDependencies: ['lib']),
+ 'lib/src/scanner': new SubpackageRules(allowedDependencies: ['lib/src/base']),
+};
+
+/// Rules for what a subpackage may depend directly on.
+class SubpackageRules {
+ /// Indicates whether the subpackage may directly depend on analyzer.
+ final bool mayImportAnalyzer;
+
+ /// Indicates which other subpackages a given subpackage may directly depend
+ /// on.
+ final List<String> allowedDependencies;
+
+ SubpackageRules(
+ {this.mayImportAnalyzer: false, this.allowedDependencies: const []});
+}
+
+class _SubpackageRelationshipsTest {
+ /// File uri of the front_end package's "lib" directory.
+ final frontEndLibUri = Platform.script.resolve('../lib/');
+
+ /// Indicates whether any problems have been reported yet.
+ bool problemsReported = false;
+
+ /// Check for problems resulting from URI [src] having a direct dependency on
+ /// URI [dst].
+ void checkDependency(Uri src, Uri dst) {
+ if (dst.scheme == 'dart') return;
+ if (dst.scheme != 'package') {
+ problem('$src depends on $dst, which is neither a package: or dart: URI');
+ return;
+ }
+ var srcSubpackage = subpackageForUri(src);
+ if (srcSubpackage == null) return;
+ var srcSubpackageRules = subpackageRules[srcSubpackage];
+ if (srcSubpackageRules == null) {
+ problem('$src is in subpackage "$srcSubpackage", which is not found in '
+ 'subpackageRules');
+ return;
+ }
+ if (!srcSubpackageRules.mayImportAnalyzer &&
+ dst.pathSegments[0] == 'analyzer') {
+ problem('$src depends on $dst, but subpackage "$srcSubpackage" may not '
+ 'import analyzer');
+ }
+ var dstSubPackage = subpackageForUri(dst);
+ if (dstSubPackage == null) return;
+ if (dstSubPackage == srcSubpackage) return;
+ if (!srcSubpackageRules.allowedDependencies.contains(dstSubPackage)) {
+ problem('$src depends on $dst, but subpackage "$srcSubpackage" is not '
+ 'allowed to depend on subpackage "$dstSubPackage"');
+ }
+ }
+
+ /// Finds all files in the front_end's "lib" directory and returns their Uris
+ /// (as "package:" URIs).
+ List<Uri> findFrontEndUris() {
+ var frontEndUris = <Uri>[];
+ var frontEndLibPath = pathos.fromUri(frontEndLibUri);
+ for (var entity in new Directory(frontEndLibPath)
+ .listSync(recursive: true, followLinks: false)) {
+ if (entity is File && entity.path.endsWith('.dart')) {
+ var posixRelativePath = pathos.url.joinAll(
+ pathos.split(pathos.relative(entity.path, from: frontEndLibPath)));
+ frontEndUris.add(Uri.parse('package:front_end/$posixRelativePath'));
+ }
+ }
+ return frontEndUris;
+ }
+
+ /// Reports a single problem.
+ void problem(String description) {
+ print(description);
+ problemsReported = true;
+ }
+
+ /// Tests all subpackage relationships in the front end, and returns an
+ /// appropriate exit code.
+ Future<int> run() async {
+ var frontEndUris = await findFrontEndUris();
+ var packagesFileUri = frontEndLibUri.resolve('../../../.packages');
+ var graph = await graphForProgram(
+ frontEndUris,
+ new CompilerOptions()
+ ..packagesFileUri = packagesFileUri
+ ..chaseDependencies = true);
+ for (var i = 0; i < graph.topologicallySortedCycles.length; i++) {
+ for (var library in graph.topologicallySortedCycles[i].libraries.values) {
+ for (var dependency in library.dependencies) {
+ checkDependency(library.uri, dependency.uri);
+ }
+ }
+ }
+ return problemsReported ? 1 : 0;
+ }
+
+ /// Determines which subpackage [src] is in.
+ ///
+ /// If [src] is not part of the front end, `null` is returned.
+ String subpackageForUri(Uri src) {
+ if (src.scheme != 'package') return null;
+ if (src.pathSegments[0] != 'front_end') return null;
+ if (src.pathSegments[1] != 'src') return 'lib';
+ if (src.pathSegments.length == 3) return 'lib/src';
+ return 'lib/src/${src.pathSegments[2]}';
+ }
+}
diff --git a/pkg/pkg.status b/pkg/pkg.status
index 9a3c1ec..dd69e65 100644
--- a/pkg/pkg.status
+++ b/pkg/pkg.status
@@ -73,6 +73,7 @@
front_end/test/physical_file_system_test: SkipByDesign # Uses dart:io
front_end/test/src/base/libraries_reader_test: SkipByDesign # Uses dart:io
front_end/test/src/base/processed_options_test: SkipByDesign # Uses dart:io
+front_end/test/subpackage_relationships_test: SkipByDesign # Uses dart:io
[ $compiler == dart2js && $fast_startup ]
front_end/test/*: SkipByDesign # Tests written with dart:mirrors.
@@ -210,7 +211,7 @@
analyzer/test/src/task/strong_mode_test: Crash # Issue 24485
analyzer/test/src/task/yaml_test: Crash # Issue 24485
-[ $noopt || $runtime == dart_precompiled ]
+[ $runtime == dart_precompiled ]
*: SkipByDesign # The pkg test framework imports dart:mirrors.
[ $compiler == dart2js && $cps_ir && $checked ]
diff --git a/runtime/BUILD.gn b/runtime/BUILD.gn
index 50ae8ce61..36983b6 100644
--- a/runtime/BUILD.gn
+++ b/runtime/BUILD.gn
@@ -226,17 +226,6 @@
]
}
-libdart_library("libdart_noopt") {
- extra_configs = [
- ":dart_maybe_precompiled_runtime_config",
- ":dart_precompiler_config",
- ]
- extra_deps = [
- "vm:libdart_lib",
- "vm:libdart_vm_noopt",
- ]
-}
-
libdart_library("libdart_precompiled_runtime") {
extra_configs = [ ":dart_precompiled_runtime_config" ]
extra_deps = [
diff --git a/runtime/bin/BUILD.gn b/runtime/bin/BUILD.gn
index 856f8e6..ee6119a 100644
--- a/runtime/bin/BUILD.gn
+++ b/runtime/bin/BUILD.gn
@@ -620,16 +620,6 @@
extra_sources = [ "builtin_nolib.cc" ]
}
-dart_executable("dart_noopt") {
- extra_configs = [ "..:dart_precompiler_config" ]
- extra_deps = [
- "..:libdart_noopt",
- ":dart_snapshot_cc",
- "../observatory:standalone_observatory_archive",
- ]
- extra_sources = [ "builtin_nolib.cc" ]
-}
-
dart_executable("dart_precompiled_runtime") {
extra_configs = [ "..:dart_precompiled_runtime_config" ]
extra_deps = [
diff --git a/runtime/bin/bin.gypi b/runtime/bin/bin.gypi
index b870838..d546638 100644
--- a/runtime/bin/bin.gypi
+++ b/runtime/bin/bin.gypi
@@ -1167,63 +1167,6 @@
},
},
{
- # dart binary with a snapshot of corelibs built in and support for testing
- # precompilation (aka --noopt)
- 'target_name': 'dart_noopt',
- 'type': 'executable',
- 'dependencies': [
- 'build_observatory#host',
- 'generate_observatory_assets_cc_file#host',
- 'generate_resources_cc_file#host',
- 'generate_snapshot_file#host',
- 'libdart_builtin',
- 'libdart_io',
- 'libdart_noopt',
- ],
- 'include_dirs': [
- '..',
- ],
- 'sources': [
- 'main.cc',
- 'builtin.h',
- 'builtin_common.cc',
- 'builtin_natives.cc',
- 'builtin_nolib.cc',
- 'io_natives.h',
- 'vmservice_impl.cc',
- 'vmservice_impl.h',
- '<(observatory_assets_cc_file)',
- '<(resources_cc_file)',
- '<(snapshot_cc_file)',
- ],
- 'defines': [
- 'DART_PRECOMPILER',
- ],
- 'conditions': [
- ['OS=="win"', {
- 'link_settings': {
- 'libraries': [ '-lws2_32.lib', '-lRpcrt4.lib', '-lwinmm.lib' ],
- },
- # Generate an import library on Windows, by exporting a function.
- # Extensions use this import library to link to the API in dart.exe.
- 'msvs_settings': {
- 'VCLinkerTool': {
- 'AdditionalOptions': [ '/EXPORT:Dart_True' ],
- },
- },
- }],
- ],
- 'configurations': {
- 'Dart_Linux_Base': {
- # Have the linker add all symbols to the dynamic symbol table
- # so that extensions can look them up dynamically in the binary.
- 'ldflags': [
- '-rdynamic',
- ],
- },
- },
- },
- {
# dart binary for running precompiled snapshots without the compiler.
'target_name': 'dart_precompiled_runtime',
'type': 'executable',
diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index 05b3842..3ebc8fb 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -1055,7 +1055,7 @@
Dart_Handle result;
// Precompile with specified embedder entry points
- result = Dart_Precompile(standalone_entry_points, true, NULL, 0);
+ result = Dart_Precompile(standalone_entry_points, NULL, 0);
CHECK_RESULT(result);
// Create a precompiled snapshot.
@@ -1063,8 +1063,8 @@
if (as_assembly) {
uint8_t* assembly_buffer = NULL;
intptr_t assembly_size = 0;
- result = Dart_CreatePrecompiledSnapshotAssembly(&assembly_buffer,
- &assembly_size);
+ result =
+ Dart_CreateAppAOTSnapshotAsAssembly(&assembly_buffer, &assembly_size);
CHECK_RESULT(result);
WriteSnapshotFile(assembly_filename, assembly_buffer, assembly_size);
} else {
@@ -1076,7 +1076,7 @@
intptr_t instructions_blob_size = 0;
uint8_t* rodata_blob_buffer = NULL;
intptr_t rodata_blob_size = 0;
- result = Dart_CreatePrecompiledSnapshotBlob(
+ result = Dart_CreateAppAOTSnapshotAsBlobs(
&vm_isolate_buffer, &vm_isolate_size, &isolate_buffer, &isolate_size,
&instructions_blob_buffer, &instructions_blob_size, &rodata_blob_buffer,
&rodata_blob_size);
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index f64e4a8..9c73008 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -97,17 +97,6 @@
static bool use_blobs = false;
-// Global flag that is used to indicate that we want to compile everything in
-// the same way as precompilation before main, then continue running in the
-// same process.
-// Always set this with dart_noopt.
-#if defined(DART_PRECOMPILER) && !defined(DART_NO_SNAPSHOT)
-static const bool is_noopt = true;
-#else
-static const bool is_noopt = false;
-#endif
-
-
extern const char* kPrecompiledVMIsolateSymbolName;
extern const char* kPrecompiledIsolateSymbolName;
extern const char* kPrecompiledInstructionsSymbolName;
@@ -730,10 +719,6 @@
Log::PrintErr("Empty package file name specified.\n");
return -1;
}
- if (is_noopt && gen_snapshot_kind != kNone) {
- Log::PrintErr("Generating a snapshot with dart_noopt is invalid.\n");
- return -1;
- }
if ((gen_snapshot_kind != kNone) && (snapshot_filename == NULL)) {
Log::PrintErr("Generating a snapshot requires a filename (--snapshot).\n");
return -1;
@@ -830,19 +815,6 @@
char** error,
int* exit_code) {
ASSERT(script_uri != NULL);
-
- const bool needs_load_port = true;
-#if defined(PRODUCT)
- const bool run_service_isolate = needs_load_port;
-#else
- // Always create the service isolate in DEBUG and RELEASE modes for profiling,
- // even if we don't need it for loading.
- const bool run_service_isolate = true;
-#endif // PRODUCT
- if (!run_service_isolate &&
- (strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0)) {
- return NULL;
- }
if (strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0) {
if (!use_dart_frontend) {
*error = strdup("Kernel isolate not supported.");
@@ -925,12 +897,10 @@
result = DartUtils::PrepareForScriptLoading(false, trace_loading);
CHECK_RESULT(result);
- if (needs_load_port) {
- // Set up the load port provided by the service isolate so that we can
- // load scripts.
- result = DartUtils::SetupServiceLoadPort();
- CHECK_RESULT(result);
- }
+ // Set up the load port provided by the service isolate so that we can
+ // load scripts.
+ result = DartUtils::SetupServiceLoadPort();
+ CHECK_RESULT(result);
if (Dart_IsKernelIsolate(isolate)) {
script_uri = frontend_filename;
@@ -1510,13 +1480,13 @@
intptr_t rodata_blob_size = 0;
Dart_Handle result;
if (use_blobs) {
- result = Dart_CreatePrecompiledSnapshotBlob(
+ result = Dart_CreateAppAOTSnapshotAsBlobs(
&vm_isolate_buffer, &vm_isolate_size, &isolate_buffer, &isolate_size,
&instructions_blob_buffer, &instructions_blob_size, &rodata_blob_buffer,
&rodata_blob_size);
} else {
- result = Dart_CreatePrecompiledSnapshotAssembly(&assembly_buffer,
- &assembly_size);
+ result =
+ Dart_CreateAppAOTSnapshotAsAssembly(&assembly_buffer, &assembly_size);
}
if (Dart_IsError(result)) {
ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
@@ -1532,8 +1502,8 @@
}
-#if defined(TARGET_ARCH_X64)
static void GenerateAppJITSnapshot() {
+#if defined(TARGET_ARCH_X64)
uint8_t* vm_isolate_buffer = NULL;
intptr_t vm_isolate_size = 0;
uint8_t* isolate_buffer = NULL;
@@ -1542,7 +1512,7 @@
intptr_t instructions_blob_size = 0;
uint8_t* rodata_blob_buffer = NULL;
intptr_t rodata_blob_size = 0;
- Dart_Handle result = Dart_CreateAppJITSnapshot(
+ Dart_Handle result = Dart_CreateAppJITSnapshotAsBlobs(
&isolate_buffer, &isolate_size, &instructions_blob_buffer,
&instructions_blob_size, &rodata_blob_buffer, &rodata_blob_size);
if (Dart_IsError(result)) {
@@ -1552,27 +1522,14 @@
isolate_buffer, isolate_size, instructions_blob_buffer,
instructions_blob_size, rodata_blob_buffer,
rodata_blob_size);
-}
-#endif // defined(TARGET_ARCH_X64)
-
-
-static void GenerateAppSnapshot() {
- Dart_Handle result;
-#if defined(TARGET_ARCH_X64)
- result = Dart_PrecompileJIT();
- if (Dart_IsError(result)) {
- ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
- }
- GenerateAppJITSnapshot();
#else
- // Create an application snapshot of the script.
uint8_t* vm_isolate_buffer = NULL;
intptr_t vm_isolate_size = 0;
uint8_t* isolate_buffer = NULL;
intptr_t isolate_size = 0;
- result = Dart_CreateSnapshot(&vm_isolate_buffer, &vm_isolate_size,
- &isolate_buffer, &isolate_size);
+ Dart_Handle result = Dart_CreateSnapshot(&vm_isolate_buffer, &vm_isolate_size,
+ &isolate_buffer, &isolate_size);
if (Dart_IsError(result)) {
ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
}
@@ -1606,7 +1563,7 @@
Platform::Exit(kErrorExitCode);
}
if (exit_code == 0) {
- GenerateAppSnapshot();
+ GenerateAppJITSnapshot();
}
}
@@ -1659,8 +1616,7 @@
reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
result = Dart_LibraryImportLibrary(isolate_data->builtin_lib(), root_lib,
Dart_Null());
- if (is_noopt || (gen_snapshot_kind == kAppAOT) ||
- (gen_snapshot_kind == kAppJIT)) {
+ if ((gen_snapshot_kind == kAppAOT) || (gen_snapshot_kind == kAppJIT)) {
// Load the embedder's portion of the VM service's Dart code so it will
// be included in the app snapshot.
if (!VmService::LoadForGenPrecompiled()) {
@@ -1684,7 +1640,7 @@
return false;
}
- if (is_noopt || (gen_snapshot_kind == kAppAOT)) {
+ if (gen_snapshot_kind == kAppAOT) {
Dart_QualifiedFunctionName standalone_entry_points[] = {
{"dart:_builtin", "::", "_getMainClosure"},
{"dart:_builtin", "::", "_getPrintClosure"},
@@ -1737,9 +1693,8 @@
file->Release();
}
- const bool reset_fields = gen_snapshot_kind == kAppAOT;
- result = Dart_Precompile(standalone_entry_points, reset_fields,
- feedback_buffer, feedback_length);
+ result = Dart_Precompile(standalone_entry_points, feedback_buffer,
+ feedback_length);
if (feedback_buffer != NULL) {
free(feedback_buffer);
}
@@ -1782,7 +1737,7 @@
if (gen_snapshot_kind == kAppJIT) {
if (!Dart_IsCompilationError(result) &&
!Dart_IsVMRestartRequest(result)) {
- GenerateAppSnapshot();
+ GenerateAppJITSnapshot();
}
}
CHECK_RESULT(result);
@@ -1967,7 +1922,7 @@
vm_options.AddArgument("--collect_code=false");
#endif
}
- if ((gen_snapshot_kind == kAppAOT) || is_noopt) {
+ if (gen_snapshot_kind == kAppAOT) {
vm_options.AddArgument("--precompilation");
}
#if defined(DART_PRECOMPILED_RUNTIME)
diff --git a/runtime/bin/process_android.cc b/runtime/bin/process_android.cc
index 11949ba..d2dcca1 100644
--- a/runtime/bin/process_android.cc
+++ b/runtime/bin/process_android.cc
@@ -682,7 +682,10 @@
strlen(os_error_message) + 1);
}
VOID_TEMP_FAILURE_RETRY(close(exec_control_[1]));
- exit(1);
+
+ // We avoid running through registered atexit() handlers because that is
+ // unnecessary work.
+ _exit(1);
}
diff --git a/runtime/bin/process_fuchsia.cc b/runtime/bin/process_fuchsia.cc
index 81a4af3..4b4b5d5 100644
--- a/runtime/bin/process_fuchsia.cc
+++ b/runtime/bin/process_fuchsia.cc
@@ -736,8 +736,7 @@
mx_status_t status;
mx_handle_t job = MX_HANDLE_INVALID;
- status = mx_handle_duplicate(launchpad_get_mxio_job(), MX_RIGHT_SAME_RIGHTS,
- &job);
+ status = mx_handle_duplicate(mx_job_default(), MX_RIGHT_SAME_RIGHTS, &job);
CHECK_FOR_ERROR(status, "mx_handle_duplicate");
status = launchpad_create(job, program_arguments_[0], &lp);
diff --git a/runtime/bin/process_linux.cc b/runtime/bin/process_linux.cc
index 4197869..ae686e5 100644
--- a/runtime/bin/process_linux.cc
+++ b/runtime/bin/process_linux.cc
@@ -682,7 +682,10 @@
strlen(os_error_message) + 1);
}
VOID_TEMP_FAILURE_RETRY(close(exec_control_[1]));
- exit(1);
+
+ // We avoid running through registered atexit() handlers because that is
+ // unnecessary work.
+ _exit(1);
}
diff --git a/runtime/bin/run_vm_tests_fuchsia.cc b/runtime/bin/run_vm_tests_fuchsia.cc
index e7d4015..da8e19c 100644
--- a/runtime/bin/run_vm_tests_fuchsia.cc
+++ b/runtime/bin/run_vm_tests_fuchsia.cc
@@ -134,8 +134,7 @@
launchpad_t* lp;
mx_status_t status;
mx_handle_t job = MX_HANDLE_INVALID;
- status =
- mx_handle_duplicate(launchpad_get_mxio_job(), MX_RIGHT_SAME_RIGHTS, &job);
+ status = mx_handle_duplicate(mx_job_default(), MX_RIGHT_SAME_RIGHTS, &job);
RETURN_IF_ERROR(status);
status = launchpad_create(job, argv[0], &lp);
RETURN_IF_ERROR(status);
diff --git a/runtime/bin/socket_patch.dart b/runtime/bin/socket_patch.dart
index cd02b29..c11cec1 100644
--- a/runtime/bin/socket_patch.dart
+++ b/runtime/bin/socket_patch.dart
@@ -669,7 +669,8 @@
var result =
nativeWrite(bufferAndStart.buffer, bufferAndStart.start, bytes);
if (result is OSError) {
- scheduleMicrotask(() => reportError(result, "Write failed"));
+ OSError osError = result;
+ scheduleMicrotask(() => reportError(osError, "Write failed"));
result = 0;
}
// The result may be negative, if we forced a short write for testing
@@ -699,7 +700,8 @@
bufferAndStart.buffer, bufferAndStart.start, bytes,
address._in_addr, port);
if (result is OSError) {
- scheduleMicrotask(() => reportError(result, "Send failed"));
+ OSError osError = result;
+ scheduleMicrotask(() => reportError(osError, "Send failed"));
result = 0;
}
// TODO(ricow): Remove when we track internal and pipe uses.
diff --git a/runtime/bin/vmservice/server.dart b/runtime/bin/vmservice/server.dart
index 9a48adf..020badb 100644
--- a/runtime/bin/vmservice/server.dart
+++ b/runtime/bin/vmservice/server.dart
@@ -166,7 +166,7 @@
}
bool _originCheck(HttpRequest request) {
- if (_originCheckDisabled) {
+ if (_originCheckDisabled || Platform.isFuchsia) {
// Always allow.
return true;
}
@@ -306,12 +306,16 @@
// Startup HTTP server.
try {
- var addresses = await InternetAddress.lookup(_ip);
var address;
- // Prefer IPv4 addresses.
- for (var i = 0; i < addresses.length; i++) {
- address = addresses[i];
- if (address.type == InternetAddressType.IP_V4) break;
+ if (Platform.isFuchsia) {
+ address = InternetAddress.ANY_IP_V6;
+ } else {
+ var addresses = await InternetAddress.lookup(_ip);
+ // Prefer IPv4 addresses.
+ for (var i = 0; i < addresses.length; i++) {
+ address = addresses[i];
+ if (address.type == InternetAddressType.IP_V4) break;
+ }
}
_server = await HttpServer.bind(address, _port);
_server.listen(_requestHandler, cancelOnError: true);
diff --git a/runtime/bin/vmservice/vmservice_io.dart b/runtime/bin/vmservice/vmservice_io.dart
index a883a73..b092b21 100644
--- a/runtime/bin/vmservice/vmservice_io.dart
+++ b/runtime/bin/vmservice/vmservice_io.dart
@@ -229,7 +229,7 @@
VMServiceEmbedderHooks.webServerControl = webServerControlCallback;
// Always instantiate the vmservice object so that the exit message
// can be delivered and waiting loaders can be cancelled.
- var service = new VMService();
+ new VMService();
if (_autoStart) {
_lazyServerBoot();
server.startup();
diff --git a/runtime/dart-runtime.gyp b/runtime/dart-runtime.gyp
index 6ed2306..1b2f9bd 100644
--- a/runtime/dart-runtime.gyp
+++ b/runtime/dart-runtime.gyp
@@ -55,41 +55,6 @@
},
},
{
- 'target_name': 'libdart_noopt',
- 'type': 'static_library',
- 'dependencies': [
- 'libdart_lib',
- 'libdart_vm_noopt',
- 'libdouble_conversion',
- 'generate_version_cc_file#host',
- ],
- 'include_dirs': [
- '.',
- ],
- 'sources': [
- 'include/dart_api.h',
- 'include/dart_mirrors_api.h',
- 'include/dart_native_api.h',
- 'include/dart_tools_api.h',
- 'vm/dart_api_impl.cc',
- 'vm/debugger_api_impl.cc',
- 'vm/mirrors_api_impl.cc',
- 'vm/native_api_impl.cc',
- 'vm/version.h',
- '<(version_cc_file)',
- ],
- 'defines': [
- # The only effect of DART_SHARED_LIB is to export the Dart API entries.
- 'DART_SHARED_LIB',
- 'DART_PRECOMPILER',
- ],
- 'direct_dependent_settings': {
- 'include_dirs': [
- 'include',
- ],
- },
- },
- {
'target_name': 'libdart_precompiled_runtime',
'type': 'static_library',
'dependencies': [
diff --git a/runtime/include/dart_api.h b/runtime/include/dart_api.h
index 800b837..7bd749c 100644
--- a/runtime/include/dart_api.h
+++ b/runtime/include/dart_api.h
@@ -3202,15 +3202,13 @@
* reset_fields is true when we are about to create a precompilated snapshot.
* Some fields are already been initialized as part of the loading logic, and
* we want them to be reinitialized in the new process that will load the
- * snapshot. reset_fields is false for --noopt, which will continue running in
- * the same process.
+ * snapshot.
*
* \return An error handle if a compilation error or runtime error running const
* constructors was encountered.
*/
DART_EXPORT Dart_Handle
Dart_Precompile(Dart_QualifiedFunctionName entry_points[],
- bool reset_fields,
uint8_t* jit_feedback,
intptr_t jit_feedback_length);
@@ -3220,14 +3218,14 @@
* - A root library must have been loaded.
* - Dart_Precompile must have been called.
*
- * Outputs a vm isolate snapshot, an isolate snapshot, and an assembly file
- * defining the symbols kInstructionsSnapshot and kDataSnapshot. The assembly
+ * Outputs an assembly file defining the symbols kVmIsolateSnapshot,
+ * kIsolateSnapshot, kInstructionsSnapshot and kDataSnapshot. The assembly
* should be compiled as a static or shared library and linked or loaded by the
* embedder.
* Running this snapshot requires a VM compiled with DART_PRECOMPILED_SNAPSHOT.
- * The vm isolate snapshot, kInstructionsSnapshot and kDataSnapshot should be
- * passed as arguments to Dart_Initialize. The isolate snapshot should be
- * passed to Dart_CreateIsolate.
+ * The kVmIsolateSnapshot, kInstructionsSnapshot and kDataSnapshot should be
+ * passed as arguments to Dart_Initialize. The kIsolateSnapshot snapshot should
+ * be passed to Dart_CreateIsolate.
*
* The buffers are scope allocated and are only valid until the next call to
* Dart_ExitScope.
@@ -3235,28 +3233,25 @@
* \return A valid handle if no error occurs during the operation.
*/
DART_EXPORT Dart_Handle
-Dart_CreatePrecompiledSnapshotAssembly(uint8_t** assembly_buffer,
- intptr_t* assembly_size);
+Dart_CreateAppAOTSnapshotAsAssembly(uint8_t** assembly_buffer,
+ intptr_t* assembly_size);
/**
- * Same as Dart_CreatePrecompiledSnapshotAssembly, except the instruction and
- * data snapshot pieces are provided directly as bytes that the embedder can
- * load with mmap. The instructions piece must be loaded with read and
- * execute permissions; the rodata piece may be loaded as read-only.
+ * Same as Dart_CreateAppAOTSnapshotAsAssembly, except all the pieces are
+ * provided directly as bytes that the embedder can load with mmap. The
+ * instructions piece must be loaded with read and execute permissions; the
+ * other pieces may be loaded as read-only.
*/
DART_EXPORT Dart_Handle
-Dart_CreatePrecompiledSnapshotBlob(uint8_t** vm_isolate_snapshot_buffer,
- intptr_t* vm_isolate_snapshot_size,
- uint8_t** isolate_snapshot_buffer,
- intptr_t* isolate_snapshot_size,
- uint8_t** instructions_blob_buffer,
- intptr_t* instructions_blob_size,
- uint8_t** rodata_blob_buffer,
- intptr_t* rodata_blob_size);
-
-
-DART_EXPORT Dart_Handle Dart_PrecompileJIT();
+Dart_CreateAppAOTSnapshotAsBlobs(uint8_t** vm_isolate_snapshot_buffer,
+ intptr_t* vm_isolate_snapshot_size,
+ uint8_t** isolate_snapshot_buffer,
+ intptr_t* isolate_snapshot_size,
+ uint8_t** instructions_blob_buffer,
+ intptr_t* instructions_blob_size,
+ uint8_t** rodata_blob_buffer,
+ intptr_t* rodata_blob_size);
/**
@@ -3283,12 +3278,12 @@
* \return A valid handle if no error occurs during the operation.
*/
DART_EXPORT Dart_Handle
-Dart_CreateAppJITSnapshot(uint8_t** isolate_snapshot_buffer,
- intptr_t* isolate_snapshot_size,
- uint8_t** instructions_blob_buffer,
- intptr_t* instructions_blob_size,
- uint8_t** rodata_blob_buffer,
- intptr_t* rodata_blob_size);
+Dart_CreateAppJITSnapshotAsBlobs(uint8_t** isolate_snapshot_buffer,
+ intptr_t* isolate_snapshot_size,
+ uint8_t** instructions_blob_buffer,
+ intptr_t* instructions_blob_size,
+ uint8_t** rodata_blob_buffer,
+ intptr_t* rodata_blob_size);
/**
diff --git a/runtime/lib/isolate.cc b/runtime/lib/isolate.cc
index d88fbc8..4eff307 100644
--- a/runtime/lib/isolate.cc
+++ b/runtime/lib/isolate.cc
@@ -30,11 +30,17 @@
false,
"Block the parent thread when loading spawned isolates.");
-static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
+static uint8_t* malloc_allocator(uint8_t* ptr,
+ intptr_t old_size,
+ intptr_t new_size) {
void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
return reinterpret_cast<uint8_t*>(new_ptr);
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(reinterpret_cast<void*>(ptr));
+}
+
DEFINE_NATIVE_ENTRY(CapabilityImpl_factory, 1) {
ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
@@ -116,7 +122,8 @@
new Message(destination_port_id, obj.raw(), Message::kNormalPriority));
} else {
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, can_send_any_object);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator,
+ can_send_any_object);
writer.WriteMessage(obj);
// TODO(turnidge): Throw an exception when the return value is false?
@@ -424,7 +431,7 @@
msg.SetAt(0, Smi::Handle(Smi::New(Message::kIsolateLibOOBMsg)));
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(msg);
PortMap::PostMessage(new Message(port.Id(), data, writer.BytesWritten(),
diff --git a/runtime/lib/vmservice.cc b/runtime/lib/vmservice.cc
index 5b6af4f..9d83c13 100644
--- a/runtime/lib/vmservice.cc
+++ b/runtime/lib/vmservice.cc
@@ -21,11 +21,17 @@
DECLARE_FLAG(bool, trace_service);
-static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
+static uint8_t* malloc_allocator(uint8_t* ptr,
+ intptr_t old_size,
+ intptr_t new_size) {
void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
return reinterpret_cast<uint8_t*>(new_ptr);
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(reinterpret_cast<void*>(ptr));
+}
+
#ifndef PRODUCT
class RegisterRunningIsolatesVisitor : public IsolateVisitor {
@@ -95,7 +101,7 @@
// Serialize message.
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(message);
// TODO(turnidge): Throw an exception when the return value is false?
diff --git a/runtime/observatory/tests/service/get_source_report_test.dart b/runtime/observatory/tests/service/get_source_report_test.dart
index 2f089b2..81f21a5 100644
--- a/runtime/observatory/tests/service/get_source_report_test.dart
+++ b/runtime/observatory/tests/service/get_source_report_test.dart
@@ -63,10 +63,10 @@
var expectedRange = {
'scriptIndex': 0,
- 'startPos': 38,
- 'endPos': 87,
+ 'startPos': 39,
+ 'endPos': 88,
'compiled': true,
- 'coverage': {'hits': [53, 71, 81], 'misses': [59]}
+ 'coverage': {'hits': [54, 72, 82], 'misses': [60]}
};
// Full script
diff --git a/runtime/observatory/tests/service/service.status b/runtime/observatory/tests/service/service.status
index 6e63e33..7c243e7 100644
--- a/runtime/observatory/tests/service/service.status
+++ b/runtime/observatory/tests/service/service.status
@@ -46,7 +46,7 @@
[ $arch == arm ]
process_service_test: Pass, Fail # Issue 24344
-[ ($noopt || $compiler == precompiler) ]
+[ $compiler == precompiler ]
*: Skip # Issue 24651
[ $runtime == vm ]
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index fdcb0b4..b845d01 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -243,16 +243,16 @@
cc/IsolateReload_TypeIdentityGeneric: Fail # Issue 28349
cc/IsolateReload_TypeIdentityParameter: Fail # Issue 28349
-[ $noopt || $compiler == precompiler ]
+[ $compiler == precompiler ]
dart/byte_array_test: Skip # Incompatible flag --disable_alloc_stubs_after_gc
-[ $noopt || $compiler == precompiler || $mode == product ]
+[ $compiler == precompiler || $mode == product ]
dart/redirection_type_shuffling_test: SkipByDesign # Imports dart:mirrors
cc/CreateMirrorSystem: SkipByDesign # Imports dart:mirrors
cc/CoreSnapshotSize: SkipByDesign # Imports dart:mirrors
cc/StandaloneSnapshotSize: SkipByDesign # Imports dart:mirrors
-[ $noopt || $runtime == dart_precompiled ]
+[ $runtime == dart_precompiled ]
# StackTraces in precompilation omit inlined frames.
dart/inline_stack_frame_test: Pass, RuntimeError
dart/optimized_stacktrace_test: Pass, RuntimeError
diff --git a/runtime/vm/assembler_arm64.cc b/runtime/vm/assembler_arm64.cc
index 8f3dc14..1b98387 100644
--- a/runtime/vm/assembler_arm64.cc
+++ b/runtime/vm/assembler_arm64.cc
@@ -181,7 +181,7 @@
static int CountOneBits(uint64_t value, int width) {
// Mask out unused bits to ensure that they are not counted.
- value &= (0xffffffffffffffffUL >> (64 - width));
+ value &= (0xffffffffffffffffULL >> (64 - width));
value = ((value >> 1) & 0x5555555555555555) + (value & 0x5555555555555555);
value = ((value >> 2) & 0x3333333333333333) + (value & 0x3333333333333333);
@@ -282,7 +282,7 @@
// 5. If the most-significant half of the bitwise value is equal to the
// least-significant half, return to step 2 using the least-significant
// half of the value.
- uint64_t mask = (1UL << (width >> 1)) - 1;
+ uint64_t mask = (1ULL << (width >> 1)) - 1;
if ((value & mask) == ((value >> (width >> 1)) & mask)) {
width >>= 1;
set_bits >>= 1;
diff --git a/runtime/vm/benchmark_test.cc b/runtime/vm/benchmark_test.cc
index e2f8790..efe1223 100644
--- a/runtime/vm/benchmark_test.cc
+++ b/runtime/vm/benchmark_test.cc
@@ -491,6 +491,11 @@
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(ptr);
+}
+
+
BENCHMARK_SIZE(CoreSnapshotSize) {
const char* kScriptChars =
"import 'dart:async';\n"
@@ -607,6 +612,7 @@
intptr_t new_size) {
return message_buffer;
}
+static void message_deallocator(uint8_t* ptr) {}
BENCHMARK(SerializeNull) {
@@ -617,7 +623,8 @@
timer.Start();
for (intptr_t i = 0; i < kLoopCount; i++) {
StackZone zone(thread);
- MessageWriter writer(&buffer, &message_allocator, true);
+ MessageWriter writer(&buffer, &message_allocator, &message_deallocator,
+ true);
writer.WriteMessage(null_object);
intptr_t buffer_len = writer.BytesWritten();
@@ -639,7 +646,8 @@
timer.Start();
for (intptr_t i = 0; i < kLoopCount; i++) {
StackZone zone(thread);
- MessageWriter writer(&buffer, &message_allocator, true);
+ MessageWriter writer(&buffer, &message_allocator, &message_deallocator,
+ true);
writer.WriteMessage(smi_object);
intptr_t buffer_len = writer.BytesWritten();
@@ -664,7 +672,7 @@
timer.Start();
for (intptr_t i = 0; i < kLoopCount; i++) {
StackZone zone(thread);
- MessageWriter writer(&buffer, &malloc_allocator, true);
+ MessageWriter writer(&buffer, &malloc_allocator, &malloc_deallocator, true);
writer.WriteMessage(array_object);
intptr_t buffer_len = writer.BytesWritten();
@@ -698,7 +706,7 @@
timer.Start();
for (intptr_t i = 0; i < kLoopCount; i++) {
StackZone zone(thread);
- MessageWriter writer(&buffer, &malloc_allocator, true);
+ MessageWriter writer(&buffer, &malloc_allocator, &malloc_deallocator, true);
writer.WriteMessage(map);
intptr_t buffer_len = writer.BytesWritten();
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index 542fd52..bafbc73 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -810,7 +810,7 @@
uint8_t width) {
ASSERT(width <= 64);
rotate &= 63;
- return ((value & ((1UL << rotate) - 1UL)) << (width - rotate)) |
+ return ((value & ((1ULL << rotate) - 1ULL)) << (width - rotate)) |
(value >> rotate);
}
@@ -820,7 +820,7 @@
ASSERT((width == 2) || (width == 4) || (width == 8) || (width == 16) ||
(width == 32));
ASSERT((reg_size == kWRegSizeInBits) || (reg_size == kXRegSizeInBits));
- uint64_t result = value & ((1UL << width) - 1UL);
+ uint64_t result = value & ((1ULL << width) - 1ULL);
for (unsigned i = width; i < reg_size; i *= 2) {
result |= (result << i);
}
@@ -1087,7 +1087,7 @@
if (imm_s == 0x3F) {
return 0;
}
- uint64_t bits = (1UL << (imm_s + 1)) - 1;
+ uint64_t bits = (1ULL << (imm_s + 1)) - 1;
return RotateRight(bits, imm_r, 64);
} else {
if ((imm_s >> 1) == 0x1F) {
@@ -1099,7 +1099,7 @@
if ((imm_s & mask) == mask) {
return 0;
}
- uint64_t bits = (1UL << ((imm_s & mask) + 1)) - 1;
+ uint64_t bits = (1ULL << ((imm_s & mask) + 1)) - 1;
return RepeatBitsAcrossReg(
reg_size, RotateRight(bits, imm_r & mask, width), width);
}
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 42b6cfd..57f5cbe 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -139,6 +139,14 @@
if (vm_isolate_ != NULL || !Flags::Initialized()) {
return strdup("VM already initialized or flags not initialized.");
}
+#if defined(DEBUG)
+ // Turn on verify_gc_contains if any of the other GC verification flag
+ // is turned on.
+ if (FLAG_verify_before_gc || FLAG_verify_after_gc ||
+ FLAG_verify_on_transition) {
+ FLAG_verify_gc_contains = true;
+ }
+#endif
set_thread_exit_callback(thread_exit);
SetFileCallbacks(file_open, file_read, file_write, file_close);
set_entropy_source_callback(entropy_source);
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 8ff2deb..22e2391 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -1780,12 +1780,19 @@
}
-static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
+static uint8_t* malloc_allocator(uint8_t* ptr,
+ intptr_t old_size,
+ intptr_t new_size) {
void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
return reinterpret_cast<uint8_t*>(new_ptr);
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(reinterpret_cast<void*>(ptr));
+}
+
+
DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle) {
DARTSCOPE(Thread::Current());
API_TIMELINE_DURATION;
@@ -1803,7 +1810,7 @@
const Object& object = Object::Handle(Z, raw_obj);
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(object);
intptr_t len = writer.BytesWritten();
return PortMap::PostMessage(
@@ -6566,7 +6573,6 @@
DART_EXPORT Dart_Handle
Dart_Precompile(Dart_QualifiedFunctionName entry_points[],
- bool reset_fields,
uint8_t* jit_feedback,
intptr_t jit_feedback_length) {
#if defined(TARGET_ARCH_IA32)
@@ -6587,8 +6593,8 @@
return result;
}
CHECK_CALLBACK_STATE(T);
- const Error& error = Error::Handle(Precompiler::CompileAll(
- entry_points, reset_fields, jit_feedback, jit_feedback_length));
+ const Error& error = Error::Handle(
+ Precompiler::CompileAll(entry_points, jit_feedback, jit_feedback_length));
if (!error.IsNull()) {
return Api::NewHandle(T, error.raw());
}
@@ -6598,8 +6604,8 @@
DART_EXPORT Dart_Handle
-Dart_CreatePrecompiledSnapshotAssembly(uint8_t** assembly_buffer,
- intptr_t* assembly_size) {
+Dart_CreateAppAOTSnapshotAsAssembly(uint8_t** assembly_buffer,
+ intptr_t* assembly_size) {
#if defined(TARGET_ARCH_IA32)
return Api::NewError("AOT compilation is not supported on IA32.");
#elif defined(TARGET_ARCH_DBC)
@@ -6643,14 +6649,14 @@
DART_EXPORT Dart_Handle
-Dart_CreatePrecompiledSnapshotBlob(uint8_t** vm_isolate_snapshot_buffer,
- intptr_t* vm_isolate_snapshot_size,
- uint8_t** isolate_snapshot_buffer,
- intptr_t* isolate_snapshot_size,
- uint8_t** instructions_blob_buffer,
- intptr_t* instructions_blob_size,
- uint8_t** rodata_blob_buffer,
- intptr_t* rodata_blob_size) {
+Dart_CreateAppAOTSnapshotAsBlobs(uint8_t** vm_isolate_snapshot_buffer,
+ intptr_t* vm_isolate_snapshot_size,
+ uint8_t** isolate_snapshot_buffer,
+ intptr_t* isolate_snapshot_size,
+ uint8_t** instructions_blob_buffer,
+ intptr_t* instructions_blob_size,
+ uint8_t** rodata_blob_buffer,
+ intptr_t* rodata_blob_size) {
#if defined(TARGET_ARCH_IA32)
return Api::NewError("AOT compilation is not supported on IA32.");
#elif defined(TARGET_ARCH_DBC)
@@ -6713,49 +6719,19 @@
}
-DART_EXPORT Dart_Handle Dart_PrecompileJIT() {
- API_TIMELINE_BEGIN_END;
- DARTSCOPE(Thread::Current());
- Isolate* I = T->isolate();
- Dart_Handle result = Api::CheckAndFinalizePendingClasses(T);
- if (::Dart_IsError(result)) {
- return result;
- }
- CHECK_CALLBACK_STATE(T);
- GrowableObjectArray& libraries =
- GrowableObjectArray::Handle(Z, I->object_store()->libraries());
- Library& lib = Library::Handle(Z);
- Class& cls = Class::Handle(Z);
- Error& error = Error::Handle(Z);
- for (intptr_t i = 0; i < libraries.Length(); i++) {
- lib ^= libraries.At(i);
- ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
- while (it.HasNext()) {
- cls = it.GetNextClass();
- if (cls.IsDynamicClass()) {
- continue; // class 'dynamic' is in the read-only VM isolate.
- }
- error = cls.EnsureIsFinalized(T);
- if (!error.IsNull()) {
- return Api::NewHandle(T, error.raw());
- }
- }
- }
- return Api::Success();
-}
-
-
DART_EXPORT Dart_Handle
-Dart_CreateAppJITSnapshot(uint8_t** isolate_snapshot_buffer,
- intptr_t* isolate_snapshot_size,
- uint8_t** instructions_blob_buffer,
- intptr_t* instructions_blob_size,
- uint8_t** rodata_blob_buffer,
- intptr_t* rodata_blob_size) {
+Dart_CreateAppJITSnapshotAsBlobs(uint8_t** isolate_snapshot_buffer,
+ intptr_t* isolate_snapshot_size,
+ uint8_t** instructions_blob_buffer,
+ intptr_t* instructions_blob_size,
+ uint8_t** rodata_blob_buffer,
+ intptr_t* rodata_blob_size) {
#if defined(TARGET_ARCH_IA32)
return Api::NewError("Snapshots with code are not supported on IA32.");
#elif defined(TARGET_ARCH_DBC)
return Api::NewError("Snapshots with code are not supported on DBC.");
+#elif defined(DART_PRECOMPILED_RUNTIME)
+ return Api::NewError("JIT app snapshots cannot be taken from an AOT runtime");
#else
API_TIMELINE_DURATION;
DARTSCOPE(Thread::Current());
diff --git a/runtime/vm/dart_api_message.h b/runtime/vm/dart_api_message.h
index 8e2747a..c74737e 100644
--- a/runtime/vm/dart_api_message.h
+++ b/runtime/vm/dart_api_message.h
@@ -158,7 +158,7 @@
public:
static const intptr_t kInitialSize = 512;
ApiMessageWriter(uint8_t** buffer, ReAlloc alloc)
- : BaseWriter(buffer, alloc, kInitialSize),
+ : BaseWriter(buffer, alloc, NULL, kInitialSize),
object_id_(0),
forward_list_(NULL),
forward_list_length_(0),
diff --git a/runtime/vm/datastream.h b/runtime/vm/datastream.h
index 3b714b7..b50f585 100644
--- a/runtime/vm/datastream.h
+++ b/runtime/vm/datastream.h
@@ -23,6 +23,7 @@
static const uint8_t kEndUnsignedByteMarker = (255 - kMaxUnsignedDataPerByte);
typedef uint8_t* (*ReAlloc)(uint8_t* ptr, intptr_t old_size, intptr_t new_size);
+typedef void (*DeAlloc)(uint8_t* ptr);
// Stream for reading various types from a buffer.
class ReadStream : public ValueObject {
diff --git a/runtime/vm/debugger.cc b/runtime/vm/debugger.cc
index 87d0a4c..53bcba2 100644
--- a/runtime/vm/debugger.cc
+++ b/runtime/vm/debugger.cc
@@ -1771,6 +1771,7 @@
// of the given token range.
TokenPosition best_fit_pos = TokenPosition::kMaxSource;
intptr_t best_column = INT_MAX;
+ intptr_t best_line = INT_MAX;
PcDescriptors::Iterator iter(desc, kSafepointKind);
while (iter.MoveNext()) {
const TokenPosition pos = iter.TokenPos();
@@ -1781,8 +1782,8 @@
}
intptr_t token_start_column = -1;
+ intptr_t token_line = -1;
if (requested_column >= 0) {
- intptr_t ignored = -1;
intptr_t token_len = -1;
// TODO(turnidge): GetTokenLocation is a very expensive
// operation, and this code will blow up when we are setting
@@ -1790,7 +1791,8 @@
// program. Consider rewriting this code so that it only scans
// the program code once and caches the token positions and
// lengths.
- script.GetTokenLocation(pos, &ignored, &token_start_column, &token_len);
+ script.GetTokenLocation(pos, &token_line, &token_start_column,
+ &token_len);
intptr_t token_end_column = token_start_column + token_len - 1;
if ((token_end_column < requested_column) ||
(token_start_column > best_column)) {
@@ -1803,6 +1805,7 @@
// Prefer the lowest (first) token pos.
if (pos < best_fit_pos) {
best_fit_pos = pos;
+ best_line = token_line;
best_column = token_start_column;
}
}
@@ -1812,10 +1815,24 @@
// was specified) and has the lowest code address.
if (best_fit_pos != TokenPosition::kMaxSource) {
const Script& script = Script::Handle(zone, func.script());
- const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
const TokenPosition begin_pos = best_fit_pos;
- const TokenPosition end_of_line_pos =
- LastTokenOnLine(zone, tokens, begin_pos);
+
+ TokenPosition end_of_line_pos;
+ if (script.kind() == RawScript::kKernelTag) {
+ if (best_line == -1) {
+ script.GetTokenLocation(begin_pos, &best_line, NULL);
+ }
+ ASSERT(best_line > 0);
+ TokenPosition ignored;
+ script.TokenRangeAtLine(best_line, &ignored, &end_of_line_pos);
+ if (end_of_line_pos < begin_pos) {
+ end_of_line_pos = begin_pos;
+ }
+ } else {
+ const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
+ end_of_line_pos = LastTokenOnLine(zone, tokens, begin_pos);
+ }
+
uword lowest_pc_offset = kUwordMax;
PcDescriptors::Iterator iter(desc, kSafepointKind);
while (iter.MoveNext()) {
@@ -2911,6 +2928,9 @@
ASSERT(closure_or_null.IsInstance());
ASSERT(Instance::Cast(closure_or_null).IsClosure());
const Script& script = Script::Handle(zone, top_frame->SourceScript());
+ if (script.kind() == RawScript::kKernelTag) {
+ return false;
+ }
const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
TokenStream::Iterator iter(zone, tokens, top_frame->TokenPos());
if ((iter.CurrentTokenKind() == Token::kIDENT) &&
diff --git a/runtime/vm/flag_list.h b/runtime/vm/flag_list.h
index c59746e..af82d62 100644
--- a/runtime/vm/flag_list.h
+++ b/runtime/vm/flag_list.h
@@ -162,6 +162,8 @@
"Enables heap verification after GC.") \
R(verify_before_gc, false, bool, false, \
"Enables heap verification before GC.") \
+ D(verify_gc_contains, bool, false, \
+ "Enables verification of address contains during GC.") \
D(verify_on_transition, bool, false, "Verify on dart <==> VM.")
#endif // RUNTIME_VM_FLAG_LIST_H_
diff --git a/runtime/vm/flow_graph_compiler.cc b/runtime/vm/flow_graph_compiler.cc
index d0a2cb1..2ab89c1 100644
--- a/runtime/vm/flow_graph_compiler.cc
+++ b/runtime/vm/flow_graph_compiler.cc
@@ -90,7 +90,8 @@
FLAG_unbox_numeric_fields = false;
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
- // Set flags affecting runtime accordingly for dart_noopt.
+ // Set flags affecting runtime accordingly for dart_bootstrap.
+ // These flags are constants with PRODUCT and DART_PRECOMPILED_RUNTIME.
FLAG_collect_code = false;
FLAG_support_debugger = false;
FLAG_deoptimize_alot = false; // Used in some tests.
diff --git a/runtime/vm/gc_marker.cc b/runtime/vm/gc_marker.cc
index 86c5ae3..a6d1548 100644
--- a/runtime/vm/gc_marker.cc
+++ b/runtime/vm/gc_marker.cc
@@ -305,7 +305,7 @@
private:
void PushMarked(RawObject* raw_obj) {
ASSERT(raw_obj->IsHeapObject());
- ASSERT((FLAG_verify_before_gc || FLAG_verify_before_gc)
+ ASSERT((FLAG_verify_gc_contains)
? page_space_->Contains(RawObject::ToAddr(raw_obj))
: true);
diff --git a/runtime/vm/heap.cc b/runtime/vm/heap.cc
index fce8cfe..c7ce678 100644
--- a/runtime/vm/heap.cc
+++ b/runtime/vm/heap.cc
@@ -178,6 +178,11 @@
}
+bool Heap::DataContains(uword addr) const {
+ return old_space_.DataContains(addr);
+}
+
+
void Heap::VisitObjects(ObjectVisitor* visitor) const {
new_space_.VisitObjects(visitor);
old_space_.VisitObjects(visitor);
diff --git a/runtime/vm/heap.h b/runtime/vm/heap.h
index 8154987..40bbc90 100644
--- a/runtime/vm/heap.h
+++ b/runtime/vm/heap.h
@@ -88,6 +88,7 @@
bool NewContains(uword addr) const;
bool OldContains(uword addr) const;
bool CodeContains(uword addr) const;
+ bool DataContains(uword addr) const;
void IterateObjects(ObjectVisitor* visitor) const;
void IterateOldObjects(ObjectVisitor* visitor) const;
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index 76159c8..5e43f3a 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -100,17 +100,24 @@
#endif
-static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
+static uint8_t* malloc_allocator(uint8_t* ptr,
+ intptr_t old_size,
+ intptr_t new_size) {
void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
return reinterpret_cast<uint8_t*>(new_ptr);
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(reinterpret_cast<void*>(ptr));
+}
+
static void SerializeObject(const Instance& obj,
uint8_t** obj_data,
intptr_t* obj_len,
bool allow_any_object) {
- MessageWriter writer(obj_data, &allocator, allow_any_object);
+ MessageWriter writer(obj_data, &malloc_allocator, &malloc_deallocator,
+ allow_any_object);
writer.WriteMessage(obj);
*obj_len = writer.BytesWritten();
}
@@ -193,7 +200,7 @@
msg.SetAt(2, element);
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(msg);
PortMap::PostMessage(new Message(main_port(), data, writer.BytesWritten(),
@@ -1723,7 +1730,7 @@
StopBackgroundCompiler();
#if defined(DEBUG)
- if (heap_ != NULL) {
+ if (heap_ != NULL && FLAG_verify_on_transition) {
// The VM isolate keeps all objects marked.
heap_->Verify(this == Dart::vm_isolate() ? kRequireMarked : kForbidMarked);
}
@@ -2556,7 +2563,7 @@
{
uint8_t* buffer = NULL;
- ApiMessageWriter writer(&buffer, allocator);
+ ApiMessageWriter writer(&buffer, &malloc_allocator);
bool success = writer.WriteCMessage(&kill_msg);
ASSERT(success);
diff --git a/runtime/vm/kernel.h b/runtime/vm/kernel.h
index ea04b73..ebdac48 100644
--- a/runtime/vm/kernel.h
+++ b/runtime/vm/kernel.h
@@ -135,7 +135,6 @@
class Reader;
class TreeNode;
class TypeParameter;
-class Writer;
// Boxes a value of type `T*` and `delete`s it on destruction.
template <typename T>
@@ -199,11 +198,6 @@
template <typename IT>
void ReadFromStatic(Reader* reader);
- void WriteTo(Writer* writer);
-
- template <typename IT>
- void WriteToStatic(Writer* writer);
-
// Extends the array to at least be able to hold [length] elements.
//
// Free places will be filled with `NULL` values.
@@ -240,7 +234,6 @@
class TypeParameterList : public List<TypeParameter> {
public:
void ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
};
@@ -248,7 +241,6 @@
class Tuple {
public:
static Tuple<A, B>* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
Tuple(A* a, B* b) : first_(a), second_(b) {}
@@ -269,8 +261,6 @@
public:
static String* ReadFrom(Reader* reader);
static String* ReadFromImpl(Reader* reader);
- void WriteTo(Writer* writer);
- void WriteToImpl(Writer* writer);
String(const uint8_t* utf8, int length) {
buffer_ = new uint8_t[length];
@@ -295,7 +285,6 @@
class StringTable {
public:
void ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
List<String>& strings() { return strings_; }
@@ -313,7 +302,6 @@
class SourceTable {
public:
void ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
~SourceTable() {
for (intptr_t i = 0; i < size_; ++i) {
delete source_code_[i];
@@ -415,7 +403,6 @@
class Library : public TreeNode {
public:
Library* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Library();
@@ -473,7 +460,6 @@
class Class : public TreeNode {
public:
Class* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Class();
@@ -517,7 +503,6 @@
class NormalClass : public Class {
public:
NormalClass* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~NormalClass();
@@ -556,7 +541,6 @@
class MixinClass : public Class {
public:
MixinClass* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~MixinClass();
@@ -640,7 +624,6 @@
};
Field* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Field();
@@ -683,7 +666,6 @@
};
Constructor* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Constructor();
@@ -734,7 +716,6 @@
};
Procedure* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Procedure();
@@ -771,7 +752,6 @@
class Initializer : public TreeNode {
public:
static Initializer* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer) = 0;
virtual ~Initializer();
@@ -791,7 +771,6 @@
class InvalidInitializer : public Initializer {
public:
static InvalidInitializer* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~InvalidInitializer();
@@ -809,7 +788,6 @@
class FieldInitializer : public Initializer {
public:
static FieldInitializer* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~FieldInitializer();
@@ -834,7 +812,6 @@
class SuperInitializer : public Initializer {
public:
static SuperInitializer* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~SuperInitializer();
@@ -859,7 +836,6 @@
class RedirectingInitializer : public Initializer {
public:
static RedirectingInitializer* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~RedirectingInitializer();
@@ -884,7 +860,6 @@
class LocalInitializer : public Initializer {
public:
static LocalInitializer* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~LocalInitializer();
@@ -915,7 +890,6 @@
};
static FunctionNode* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~FunctionNode();
@@ -962,7 +936,6 @@
class Expression : public TreeNode {
public:
static Expression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer) = 0;
virtual ~Expression();
@@ -984,7 +957,6 @@
class InvalidExpression : public Expression {
public:
static InvalidExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~InvalidExpression();
virtual void VisitChildren(Visitor* visitor);
@@ -1004,7 +976,6 @@
public:
static VariableGet* ReadFrom(Reader* reader);
static VariableGet* ReadFrom(Reader* reader, uint8_t payload);
- virtual void WriteTo(Writer* writer);
virtual ~VariableGet();
@@ -1028,7 +999,6 @@
public:
static VariableSet* ReadFrom(Reader* reader);
static VariableSet* ReadFrom(Reader* reader, uint8_t payload);
- virtual void WriteTo(Writer* writer);
virtual ~VariableSet();
@@ -1053,7 +1023,6 @@
class PropertyGet : public Expression {
public:
static PropertyGet* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~PropertyGet();
@@ -1079,7 +1048,6 @@
class PropertySet : public Expression {
public:
static PropertySet* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~PropertySet();
@@ -1107,7 +1075,6 @@
class DirectPropertyGet : public Expression {
public:
static DirectPropertyGet* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~DirectPropertyGet();
@@ -1132,7 +1099,6 @@
class DirectPropertySet : public Expression {
public:
static DirectPropertySet* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~DirectPropertySet();
@@ -1159,7 +1125,6 @@
class StaticGet : public Expression {
public:
static StaticGet* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~StaticGet();
@@ -1182,7 +1147,6 @@
class StaticSet : public Expression {
public:
static StaticSet* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~StaticSet();
@@ -1207,7 +1171,6 @@
class Arguments : public TreeNode {
public:
static Arguments* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~Arguments();
@@ -1236,7 +1199,6 @@
class NamedExpression : public TreeNode {
public:
static NamedExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
NamedExpression(String* name, Expression* expr)
: name_(name), expression_(expr) {}
@@ -1263,7 +1225,6 @@
class MethodInvocation : public Expression {
public:
static MethodInvocation* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~MethodInvocation();
@@ -1291,7 +1252,6 @@
class DirectMethodInvocation : public Expression {
public:
static DirectMethodInvocation* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~DirectMethodInvocation();
@@ -1318,7 +1278,6 @@
class StaticInvocation : public Expression {
public:
static StaticInvocation* ReadFrom(Reader* reader, bool is_const);
- virtual void WriteTo(Writer* writer);
~StaticInvocation();
virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
@@ -1342,7 +1301,6 @@
class ConstructorInvocation : public Expression {
public:
static ConstructorInvocation* ReadFrom(Reader* reader, bool is_const);
- virtual void WriteTo(Writer* writer);
virtual ~ConstructorInvocation();
@@ -1369,7 +1327,6 @@
class Not : public Expression {
public:
static Not* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~Not();
@@ -1394,7 +1351,6 @@
enum Operator { kAnd, kOr };
static LogicalExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~LogicalExpression();
@@ -1421,7 +1377,6 @@
class ConditionalExpression : public Expression {
public:
static ConditionalExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~ConditionalExpression();
@@ -1448,7 +1403,6 @@
class StringConcatenation : public Expression {
public:
static StringConcatenation* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~StringConcatenation();
@@ -1471,7 +1425,6 @@
class IsExpression : public Expression {
public:
static IsExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~IsExpression();
@@ -1496,7 +1449,6 @@
class AsExpression : public Expression {
public:
static AsExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~AsExpression();
@@ -1531,7 +1483,6 @@
class StringLiteral : public BasicLiteral {
public:
static StringLiteral* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
@@ -1555,7 +1506,6 @@
class BigintLiteral : public StringLiteral {
public:
static BigintLiteral* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
@@ -1575,7 +1525,6 @@
public:
static IntLiteral* ReadFrom(Reader* reader, bool is_negative);
static IntLiteral* ReadFrom(Reader* reader, uint8_t payload);
- virtual void WriteTo(Writer* writer);
virtual ~IntLiteral();
@@ -1597,7 +1546,6 @@
class DoubleLiteral : public BasicLiteral {
public:
static DoubleLiteral* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~DoubleLiteral();
@@ -1619,7 +1567,6 @@
class BoolLiteral : public BasicLiteral {
public:
static BoolLiteral* ReadFrom(Reader* reader, bool value);
- virtual void WriteTo(Writer* writer);
virtual ~BoolLiteral();
@@ -1641,7 +1588,6 @@
class NullLiteral : public BasicLiteral {
public:
static NullLiteral* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~NullLiteral();
@@ -1659,7 +1605,6 @@
class SymbolLiteral : public Expression {
public:
static SymbolLiteral* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~SymbolLiteral();
@@ -1682,7 +1627,6 @@
class TypeLiteral : public Expression {
public:
static TypeLiteral* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~TypeLiteral();
@@ -1705,7 +1649,6 @@
class ThisExpression : public Expression {
public:
static ThisExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~ThisExpression();
@@ -1724,7 +1667,6 @@
class Rethrow : public Expression {
public:
static Rethrow* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~Rethrow();
@@ -1743,7 +1685,6 @@
class Throw : public Expression {
public:
static Throw* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~Throw();
@@ -1766,7 +1707,6 @@
class ListLiteral : public Expression {
public:
static ListLiteral* ReadFrom(Reader* reader, bool is_const);
- virtual void WriteTo(Writer* writer);
virtual ~ListLiteral();
@@ -1793,7 +1733,6 @@
class MapLiteral : public Expression {
public:
static MapLiteral* ReadFrom(Reader* reader, bool is_const);
- virtual void WriteTo(Writer* writer);
virtual ~MapLiteral();
@@ -1822,7 +1761,6 @@
class MapEntry : public TreeNode {
public:
static MapEntry* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~MapEntry();
@@ -1850,7 +1788,6 @@
class AwaitExpression : public Expression {
public:
static AwaitExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~AwaitExpression();
@@ -1873,7 +1810,6 @@
class FunctionExpression : public Expression {
public:
static FunctionExpression* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~FunctionExpression();
@@ -1896,7 +1832,6 @@
class Let : public Expression {
public:
static Let* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~Let();
@@ -1927,7 +1862,6 @@
class Statement : public TreeNode {
public:
static Statement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer) = 0;
virtual ~Statement();
@@ -1949,7 +1883,6 @@
class InvalidStatement : public Statement {
public:
static InvalidStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~InvalidStatement();
@@ -1968,7 +1901,6 @@
class ExpressionStatement : public Statement {
public:
static ExpressionStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
explicit ExpressionStatement(Expression* exp) : expression_(exp) {}
virtual ~ExpressionStatement();
@@ -1992,8 +1924,6 @@
class Block : public Statement {
public:
static Block* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
- void WriteToImpl(Writer* writer);
virtual ~Block();
@@ -2003,11 +1933,13 @@
virtual void VisitChildren(Visitor* visitor);
List<Statement>& statements() { return statements_; }
+ TokenPosition end_position() { return end_position_; }
private:
- Block() {}
+ Block() : end_position_(TokenPosition::kNoSource) {}
List<Statement> statements_;
+ TokenPosition end_position_;
DISALLOW_COPY_AND_ASSIGN(Block);
};
@@ -2016,7 +1948,6 @@
class EmptyStatement : public Statement {
public:
static EmptyStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~EmptyStatement();
@@ -2035,7 +1966,6 @@
class AssertStatement : public Statement {
public:
static AssertStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~AssertStatement();
@@ -2060,7 +1990,6 @@
class LabeledStatement : public Statement {
public:
static LabeledStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~LabeledStatement();
@@ -2083,7 +2012,6 @@
class BreakStatement : public Statement {
public:
static BreakStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~BreakStatement();
@@ -2106,7 +2034,6 @@
class WhileStatement : public Statement {
public:
static WhileStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~WhileStatement();
@@ -2131,7 +2058,6 @@
class DoStatement : public Statement {
public:
static DoStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~DoStatement();
@@ -2156,7 +2082,6 @@
class ForStatement : public Statement {
public:
static ForStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~ForStatement();
@@ -2169,14 +2094,20 @@
Expression* condition() { return condition_; }
List<Expression>& updates() { return updates_; }
Statement* body() { return body_; }
+ TokenPosition position() { return position_; }
+ TokenPosition end_position() { return end_position_; }
private:
- ForStatement() {}
+ ForStatement()
+ : position_(TokenPosition::kNoSource),
+ end_position_(TokenPosition::kNoSource) {}
List<VariableDeclaration> variables_;
Child<Expression> condition_;
List<Expression> updates_;
Child<Statement> body_;
+ TokenPosition position_;
+ TokenPosition end_position_;
DISALLOW_COPY_AND_ASSIGN(ForStatement);
};
@@ -2185,7 +2116,6 @@
class ForInStatement : public Statement {
public:
static ForInStatement* ReadFrom(Reader* reader, bool is_async);
- virtual void WriteTo(Writer* writer);
virtual ~ForInStatement();
@@ -2198,14 +2128,20 @@
Expression* iterable() { return iterable_; }
Statement* body() { return body_; }
bool is_async() { return is_async_; }
+ TokenPosition position() { return position_; }
+ TokenPosition end_position() { return end_position_; }
private:
- ForInStatement() {}
+ ForInStatement()
+ : position_(TokenPosition::kNoSource),
+ end_position_(TokenPosition::kNoSource) {}
Child<VariableDeclaration> variable_;
Child<Expression> iterable_;
Child<Statement> body_;
bool is_async_;
+ TokenPosition position_;
+ TokenPosition end_position_;
DISALLOW_COPY_AND_ASSIGN(ForInStatement);
};
@@ -2214,7 +2150,6 @@
class SwitchStatement : public Statement {
public:
static SwitchStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~SwitchStatement();
@@ -2239,7 +2174,6 @@
class SwitchCase : public TreeNode {
public:
SwitchCase* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~SwitchCase();
@@ -2269,7 +2203,6 @@
class ContinueSwitchStatement : public Statement {
public:
static ContinueSwitchStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~ContinueSwitchStatement();
@@ -2292,7 +2225,6 @@
class IfStatement : public Statement {
public:
static IfStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~IfStatement();
@@ -2319,7 +2251,6 @@
class ReturnStatement : public Statement {
public:
static ReturnStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~ReturnStatement();
@@ -2342,7 +2273,6 @@
class TryCatch : public Statement {
public:
static TryCatch* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~TryCatch();
@@ -2367,7 +2297,6 @@
class Catch : public TreeNode {
public:
static Catch* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Catch();
@@ -2380,9 +2309,13 @@
VariableDeclaration* exception() { return exception_; }
VariableDeclaration* stack_trace() { return stack_trace_; }
Statement* body() { return body_; }
+ TokenPosition position() { return position_; }
+ TokenPosition end_position() { return end_position_; }
private:
- Catch() {}
+ Catch()
+ : position_(TokenPosition::kNoSource),
+ end_position_(TokenPosition::kNoSource) {}
template <typename T>
friend class List;
@@ -2391,6 +2324,8 @@
Child<VariableDeclaration> exception_;
Child<VariableDeclaration> stack_trace_;
Child<Statement> body_;
+ TokenPosition position_;
+ TokenPosition end_position_;
DISALLOW_COPY_AND_ASSIGN(Catch);
};
@@ -2399,7 +2334,6 @@
class TryFinally : public Statement {
public:
static TryFinally* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~TryFinally();
@@ -2428,7 +2362,6 @@
kFlagNative = 1 << 1,
};
static YieldStatement* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~YieldStatement();
@@ -2460,8 +2393,6 @@
static VariableDeclaration* ReadFrom(Reader* reader);
static VariableDeclaration* ReadFromImpl(Reader* reader);
- virtual void WriteTo(Writer* writer);
- void WriteToImpl(Writer* writer);
virtual ~VariableDeclaration();
@@ -2477,9 +2408,10 @@
DartType* type() { return type_; }
InferredValue* inferred_value() { return inferred_value_; }
Expression* initializer() { return initializer_; }
+ TokenPosition end_position() { return end_position_; }
private:
- VariableDeclaration() {}
+ VariableDeclaration() : end_position_(TokenPosition::kNoSource) {}
template <typename T>
friend class List;
@@ -2489,6 +2421,7 @@
Child<DartType> type_;
Child<InferredValue> inferred_value_;
Child<Expression> initializer_;
+ TokenPosition end_position_;
DISALLOW_COPY_AND_ASSIGN(VariableDeclaration);
};
@@ -2497,7 +2430,6 @@
class FunctionDeclaration : public Statement {
public:
static FunctionDeclaration* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer);
virtual ~FunctionDeclaration();
@@ -2522,7 +2454,6 @@
class Name : public Node {
public:
static Name* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Name();
@@ -2535,7 +2466,8 @@
Library* library() { return library_; }
private:
- Name(String* string, Library* library) : string_(string), library_(library) {}
+ Name(String* string, Library* library)
+ : string_(string), library_(library) {} // NOLINT
Ref<String> string_;
Ref<Library> library_;
@@ -2560,7 +2492,6 @@
};
static InferredValue* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~InferredValue();
@@ -2601,7 +2532,6 @@
class DartType : public Node {
public:
static DartType* ReadFrom(Reader* reader);
- virtual void WriteTo(Writer* writer) = 0;
virtual ~DartType();
@@ -2621,7 +2551,6 @@
class InvalidType : public DartType {
public:
static InvalidType* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~InvalidType();
@@ -2640,7 +2569,6 @@
class DynamicType : public DartType {
public:
static DynamicType* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~DynamicType();
@@ -2659,7 +2587,6 @@
class VoidType : public DartType {
public:
static VoidType* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~VoidType();
@@ -2679,7 +2606,6 @@
public:
static InterfaceType* ReadFrom(Reader* reader);
static InterfaceType* ReadFrom(Reader* reader, bool _without_type_arguments_);
- void WriteTo(Writer* writer);
explicit InterfaceType(Class* klass) : klass_(klass) {}
virtual ~InterfaceType();
@@ -2706,7 +2632,6 @@
public:
static FunctionType* ReadFrom(Reader* reader);
static FunctionType* ReadFrom(Reader* reader, bool _without_type_arguments_);
- void WriteTo(Writer* writer);
virtual ~FunctionType();
@@ -2739,7 +2664,6 @@
class TypeParameterType : public DartType {
public:
static TypeParameterType* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~TypeParameterType();
@@ -2762,7 +2686,6 @@
class TypeParameter : public TreeNode {
public:
TypeParameter* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~TypeParameter();
@@ -2791,7 +2714,6 @@
class Program : public TreeNode {
public:
static Program* ReadFrom(Reader* reader);
- void WriteTo(Writer* writer);
virtual ~Program();
@@ -2822,17 +2744,10 @@
class Reference : public AllStatic {
public:
static Member* ReadMemberFrom(Reader* reader, bool allow_null = false);
- static void WriteMemberTo(Writer* writer,
- Member* member,
- bool allow_null = false);
static Class* ReadClassFrom(Reader* reader, bool allow_null = false);
- static void WriteClassTo(Writer* writer,
- Class* klass,
- bool allow_null = false);
static String* ReadStringFrom(Reader* reader);
- static void WriteStringTo(Writer* writer, String* string); // NOLINT
};
@@ -3250,17 +3165,6 @@
kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
intptr_t buffer_length);
-class ByteWriter {
- public:
- virtual ~ByteWriter();
-
- virtual void WriteByte(uint8_t byte) = 0;
-
- virtual void WriteBytes(uint8_t* buffer, int count) = 0;
-};
-
-
-void WritePrecompiledKernel(ByteWriter* out, kernel::Program* program);
} // namespace dart
diff --git a/runtime/vm/kernel_binary.cc b/runtime/vm/kernel_binary.cc
index 4cdc004..1f56c09 100644
--- a/runtime/vm/kernel_binary.cc
+++ b/runtime/vm/kernel_binary.cc
@@ -16,21 +16,13 @@
do { \
if (FLAG_trace_kernel_binary) reader->DumpOffset(DART_PRETTY_FUNCTION); \
} while (0)
-#define TRACE_WRITE_OFFSET() \
- do { \
- if (FLAG_trace_kernel_binary) writer->DumpOffset(DART_PRETTY_FUNCTION); \
- } while (0)
#else
#define TRACE_READ_OFFSET()
-#define TRACE_WRITE_OFFSET()
#endif
namespace dart {
-ByteWriter::~ByteWriter() {}
-
-
namespace kernel {
@@ -372,11 +364,22 @@
}
}
+ /**
+ * Read and return a TokenPosition from this reader.
+ */
TokenPosition ReadPosition() {
- intptr_t value = ReadUInt();
// Position is saved as unsigned,
// but actually ranges from -1 and up (thus the -1)
- return TokenPosition(value - 1);
+ intptr_t value = ReadUInt() - 1;
+ TokenPosition result = TokenPosition(value);
+ max_position_ = Utils::Maximum(max_position_, result);
+ if (min_position_.IsNoSource()) {
+ min_position_ = result;
+ } else if (result.IsReal()) {
+ min_position_ = Utils::Minimum(min_position_, result);
+ }
+
+ return result;
}
intptr_t ReadListLength() { return ReadUInt(); }
@@ -420,6 +423,22 @@
OS::PrintErr("@%" Pd64 " %s\n", offset_, str);
}
+ // The largest position read yet (since last reset).
+ // This is automatically updated when calling ReadPosition,
+ // but can be overwritten (e.g. via the PositionScope class).
+ TokenPosition max_position() { return max_position_; }
+ // The smallest position read yet (since last reset).
+ // This is automatically updated when calling ReadPosition,
+ // but can be overwritten (e.g. via the PositionScope class).
+ TokenPosition min_position() { return min_position_; }
+ // The current script id for what we are currently processing.
+ // Note though that this is only a convenience helper and has to be set
+ // manually.
+ intptr_t current_script_id() { return current_script_id_; }
+ void set_current_script_id(intptr_t script_id) {
+ current_script_id_ = script_id;
+ }
+
template <typename T, typename RT>
T* ReadOptional() {
Tag tag = ReadTag();
@@ -442,185 +461,43 @@
int64_t size_;
int64_t offset_;
ReaderHelper builder_;
+ TokenPosition max_position_;
+ TokenPosition min_position_;
+ intptr_t current_script_id_;
+
+ friend class PositionScope;
};
-class WriterHelper {
+// A helper class that resets the readers min and max positions both upon
+// initialization and upon destruction, i.e. when created the min an max
+// positions will be reset to "noSource", when destructing the min and max will
+// be reset to have they value they would have had, if they hadn't been reset in
+// the first place.
+class PositionScope {
public:
- WriterHelper() : labels_(NULL) {}
-
- void SetProgram(Program* program) {
- program_ = program;
- for (int i = 0; i < program->libraries().length(); i++) {
- Library* lib = program->libraries()[i];
- libraries_.Set(lib, i);
-
- for (int j = 0; j < lib->classes().length(); j++) {
- Class* klass = lib->classes()[j];
- classes_.Set(klass, j);
-
- for (int k = 0; k < klass->fields().length(); k++) {
- Field* field = klass->fields()[k];
- fields_.Set(field, k);
- }
- for (int k = 0; k < klass->constructors().length(); k++) {
- Constructor* constructor = klass->constructors()[k];
- constructors_.Set(constructor, k);
- }
- for (int k = 0; k < klass->procedures().length(); k++) {
- Procedure* procedure = klass->procedures()[k];
- procedures_.Set(procedure, k);
- }
- }
-
- for (int k = 0; k < lib->fields().length(); k++) {
- Field* field = lib->fields()[k];
- fields_.Set(field, k);
- }
-
- for (int k = 0; k < lib->procedures().length(); k++) {
- Procedure* procedure = lib->procedures()[k];
- procedures_.Set(procedure, k);
- }
- }
+ explicit PositionScope(Reader* reader)
+ : reader_(reader),
+ min_(reader->min_position_),
+ max_(reader->max_position_) {
+ reader->min_position_ = reader->max_position_ = TokenPosition::kNoSource;
}
- Program* program() { return program_; }
-
- BlockMap<String>& strings() { return strings_; }
- BlockMap<Library>& libraries() { return libraries_; }
- BlockMap<Class>& classes() { return classes_; }
- BlockMap<Field>& fields() { return fields_; }
- BlockMap<Procedure>& procedures() { return procedures_; }
- BlockMap<Constructor>& constructors() { return constructors_; }
-
- BlockMap<VariableDeclaration>& variables() { return scope_; }
- BlockMap<TypeParameter>& type_parameters() { return type_parameters_; }
- BlockMap<SwitchCase>& switch_cases() { return switch_cases_; }
-
- BlockMap<LabeledStatement>* labels() { return labels_; }
- void set_labels(BlockMap<LabeledStatement>* labels) { labels_ = labels; }
+ ~PositionScope() {
+ if (reader_->min_position_.IsNoSource()) {
+ reader_->min_position_ = min_;
+ } else if (min_.IsReal()) {
+ reader_->min_position_ = Utils::Minimum(reader_->min_position_, min_);
+ }
+ reader_->max_position_ = Utils::Maximum(reader_->max_position_, max_);
+ }
private:
- Program* program_;
-
- BlockMap<String> strings_;
- BlockMap<Library> libraries_;
- BlockMap<Class> classes_;
- BlockMap<Field> fields_;
- BlockMap<Procedure> procedures_;
- BlockMap<Constructor> constructors_;
-
- BlockMap<VariableDeclaration> scope_;
- BlockMap<TypeParameter> type_parameters_;
- BlockMap<SwitchCase> switch_cases_;
- BlockMap<LabeledStatement>* labels_;
+ Reader* reader_;
+ TokenPosition min_;
+ TokenPosition max_;
};
-
-class Writer {
- public:
- explicit Writer(ByteWriter* writer) : out_(writer), offset_(0) {}
-
- void WriteUInt32(uint32_t value) {
- uint8_t buffer[4] = {
- static_cast<uint8_t>((value >> 24) & 0xff),
- static_cast<uint8_t>((value >> 16) & 0xff),
- static_cast<uint8_t>((value >> 8) & 0xff),
- static_cast<uint8_t>((value >> 0) & 0xff),
- };
- WriteBytes(buffer, 4);
- }
-
- void WriteUInt(uint32_t value) {
- if (value < 0x80) {
- // 0...
- WriteByte(static_cast<uint8_t>(value));
- } else if (value < 0x4000) {
- // 10...
- WriteByte(static_cast<uint8_t>(((value >> 8) & 0x3f) | 0x80));
- WriteByte(static_cast<uint8_t>(value & 0xff));
- } else {
- // 11...
- // Ensure the highest 2 bits is not used for anything (we use it to for
- // encoding).
- ASSERT(static_cast<uint8_t>((value >> 24) & 0xc0) == 0);
- uint8_t buffer[4] = {
- static_cast<uint8_t>(((value >> 24) & 0x7f) | 0xc0),
- static_cast<uint8_t>((value >> 16) & 0xff),
- static_cast<uint8_t>((value >> 8) & 0xff),
- static_cast<uint8_t>((value >> 0) & 0xff),
- };
- WriteBytes(buffer, 4);
- }
- }
-
- void WriteListLength(intptr_t value) { return WriteUInt(value); }
-
- void WriteByte(uint8_t value) {
- out_->WriteByte(value);
- offset_++;
- }
-
- void WriteBool(bool value) { WriteByte(value ? 1 : 0); }
-
- void WriteFlags(uint8_t value) { WriteByte(value); }
-
- void WriteTag(Tag tag) { WriteByte(static_cast<uint8_t>(tag)); }
-
- void WriteTag(Tag tag, uint8_t payload) {
- ASSERT((payload & ~kSpecializedPayloadMask) == 0);
- WriteByte(kSpecializedTagHighBit | static_cast<uint8_t>(tag) | payload);
- }
-
- void WriteBytes(uint8_t* bytes, int length) {
- out_->WriteBytes(bytes, length);
- offset_ += length;
- }
-
- void WritePosition(TokenPosition position) {
- intptr_t value = position.value() + 1;
- WriteUInt(value);
- }
-
- template <typename T>
- void WriteOptional(T* object) {
- if (object == NULL) {
- WriteTag(kNothing);
- } else {
- WriteTag(kSomething);
- object->WriteTo(this);
- }
- }
-
- template <typename T, typename WT>
- void WriteOptionalStatic(T* object) {
- if (object == NULL) {
- WriteTag(kNothing);
- } else {
- WriteTag(kSomething);
- WT::WriteTo(this, object);
- }
- }
-
- template <typename T>
- void WriteOptionalStatic(T* object) {
- return WriteOptionalStatic<T, T>(object);
- }
-
- void DumpOffset(const char* str) {
- OS::PrintErr("@%" Pd64 " %s\n", offset_, str);
- }
-
- WriterHelper* helper() { return &helper_; }
-
- private:
- ByteWriter* out_;
- WriterHelper helper_;
- int64_t offset_;
-};
-
-
template <typename T>
template <typename IT>
void List<T>::ReadFrom(Reader* reader, TreeNode* parent) {
@@ -662,36 +539,6 @@
}
}
-
-template <typename T>
-void List<T>::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
-
- // NOTE: We only support dense lists.
- writer->WriteListLength(length_);
- for (int i = 0; i < length_; i++) {
- T* object = array_[i];
- ASSERT(object != NULL);
- object->WriteTo(writer);
- }
-}
-
-
-template <typename T>
-template <typename IT>
-void List<T>::WriteToStatic(Writer* writer) {
- TRACE_WRITE_OFFSET();
-
- // NOTE: We only support dense lists.
- writer->WriteListLength(length_);
- for (int i = 0; i < length_; i++) {
- T* object = array_[i];
- ASSERT(object != NULL);
- IT::WriteTo(writer, object);
- }
-}
-
-
void TypeParameterList::ReadFrom(Reader* reader) {
// It is possible for the bound of the first type parameter to refer to
// the second type parameter. This means we need to create [TypeParameter]
@@ -712,23 +559,6 @@
}
-void TypeParameterList::WriteTo(Writer* writer) {
- writer->WriteListLength(length());
-
- // Make all [TypeParameter]s available in scope.
- for (int i = 0; i < length(); i++) {
- TypeParameter* parameter = (*this)[i];
- writer->helper()->type_parameters().Push(parameter);
- }
-
- // Write all [TypeParameter]s and their bounds.
- for (int i = 0; i < length(); i++) {
- TypeParameter* parameter = (*this)[i];
- parameter->WriteTo(writer);
- }
-}
-
-
template <typename A, typename B>
Tuple<A, B>* Tuple<A, B>::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
@@ -738,14 +568,6 @@
}
-template <typename A, typename B>
-void Tuple<A, B>::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- first_->WriteTo(writer);
- second_->WriteTo(writer);
-}
-
-
template <typename B, typename S>
class DowncastReader {
public:
@@ -762,11 +584,6 @@
TRACE_READ_OFFSET();
return String::ReadFromImpl(reader);
}
-
- static void WriteTo(Writer* writer, String* string) {
- TRACE_WRITE_OFFSET();
- string->WriteToImpl(writer);
- }
};
@@ -776,11 +593,6 @@
TRACE_READ_OFFSET();
return VariableDeclaration::ReadFromImpl(reader);
}
-
- static void WriteTo(Writer* writer, VariableDeclaration* d) {
- TRACE_WRITE_OFFSET();
- d->WriteToImpl(writer);
- }
};
@@ -797,36 +609,11 @@
return string;
}
-
-void String::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- Reference::WriteStringTo(writer, this);
-}
-
-
-void String::WriteToImpl(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteUInt(size_);
- writer->WriteBytes(buffer_, size_);
-}
-
-
void StringTable::ReadFrom(Reader* reader) {
strings_.ReadFromStatic<StringImpl>(reader);
}
-void StringTable::WriteTo(Writer* writer) {
- strings_.WriteToStatic<StringImpl>(writer);
-
- // Build up the "String* -> index" table.
- WriterHelper* helper = writer->helper();
- for (int i = 0; i < strings_.length(); i++) {
- helper->strings().Push(strings_[i]);
- }
-}
-
-
void SourceTable::ReadFrom(Reader* reader) {
size_ = reader->helper()->program()->source_uri_table().strings().length();
source_code_ = new String*[size_];
@@ -848,23 +635,6 @@
}
-void SourceTable::WriteTo(Writer* writer) {
- for (intptr_t i = 0; i < size_; ++i) {
- StringImpl::WriteTo(writer, source_code_[i]);
- intptr_t* line_starts = line_starts_[i];
- intptr_t line_count = line_count_[i];
- writer->WriteUInt(line_count);
-
- intptr_t previous_line_start = 0;
- for (intptr_t j = 0; j < line_count; ++j) {
- intptr_t line_start = line_starts[j];
- writer->WriteUInt(line_start - previous_line_start);
- previous_line_start = line_start;
- }
- }
-}
-
-
Library* Library::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
int flags = reader->ReadFlags();
@@ -872,6 +642,7 @@
name_ = Reference::ReadStringFrom(reader);
import_uri_ = Reference::ReadStringFrom(reader);
source_uri_index_ = reader->ReadUInt();
+ reader->set_current_script_id(source_uri_index_);
int num_classes = reader->ReadUInt();
classes().EnsureInitialized(num_classes);
@@ -893,28 +664,6 @@
}
-void Library::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- name_->WriteTo(writer);
- import_uri_->WriteTo(writer);
- writer->WriteUInt(source_uri_index_);
-
- writer->WriteUInt(classes_.length());
- for (int i = 0; i < classes_.length(); i++) {
- Class* klass = classes_[i];
- if (klass->IsNormalClass()) {
- writer->WriteTag(kNormalClass);
- NormalClass::Cast(klass)->WriteTo(writer);
- } else {
- writer->WriteTag(kMixinClass);
- MixinClass::Cast(klass)->WriteTo(writer);
- }
- }
- fields().WriteTo(writer);
- procedures().WriteTo(writer);
-}
-
-
Class* Class::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
@@ -922,22 +671,13 @@
is_abstract_ = reader->ReadBool();
name_ = Reference::ReadStringFrom(reader);
source_uri_index_ = reader->ReadUInt();
+ reader->set_current_script_id(source_uri_index_);
annotations_.ReadFromStatic<Expression>(reader);
return this;
}
-void Class::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WritePosition(position_);
- writer->WriteBool(is_abstract_);
- name_->WriteTo(writer);
- writer->WriteUInt(source_uri_index_);
- annotations_.WriteTo(writer);
-}
-
-
NormalClass* NormalClass::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Class::ReadFrom(reader);
@@ -957,20 +697,6 @@
}
-void NormalClass::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- Class::WriteTo(writer);
- TypeParameterScope<WriterHelper> scope(writer->helper());
-
- type_parameters().WriteTo(writer);
- writer->WriteOptional<DartType>(super_class_);
- implemented_classes().WriteTo(writer);
- fields_.WriteTo(writer);
- constructors_.WriteTo(writer);
- procedures_.WriteTo(writer);
-}
-
-
MixinClass* MixinClass::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
TypeParameterScope<ReaderHelper> scope(reader->helper());
@@ -986,19 +712,6 @@
}
-void MixinClass::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- TypeParameterScope<WriterHelper> scope(writer->helper());
-
- Class::WriteTo(writer);
- type_parameters_.WriteTo(writer);
- first_->WriteTo(writer);
- second_->WriteTo(writer);
- implemented_classes_.WriteTo(writer);
- constructors_.WriteTo(writer);
-}
-
-
Member* Reference::ReadMemberFrom(Reader* reader, bool allow_null) {
TRACE_READ_OFFSET();
@@ -1051,56 +764,6 @@
}
-void Reference::WriteMemberTo(Writer* writer, Member* member, bool allow_null) {
- TRACE_WRITE_OFFSET();
- if (member == NULL) {
- if (allow_null) {
- writer->WriteTag(kNullReference);
- return;
- } else {
- FATAL("Expected a valid member reference but got `null`");
- }
- }
- TreeNode* node = member->parent();
-
- WriterHelper* helper = writer->helper();
-
- if (node->IsLibrary()) {
- Library* library = Library::Cast(node);
- if (member->IsField()) {
- Field* field = Field::Cast(member);
- writer->WriteTag(kLibraryFieldReference);
- writer->WriteUInt(helper->libraries().Lookup(library));
- writer->WriteUInt(helper->fields().Lookup(field));
- } else {
- Procedure* procedure = Procedure::Cast(member);
- writer->WriteTag(kLibraryProcedureReference);
- writer->WriteUInt(helper->libraries().Lookup(library));
- writer->WriteUInt(helper->procedures().Lookup(procedure));
- }
- } else {
- Class* klass = Class::Cast(node);
-
- if (member->IsField()) {
- Field* field = Field::Cast(member);
- writer->WriteTag(kClassFieldReference);
- Reference::WriteClassTo(writer, klass);
- writer->WriteUInt(helper->fields().Lookup(field));
- } else if (member->IsConstructor()) {
- Constructor* constructor = Constructor::Cast(member);
- writer->WriteTag(kClassConstructorReference);
- Reference::WriteClassTo(writer, klass);
- writer->WriteUInt(helper->constructors().Lookup(constructor));
- } else {
- Procedure* procedure = Procedure::Cast(member);
- writer->WriteTag(kClassProcedureReference);
- Reference::WriteClassTo(writer, klass);
- writer->WriteUInt(helper->procedures().Lookup(procedure));
- }
- }
-}
-
-
Class* Reference::ReadClassFrom(Reader* reader, bool allow_null) {
TRACE_READ_OFFSET();
Program* program = reader->helper()->program();
@@ -1128,40 +791,12 @@
}
-void Reference::WriteClassTo(Writer* writer, Class* klass, bool allow_null) {
- TRACE_WRITE_OFFSET();
- if (klass == NULL) {
- if (allow_null) {
- writer->WriteTag(kNullReference);
- return;
- } else {
- FATAL("Expected a valid class reference but got `null`.");
- }
- }
- if (klass->IsNormalClass()) {
- writer->WriteTag(kNormalClassReference);
- } else {
- ASSERT(klass->IsMixinClass());
- writer->WriteTag(kMixinClassReference);
- }
-
- writer->WriteUInt(writer->helper()->libraries().Lookup(klass->parent()));
- writer->WriteUInt(writer->helper()->classes().Lookup(klass));
-}
-
-
String* Reference::ReadStringFrom(Reader* reader) {
int index = reader->ReadUInt();
return reader->helper()->program()->string_table().strings()[index];
}
-void Reference::WriteStringTo(Writer* writer, String* string) {
- int index = writer->helper()->strings().Lookup(string);
- writer->WriteUInt(index);
-}
-
-
Field* Field::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -1172,6 +807,7 @@
flags_ = reader->ReadFlags();
name_ = Name::ReadFrom(reader);
source_uri_index_ = reader->ReadUInt();
+ reader->set_current_script_id(source_uri_index_);
annotations_.ReadFromStatic<Expression>(reader);
type_ = DartType::ReadFrom(reader);
inferred_value_ = reader->ReadOptional<InferredValue>();
@@ -1180,21 +816,6 @@
}
-void Field::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kField);
- writer->WritePosition(position_);
- writer->WritePosition(end_position_);
- writer->WriteFlags(flags_);
- name_->WriteTo(writer);
- writer->WriteUInt(source_uri_index_);
- annotations_.WriteTo(writer);
- type_->WriteTo(writer);
- writer->WriteOptional<InferredValue>(inferred_value_);
- writer->WriteOptional<Expression>(initializer_);
-}
-
-
Constructor* Constructor::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -1212,21 +833,6 @@
}
-void Constructor::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kConstructor);
-
- writer->WritePosition(position_);
- writer->WritePosition(end_position_);
- VariableScope<WriterHelper> parameters(writer->helper());
- writer->WriteFlags(flags_);
- name_->WriteTo(writer);
- annotations_.WriteTo(writer);
- function_->WriteTo(writer);
- initializers_.WriteTo(writer);
-}
-
-
Procedure* Procedure::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -1239,28 +845,13 @@
flags_ = reader->ReadFlags();
name_ = Name::ReadFrom(reader);
source_uri_index_ = reader->ReadUInt();
+ reader->set_current_script_id(source_uri_index_);
annotations_.ReadFromStatic<Expression>(reader);
function_ = reader->ReadOptional<FunctionNode>();
return this;
}
-void Procedure::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kProcedure);
-
- writer->WritePosition(position_);
- writer->WritePosition(end_position_);
- VariableScope<WriterHelper> parameters(writer->helper());
- writer->WriteByte(kind_);
- writer->WriteFlags(flags_);
- name_->WriteTo(writer);
- writer->WriteUInt(source_uri_index_);
- annotations_.WriteTo(writer);
- writer->WriteOptional<FunctionNode>(function_);
-}
-
-
Initializer* Initializer::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -1288,12 +879,6 @@
}
-void InvalidInitializer::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kInvalidInitializer);
-}
-
-
FieldInitializer* FieldInitializer::ReadFromImpl(Reader* reader) {
TRACE_READ_OFFSET();
FieldInitializer* initializer = new FieldInitializer();
@@ -1303,14 +888,6 @@
}
-void FieldInitializer::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kFieldInitializer);
- Reference::WriteMemberTo(writer, field_);
- value_->WriteTo(writer);
-}
-
-
SuperInitializer* SuperInitializer::ReadFromImpl(Reader* reader) {
TRACE_READ_OFFSET();
SuperInitializer* init = new SuperInitializer();
@@ -1320,14 +897,6 @@
}
-void SuperInitializer::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kSuperInitializer);
- Reference::WriteMemberTo(writer, target_);
- arguments_->WriteTo(writer);
-}
-
-
RedirectingInitializer* RedirectingInitializer::ReadFromImpl(Reader* reader) {
TRACE_READ_OFFSET();
RedirectingInitializer* init = new RedirectingInitializer();
@@ -1337,14 +906,6 @@
}
-void RedirectingInitializer::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kRedirectingInitializer);
- Reference::WriteMemberTo(writer, target_);
- arguments_->WriteTo(writer);
-}
-
-
LocalInitializer* LocalInitializer::ReadFromImpl(Reader* reader) {
TRACE_READ_OFFSET();
LocalInitializer* init = new LocalInitializer();
@@ -1353,13 +914,6 @@
}
-void LocalInitializer::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kLocalInitializer);
- variable_->WriteToImpl(writer);
-}
-
-
Expression* Expression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
uint8_t payload = 0;
@@ -1466,12 +1020,6 @@
}
-void InvalidExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kInvalidExpression);
-}
-
-
VariableGet* VariableGet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
VariableGet* get = new VariableGet();
@@ -1491,21 +1039,6 @@
}
-void VariableGet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- int index = writer->helper()->variables().Lookup(variable_);
- if ((index & kSpecializedPayloadMask) == index) {
- writer->WriteTag(kSpecializedVariableGet, static_cast<uint8_t>(index));
- writer->WritePosition(position_);
- } else {
- writer->WriteTag(kVariableGet);
- writer->WritePosition(position_);
- writer->WriteUInt(index);
- writer->WriteOptional<DartType>(NULL);
- }
-}
-
-
VariableSet* VariableSet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
VariableSet* set = new VariableSet();
@@ -1526,21 +1059,6 @@
}
-void VariableSet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- int index = writer->helper()->variables().Lookup(variable_);
- if ((index & kSpecializedPayloadMask) == index) {
- writer->WriteTag(kSpecializedVariableSet, static_cast<uint8_t>(index));
- writer->WritePosition(position_);
- } else {
- writer->WriteTag(kVariableSet);
- writer->WritePosition(position_);
- writer->WriteUInt(index);
- }
- expression_->WriteTo(writer);
-}
-
-
PropertyGet* PropertyGet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
PropertyGet* get = new PropertyGet();
@@ -1552,16 +1070,6 @@
}
-void PropertyGet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kPropertyGet);
- writer->WritePosition(position_);
- receiver_->WriteTo(writer);
- name_->WriteTo(writer);
- Reference::WriteMemberTo(writer, interfaceTarget_, true);
-}
-
-
PropertySet* PropertySet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
PropertySet* set = new PropertySet();
@@ -1574,17 +1082,6 @@
}
-void PropertySet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kPropertySet);
- writer->WritePosition(position_);
- receiver_->WriteTo(writer);
- name_->WriteTo(writer);
- value_->WriteTo(writer);
- Reference::WriteMemberTo(writer, interfaceTarget_, true);
-}
-
-
DirectPropertyGet* DirectPropertyGet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
DirectPropertyGet* get = new DirectPropertyGet();
@@ -1594,14 +1091,6 @@
}
-void DirectPropertyGet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kDirectPropertyGet);
- receiver_->WriteTo(writer);
- Reference::WriteMemberTo(writer, target_);
-}
-
-
DirectPropertySet* DirectPropertySet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
DirectPropertySet* set = new DirectPropertySet();
@@ -1612,15 +1101,6 @@
}
-void DirectPropertySet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kDirectPropertySet);
- receiver_->WriteTo(writer);
- Reference::WriteMemberTo(writer, target_);
- value_->WriteTo(writer);
-}
-
-
StaticGet* StaticGet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
StaticGet* get = new StaticGet();
@@ -1630,14 +1110,6 @@
}
-void StaticGet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kStaticGet);
- writer->WritePosition(position_);
- Reference::WriteMemberTo(writer, target_);
-}
-
-
StaticSet* StaticSet::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
StaticSet* set = new StaticSet();
@@ -1647,14 +1119,6 @@
}
-void StaticSet::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kStaticSet);
- Reference::WriteMemberTo(writer, target_);
- expression_->WriteTo(writer);
-}
-
-
Arguments* Arguments::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Arguments* arguments = new Arguments();
@@ -1665,14 +1129,6 @@
}
-void Arguments::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- types().WriteTo(writer);
- positional().WriteTo(writer);
- named().WriteTo(writer);
-}
-
-
NamedExpression* NamedExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
String* name = Reference::ReadStringFrom(reader);
@@ -1681,13 +1137,6 @@
}
-void NamedExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- name_->WriteTo(writer);
- expression_->WriteTo(writer);
-}
-
-
MethodInvocation* MethodInvocation::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
MethodInvocation* invocation = new MethodInvocation();
@@ -1700,17 +1149,6 @@
}
-void MethodInvocation::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kMethodInvocation);
- writer->WritePosition(position_);
- receiver_->WriteTo(writer);
- name_->WriteTo(writer);
- arguments_->WriteTo(writer);
- Reference::WriteMemberTo(writer, interfaceTarget_, true);
-}
-
-
DirectMethodInvocation* DirectMethodInvocation::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
DirectMethodInvocation* invocation = new DirectMethodInvocation();
@@ -1721,15 +1159,6 @@
}
-void DirectMethodInvocation::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kDirectMethodInvocation);
- receiver_->WriteTo(writer);
- Reference::WriteMemberTo(writer, target_);
- arguments_->WriteTo(writer);
-}
-
-
StaticInvocation* StaticInvocation::ReadFrom(Reader* reader, bool is_const) {
TRACE_READ_OFFSET();
StaticInvocation* invocation = new StaticInvocation();
@@ -1741,15 +1170,6 @@
}
-void StaticInvocation::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(is_const_ ? kConstStaticInvocation : kStaticInvocation);
- writer->WritePosition(position_);
- Reference::WriteMemberTo(writer, procedure_);
- arguments_->WriteTo(writer);
-}
-
-
ConstructorInvocation* ConstructorInvocation::ReadFrom(Reader* reader,
bool is_const) {
TRACE_READ_OFFSET();
@@ -1762,16 +1182,6 @@
}
-void ConstructorInvocation::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(is_const_ ? kConstConstructorInvocation
- : kConstructorInvocation);
- writer->WritePosition(position_);
- Reference::WriteMemberTo(writer, target_);
- arguments_->WriteTo(writer);
-}
-
-
Not* Not::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Not* n = new Not();
@@ -1780,13 +1190,6 @@
}
-void Not::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kNot);
- expression_->WriteTo(writer);
-}
-
-
LogicalExpression* LogicalExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
LogicalExpression* expr = new LogicalExpression();
@@ -1797,15 +1200,6 @@
}
-void LogicalExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kLogicalExpression);
- left_->WriteTo(writer);
- writer->WriteByte(operator_);
- right_->WriteTo(writer);
-}
-
-
ConditionalExpression* ConditionalExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
ConditionalExpression* expr = new ConditionalExpression();
@@ -1817,16 +1211,6 @@
}
-void ConditionalExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kConditionalExpression);
- condition_->WriteTo(writer);
- then_->WriteTo(writer);
- otherwise_->WriteTo(writer);
- writer->WriteOptional<DartType>(NULL); // Unused static type.
-}
-
-
StringConcatenation* StringConcatenation::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
StringConcatenation* concat = new StringConcatenation();
@@ -1836,14 +1220,6 @@
}
-void StringConcatenation::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kStringConcatenation);
- writer->WritePosition(position_);
- expressions_.WriteTo(writer);
-}
-
-
IsExpression* IsExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
IsExpression* expr = new IsExpression();
@@ -1854,15 +1230,6 @@
}
-void IsExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kIsExpression);
- writer->WritePosition(position_);
- operand_->WriteTo(writer);
- type_->WriteTo(writer);
-}
-
-
AsExpression* AsExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
AsExpression* expr = new AsExpression();
@@ -1872,40 +1239,18 @@
}
-void AsExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kAsExpression);
- operand_->WriteTo(writer);
- type_->WriteTo(writer);
-}
-
-
StringLiteral* StringLiteral::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new StringLiteral(Reference::ReadStringFrom(reader));
}
-void StringLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kStringLiteral);
- value_->WriteTo(writer);
-}
-
-
BigintLiteral* BigintLiteral::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new BigintLiteral(Reference::ReadStringFrom(reader));
}
-void BigintLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kBigIntLiteral);
- value_->WriteTo(writer);
-}
-
-
IntLiteral* IntLiteral::ReadFrom(Reader* reader, bool is_negative) {
TRACE_READ_OFFSET();
IntLiteral* literal = new IntLiteral();
@@ -1923,18 +1268,6 @@
}
-void IntLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- int64_t payload = value_ + SpecializedIntLiteralBias;
- if ((payload & kSpecializedPayloadMask) == payload) {
- writer->WriteTag(kSpecialIntLiteral, static_cast<uint8_t>(payload));
- } else {
- writer->WriteTag(value_ < 0 ? kNegativeIntLiteral : kPositiveIntLiteral);
- writer->WriteUInt(static_cast<uint32_t>(value_ < 0 ? -value_ : value_));
- }
-}
-
-
DoubleLiteral* DoubleLiteral::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
DoubleLiteral* literal = new DoubleLiteral();
@@ -1943,13 +1276,6 @@
}
-void DoubleLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kDoubleLiteral);
- value_->WriteTo(writer);
-}
-
-
BoolLiteral* BoolLiteral::ReadFrom(Reader* reader, bool value) {
TRACE_READ_OFFSET();
BoolLiteral* lit = new BoolLiteral();
@@ -1958,24 +1284,12 @@
}
-void BoolLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(value_ ? kTrueLiteral : kFalseLiteral);
-}
-
-
NullLiteral* NullLiteral::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new NullLiteral();
}
-void NullLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kNullLiteral);
-}
-
-
SymbolLiteral* SymbolLiteral::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
SymbolLiteral* lit = new SymbolLiteral();
@@ -1984,13 +1298,6 @@
}
-void SymbolLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kSymbolLiteral);
- value_->WriteTo(writer);
-}
-
-
TypeLiteral* TypeLiteral::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
TypeLiteral* literal = new TypeLiteral();
@@ -1999,37 +1306,18 @@
}
-void TypeLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kTypeLiteral);
- type_->WriteTo(writer);
-}
-
-
ThisExpression* ThisExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new ThisExpression();
}
-void ThisExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kThisExpression);
-}
-
-
Rethrow* Rethrow::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new Rethrow();
}
-void Rethrow::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kRethrow);
-}
-
-
Throw* Throw::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Throw* t = new Throw();
@@ -2039,14 +1327,6 @@
}
-void Throw::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kThrow);
- writer->WritePosition(position_);
- expression_->WriteTo(writer);
-}
-
-
ListLiteral* ListLiteral::ReadFrom(Reader* reader, bool is_const) {
TRACE_READ_OFFSET();
ListLiteral* literal = new ListLiteral();
@@ -2057,14 +1337,6 @@
}
-void ListLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(is_const_ ? kConstListLiteral : kListLiteral);
- type_->WriteTo(writer);
- expressions_.WriteTo(writer);
-}
-
-
MapLiteral* MapLiteral::ReadFrom(Reader* reader, bool is_const) {
TRACE_READ_OFFSET();
MapLiteral* literal = new MapLiteral();
@@ -2077,16 +1349,6 @@
}
-void MapLiteral::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(is_const_ ? kConstMapLiteral : kMapLiteral);
- writer->WritePosition(position_);
- key_type_->WriteTo(writer);
- value_type_->WriteTo(writer);
- entries_.WriteTo(writer);
-}
-
-
MapEntry* MapEntry::ReadFrom(Reader* reader) {
MapEntry* entry = new MapEntry();
entry->key_ = Expression::ReadFrom(reader);
@@ -2095,13 +1357,6 @@
}
-void MapEntry::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- key_->WriteTo(writer);
- value_->WriteTo(writer);
-}
-
-
AwaitExpression* AwaitExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
AwaitExpression* await = new AwaitExpression();
@@ -2110,13 +1365,6 @@
}
-void AwaitExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kAwaitExpression);
- operand_->WriteTo(writer);
-}
-
-
FunctionExpression* FunctionExpression::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
VariableScope<ReaderHelper> parameters(reader->helper());
@@ -2126,33 +1374,21 @@
}
-void FunctionExpression::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- VariableScope<WriterHelper> parameters(writer->helper());
- writer->WriteTag(kFunctionExpression);
- function_->WriteTo(writer);
-}
-
-
Let* Let::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
VariableScope<ReaderHelper> vars(reader->helper());
+ PositionScope scope(reader);
+
Let* let = new Let();
let->variable_ = VariableDeclaration::ReadFromImpl(reader);
let->body_ = Expression::ReadFrom(reader);
+ let->position_ = reader->min_position();
+ let->end_position_ = reader->max_position();
+
return let;
}
-void Let::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- VariableScope<WriterHelper> vars(writer->helper());
- writer->WriteTag(kLet);
- variable_->WriteToImpl(writer);
- body_->WriteTo(writer);
-}
-
-
Statement* Statement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -2212,59 +1448,32 @@
}
-void InvalidStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kInvalidStatement);
-}
-
-
ExpressionStatement* ExpressionStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new ExpressionStatement(Expression::ReadFrom(reader));
}
-void ExpressionStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kExpressionStatement);
- expression_->WriteTo(writer);
-}
-
-
Block* Block::ReadFromImpl(Reader* reader) {
TRACE_READ_OFFSET();
+ PositionScope scope(reader);
+
VariableScope<ReaderHelper> vars(reader->helper());
Block* block = new Block();
block->statements().ReadFromStatic<Statement>(reader);
+ block->position_ = reader->min_position();
+ block->end_position_ = reader->max_position();
+
return block;
}
-void Block::WriteTo(Writer* writer) {
- writer->WriteTag(kBlock);
- WriteToImpl(writer);
-}
-
-
-void Block::WriteToImpl(Writer* writer) {
- TRACE_WRITE_OFFSET();
- VariableScope<WriterHelper> vars(writer->helper());
- statements_.WriteTo(writer);
-}
-
-
EmptyStatement* EmptyStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new EmptyStatement();
}
-void EmptyStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kEmptyStatement);
-}
-
-
AssertStatement* AssertStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
AssertStatement* stmt = new AssertStatement();
@@ -2274,14 +1483,6 @@
}
-void AssertStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kAssertStatement);
- condition_->WriteTo(writer);
- writer->WriteOptional<Expression>(message_);
-}
-
-
LabeledStatement* LabeledStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
LabeledStatement* stmt = new LabeledStatement();
@@ -2292,15 +1493,6 @@
}
-void LabeledStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kLabeledStatement);
- writer->helper()->labels()->Push(this);
- body_->WriteTo(writer);
- writer->helper()->labels()->Pop(this);
-}
-
-
BreakStatement* BreakStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
BreakStatement* stmt = new BreakStatement();
@@ -2309,13 +1501,6 @@
}
-void BreakStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kBreakStatement);
- writer->WriteUInt(writer->helper()->labels()->Lookup(target_));
-}
-
-
WhileStatement* WhileStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
WhileStatement* stmt = new WhileStatement();
@@ -2325,14 +1510,6 @@
}
-void WhileStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kWhileStatement);
- condition_->WriteTo(writer);
- body_->WriteTo(writer);
-}
-
-
DoStatement* DoStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
DoStatement* dostmt = new DoStatement();
@@ -2342,59 +1519,40 @@
}
-void DoStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kDoStatement);
- body_->WriteTo(writer);
- condition_->WriteTo(writer);
-}
-
-
ForStatement* ForStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
VariableScope<ReaderHelper> vars(reader->helper());
+ PositionScope scope(reader);
+
ForStatement* forstmt = new ForStatement();
forstmt->variables_.ReadFromStatic<VariableDeclarationImpl>(reader);
forstmt->condition_ = reader->ReadOptional<Expression>();
forstmt->updates_.ReadFromStatic<Expression>(reader);
forstmt->body_ = Statement::ReadFrom(reader);
+ forstmt->end_position_ = reader->max_position();
+ forstmt->position_ = reader->min_position();
+
return forstmt;
}
-void ForStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kForStatement);
- VariableScope<WriterHelper> vars(writer->helper());
- variables_.WriteToStatic<VariableDeclarationImpl>(writer);
- writer->WriteOptional<Expression>(condition_);
- updates_.WriteTo(writer);
- body_->WriteTo(writer);
-}
-
-
ForInStatement* ForInStatement::ReadFrom(Reader* reader, bool is_async) {
TRACE_READ_OFFSET();
VariableScope<ReaderHelper> vars(reader->helper());
+ PositionScope scope(reader);
+
ForInStatement* forinstmt = new ForInStatement();
forinstmt->is_async_ = is_async;
forinstmt->variable_ = VariableDeclaration::ReadFromImpl(reader);
forinstmt->iterable_ = Expression::ReadFrom(reader);
forinstmt->body_ = Statement::ReadFrom(reader);
+ forinstmt->end_position_ = reader->max_position();
+ forinstmt->position_ = reader->min_position();
+
return forinstmt;
}
-void ForInStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(is_async_ ? kAsyncForInStatement : kForInStatement);
- VariableScope<WriterHelper> vars(writer->helper());
- variable_->WriteToImpl(writer);
- iterable_->WriteTo(writer);
- body_->WriteTo(writer);
-}
-
-
SwitchStatement* SwitchStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
SwitchCaseScope<ReaderHelper> scope(reader->helper());
@@ -2416,18 +1574,6 @@
}
-void SwitchStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- SwitchCaseScope<WriterHelper> scope(writer->helper());
- writer->WriteTag(kSwitchStatement);
- condition_->WriteTo(writer);
- for (int i = 0; i < cases_.length(); i++) {
- writer->helper()->switch_cases().Push(cases_[i]);
- }
- cases_.WriteTo(writer);
-}
-
-
SwitchCase* SwitchCase::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
expressions_.ReadFromStatic<Expression>(reader);
@@ -2437,14 +1583,6 @@
}
-void SwitchCase::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- expressions_.WriteTo(writer);
- writer->WriteBool(is_default_);
- body_->WriteTo(writer);
-}
-
-
ContinueSwitchStatement* ContinueSwitchStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
ContinueSwitchStatement* stmt = new ContinueSwitchStatement();
@@ -2453,13 +1591,6 @@
}
-void ContinueSwitchStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kContinueSwitchStatement);
- writer->WriteUInt(writer->helper()->switch_cases().Lookup(target_));
-}
-
-
IfStatement* IfStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
IfStatement* ifstmt = new IfStatement();
@@ -2470,15 +1601,6 @@
}
-void IfStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kIfStatement);
- condition_->WriteTo(writer);
- then_->WriteTo(writer);
- otherwise_->WriteTo(writer);
-}
-
-
ReturnStatement* ReturnStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
ReturnStatement* ret = new ReturnStatement();
@@ -2488,34 +1610,24 @@
}
-void ReturnStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kReturnStatement);
- writer->WritePosition(position_);
- writer->WriteOptional<Expression>(expression_);
-}
-
-
TryCatch* TryCatch::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
+ PositionScope scope(reader);
+
TryCatch* tc = new TryCatch();
tc->body_ = Statement::ReadFrom(reader);
tc->catches_.ReadFromStatic<Catch>(reader);
+ tc->position_ = reader->min_position();
+
return tc;
}
-void TryCatch::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kTryCatch);
- body_->WriteTo(writer);
- catches_.WriteTo(writer);
-}
-
-
Catch* Catch::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
VariableScope<ReaderHelper> vars(reader->helper());
+ PositionScope scope(reader);
+
Catch* c = new Catch();
c->guard_ = DartType::ReadFrom(reader);
c->exception_ =
@@ -2523,22 +1635,13 @@
c->stack_trace_ =
reader->ReadOptional<VariableDeclaration, VariableDeclarationImpl>();
c->body_ = Statement::ReadFrom(reader);
+ c->end_position_ = reader->max_position();
+ c->position_ = reader->min_position();
+
return c;
}
-void Catch::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- VariableScope<WriterHelper> vars(writer->helper());
- guard_->WriteTo(writer);
- writer->WriteOptionalStatic<VariableDeclaration, VariableDeclarationImpl>(
- exception_);
- writer->WriteOptionalStatic<VariableDeclaration, VariableDeclarationImpl>(
- stack_trace_);
- body_->WriteTo(writer);
-}
-
-
TryFinally* TryFinally::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
TryFinally* tf = new TryFinally();
@@ -2548,14 +1651,6 @@
}
-void TryFinally::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kTryFinally);
- body_->WriteTo(writer);
- finalizer_->WriteTo(writer);
-}
-
-
YieldStatement* YieldStatement::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
YieldStatement* stmt = new YieldStatement();
@@ -2566,15 +1661,6 @@
}
-void YieldStatement::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kYieldStatement);
- writer->WritePosition(position_);
- writer->WriteByte(flags_);
- expression_->WriteTo(writer);
-}
-
-
VariableDeclaration* VariableDeclaration::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -2585,6 +1671,8 @@
VariableDeclaration* VariableDeclaration::ReadFromImpl(Reader* reader) {
TRACE_READ_OFFSET();
+ PositionScope scope(reader);
+
VariableDeclaration* decl = new VariableDeclaration();
decl->position_ = reader->ReadPosition();
decl->flags_ = reader->ReadFlags();
@@ -2592,30 +1680,18 @@
decl->type_ = DartType::ReadFrom(reader);
decl->inferred_value_ = reader->ReadOptional<InferredValue>();
decl->initializer_ = reader->ReadOptional<Expression>();
+
+ // Go to next token position so it ends *after* the last potentially
+ // debuggable position in the initializer.
+ TokenPosition position = reader->max_position();
+ if (position.IsReal()) position.Next();
+ decl->end_position_ = position;
reader->helper()->variables().Push(decl);
+
return decl;
}
-void VariableDeclaration::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kVariableDeclaration);
- WriteToImpl(writer);
-}
-
-
-void VariableDeclaration::WriteToImpl(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WritePosition(position_);
- writer->WriteFlags(flags_);
- name_->WriteTo(writer);
- type_->WriteTo(writer);
- writer->WriteOptional<InferredValue>(inferred_value_);
- writer->WriteOptional<Expression>(initializer_);
- writer->helper()->variables().Push(this);
-}
-
-
FunctionDeclaration* FunctionDeclaration::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
FunctionDeclaration* decl = new FunctionDeclaration();
@@ -2627,16 +1703,6 @@
}
-void FunctionDeclaration::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kFunctionDeclaration);
- writer->WritePosition(position_);
- variable_->WriteToImpl(writer);
- VariableScope<WriterHelper> parameters(writer->helper());
- function_->WriteTo(writer);
-}
-
-
Name* Name::ReadFrom(Reader* reader) {
String* string = Reference::ReadStringFrom(reader);
if (string->size() >= 1 && string->buffer()[0] == '_') {
@@ -2651,17 +1717,6 @@
}
-void Name::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- string_->WriteTo(writer);
- Library* library = library_;
- bool is_private = library != NULL;
- if (is_private) {
- writer->WriteUInt(writer->helper()->libraries().Lookup(library_));
- }
-}
-
-
InferredValue* InferredValue::ReadFrom(Reader* reader) {
InferredValue* type = new InferredValue();
type->klass_ = Reference::ReadClassFrom(reader, true);
@@ -2671,13 +1726,6 @@
}
-void InferredValue::WriteTo(Writer* writer) {
- Reference::WriteClassTo(writer, klass_, true);
- writer->WriteByte(static_cast<uint8_t>(kind_));
- writer->WriteByte(value_bits_);
-}
-
-
DartType* DartType::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Tag tag = reader->ReadTag();
@@ -2712,36 +1760,18 @@
}
-void InvalidType::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kInvalidType);
-}
-
-
DynamicType* DynamicType::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new DynamicType();
}
-void DynamicType::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kDynamicType);
-}
-
-
VoidType* VoidType::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
return new VoidType();
}
-void VoidType::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kVoidType);
-}
-
-
InterfaceType* InterfaceType::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
Class* klass = Reference::ReadClassFrom(reader);
@@ -2761,19 +1791,6 @@
}
-void InterfaceType::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- if (type_arguments_.length() == 0) {
- writer->WriteTag(kSimpleInterfaceType);
- Reference::WriteClassTo(writer, klass_);
- } else {
- writer->WriteTag(kInterfaceType);
- Reference::WriteClassTo(writer, klass_);
- type_arguments_.WriteTo(writer);
- }
-}
-
-
FunctionType* FunctionType::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
FunctionType* type = new FunctionType();
@@ -2798,28 +1815,6 @@
}
-void FunctionType::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
-
- bool is_simple =
- positional_parameters_.length() == required_parameter_count_ &&
- type_parameters_.length() == 0 && named_parameters_.length() == 0;
- if (is_simple) {
- writer->WriteTag(kSimpleFunctionType);
- positional_parameters_.WriteTo(writer);
- return_type_->WriteTo(writer);
- } else {
- TypeParameterScope<WriterHelper> scope(writer->helper());
- writer->WriteTag(kFunctionType);
- type_parameters_.WriteTo(writer);
- writer->WriteUInt(required_parameter_count_);
- positional_parameters_.WriteTo(writer);
- named_parameters_.WriteTo(writer);
- return_type_->WriteTo(writer);
- }
-}
-
-
TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
TypeParameterType* type = new TypeParameterType();
@@ -2829,13 +1824,6 @@
}
-void TypeParameterType::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- writer->WriteTag(kTypeParameterType);
- writer->WriteUInt(writer->helper()->type_parameters().Lookup(parameter_));
-}
-
-
Program* Program::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
uint32_t magic = reader->ReadUInt32();
@@ -2860,24 +1848,6 @@
}
-void Program::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
-
- writer->helper()->SetProgram(this);
-
- writer->WriteUInt32(kMagicProgramFile);
-
- // NOTE: Currently we don't GC strings and we require that all referenced
- // strings in nodes are present in [string_table_].
- string_table_.WriteTo(writer);
- source_uri_table_.WriteTo(writer);
- source_table_.WriteTo(writer);
-
- libraries_.WriteTo(writer);
- Reference::WriteMemberTo(writer, main_method_);
-}
-
-
FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
TypeParameterScope<ReaderHelper> scope(reader->helper());
@@ -2904,28 +1874,6 @@
}
-void FunctionNode::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- TypeParameterScope<WriterHelper> scope(writer->helper());
-
- writer->WritePosition(position_);
- writer->WritePosition(end_position_);
- writer->WriteByte(static_cast<uint8_t>(async_marker_));
- writer->WriteByte(debuggable_ ? 1 : 0);
- type_parameters().WriteTo(writer);
- writer->WriteUInt(required_parameter_count());
- positional_parameters().WriteToStatic<VariableDeclarationImpl>(writer);
- named_parameters().WriteToStatic<VariableDeclarationImpl>(writer);
- return_type_->WriteTo(writer);
- writer->WriteOptional<InferredValue>(inferred_return_value_);
-
- LabelScope<WriterHelper, BlockMap<LabeledStatement> > labels(
- writer->helper());
- VariableScope<WriterHelper> vars(writer->helper());
- writer->WriteOptional<Statement>(body_);
-}
-
-
TypeParameter* TypeParameter::ReadFrom(Reader* reader) {
TRACE_READ_OFFSET();
name_ = Reference::ReadStringFrom(reader);
@@ -2934,13 +1882,6 @@
}
-void TypeParameter::WriteTo(Writer* writer) {
- TRACE_WRITE_OFFSET();
- name_->WriteTo(writer);
- bound_->WriteTo(writer);
-}
-
-
} // namespace kernel
@@ -2951,13 +1892,5 @@
}
-void WritePrecompiledKernel(ByteWriter* byte_writer, kernel::Program* program) {
- ASSERT(byte_writer != NULL);
-
- kernel::Writer writer(byte_writer);
- program->WriteTo(&writer);
-}
-
-
} // namespace dart
#endif // !defined(DART_PRECOMPILED_RUNTIME)
diff --git a/runtime/vm/kernel_reader.cc b/runtime/vm/kernel_reader.cc
index 8a23a7d..11daaa3 100644
--- a/runtime/vm/kernel_reader.cc
+++ b/runtime/vm/kernel_reader.cc
@@ -325,8 +325,8 @@
false, // is_abstract
kernel_constructor->IsExternal(),
false, // is_native
- klass, TokenPosition::kMinSource));
- function.set_end_token_pos(TokenPosition::kMinSource);
+ klass, kernel_constructor->position()));
+ function.set_end_token_pos(kernel_constructor->end_position());
klass.AddFunction(function);
function.set_kernel_function(kernel_constructor);
function.set_result_type(T.ReceiverType(klass));
@@ -403,11 +403,11 @@
false, // is_const
is_abstract, is_external,
native_name != NULL, // is_native
- script_class, TokenPosition::kMinSource));
- function.set_end_token_pos(TokenPosition::kMinSource);
+ script_class, kernel_procedure->position()));
+ function.set_end_token_pos(kernel_procedure->end_position());
owner.AddFunction(function);
function.set_kernel_function(kernel_procedure);
- function.set_is_debuggable(false);
+ function.set_is_debuggable(kernel_procedure->function()->debuggable());
if (native_name != NULL) {
function.set_native_name(*native_name);
}
@@ -504,6 +504,7 @@
false, // is_native
script_class, kernel_field->position()));
klass.AddFunction(getter);
+ getter.set_end_token_pos(kernel_field->end_position());
getter.set_kernel_function(kernel_field);
getter.set_result_type(AbstractType::Handle(Z, field.type()));
getter.set_is_debuggable(false);
@@ -522,6 +523,7 @@
false, // is_native
script_class, kernel_field->position()));
klass.AddFunction(setter);
+ setter.set_end_token_pos(kernel_field->end_position());
setter.set_kernel_function(kernel_field);
setter.set_result_type(Object::void_type());
setter.set_is_debuggable(false);
@@ -639,6 +641,7 @@
if (handle->IsNull()) {
*handle = dart::Library::New(url);
handle->Register(thread_);
+ handle->SetName(H.DartSymbol(library->name()));
}
ASSERT(!handle->IsNull());
libraries_.Insert(library, handle);
@@ -659,7 +662,7 @@
// optimized.
Script& script = ScriptAt(klass->source_uri_index());
handle = &dart::Class::Handle(
- Z, dart::Class::New(library, name, script, TokenPosition::kNoSource));
+ Z, dart::Class::New(library, name, script, klass->position()));
library.AddClass(*handle);
} else if (handle->script() == Script::null()) {
// When bootstrapping we can encounter classes that do not yet have a
diff --git a/runtime/vm/kernel_to_il.cc b/runtime/vm/kernel_to_il.cc
index 9745cd3..22299a8 100644
--- a/runtime/vm/kernel_to_il.cc
+++ b/runtime/vm/kernel_to_il.cc
@@ -58,21 +58,24 @@
}
-void ScopeBuilder::EnterScope(TreeNode* node) {
+void ScopeBuilder::EnterScope(TreeNode* node, TokenPosition start_position) {
scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
+ scope_->set_begin_token_pos(start_position);
result_->scopes.Insert(node, scope_);
}
-void ScopeBuilder::ExitScope() {
+void ScopeBuilder::ExitScope(TokenPosition end_position) {
+ scope_->set_end_token_pos(end_position);
scope_ = scope_->parent();
}
-LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name,
+LocalVariable* ScopeBuilder::MakeVariable(TokenPosition declaration_pos,
+ TokenPosition token_pos,
+ const dart::String& name,
const AbstractType& type) {
- return new (Z) LocalVariable(TokenPosition::kNoSource,
- TokenPosition::kNoSource, name, type);
+ return new (Z) LocalVariable(declaration_pos, token_pos, name, type);
}
@@ -90,8 +93,9 @@
void ScopeBuilder::AddParameter(VariableDeclaration* declaration,
intptr_t pos) {
- LocalVariable* variable = MakeVariable(H.DartSymbol(declaration->name()),
- T.TranslateVariableType(declaration));
+ LocalVariable* variable = MakeVariable(
+ declaration->position(), declaration->position(),
+ H.DartSymbol(declaration->name()), T.TranslateVariableType(declaration));
if (declaration->IsFinal()) {
variable->set_is_final();
}
@@ -138,7 +142,8 @@
// If variable was not lifted by the transformer introduce a new
// one into the current function scope.
if (v == NULL) {
- v = MakeVariable(GenerateName(prefix, nesting_depth - 1),
+ v = MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ GenerateName(prefix, nesting_depth - 1),
AbstractType::dynamic_type());
// If transformer did not lift the variable then there is no need
@@ -171,7 +176,8 @@
ASSERT(result_->iterator_variables.length() == depth_.for_in_ - 1);
LocalVariable* iterator =
- MakeVariable(GenerateName(":iterator", depth_.for_in_ - 1),
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ GenerateName(":iterator", depth_.for_in_ - 1),
AbstractType::dynamic_type());
current_function_scope_->AddVariable(iterator);
result_->iterator_variables.Add(iterator);
@@ -237,7 +243,8 @@
? GenerateName(":var", name_index_++)
: H.DartSymbol(declaration->name());
LocalVariable* variable =
- MakeVariable(name, T.TranslateVariableType(declaration));
+ MakeVariable(declaration->position(), declaration->end_position(), name,
+ T.TranslateVariableType(declaration));
if (declaration->IsFinal()) {
variable->set_is_final();
}
@@ -287,6 +294,8 @@
ContextScope::Handle(Z, function.context_scope()));
}
current_function_scope_ = scope_ = new (Z) LocalScope(enclosing_scope, 0, 0);
+ scope_->set_begin_token_pos(function.token_pos());
+ scope_->set_end_token_pos(function.end_token_pos());
LocalVariable* context_var = parsed_function->current_context_var();
context_var->set_is_forced_stack();
@@ -314,8 +323,9 @@
intptr_t pos = 0;
if (function.IsClosureFunction()) {
- LocalVariable* variable = MakeVariable(Symbols::ClosureParameter(),
- AbstractType::dynamic_type());
+ LocalVariable* variable = MakeVariable(
+ TokenPosition::kNoSource, TokenPosition::kNoSource,
+ Symbols::ClosureParameter(), AbstractType::dynamic_type());
variable->set_is_forced_stack();
scope_->InsertParameterAt(pos++, variable);
} else if (!function.is_static()) {
@@ -323,7 +333,9 @@
// returns `false` for constructors.
dart::Class& klass = dart::Class::Handle(Z, function.Owner());
Type& klass_type = H.GetCanonicalType(klass);
- LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
+ LocalVariable* variable =
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ Symbols::This(), klass_type);
scope_->InsertParameterAt(pos++, variable);
result_->this_variable = variable;
@@ -335,14 +347,15 @@
for (intptr_t i = 0; i < klass->fields().length(); i++) {
Field* field = klass->fields()[i];
if (!field->IsStatic() && (field->initializer() != NULL)) {
- EnterScope(field);
+ EnterScope(field, field->position());
field->initializer()->AcceptExpressionVisitor(this);
- ExitScope();
+ ExitScope(field->end_position());
}
}
}
} else if (function.IsFactory()) {
LocalVariable* variable = MakeVariable(
+ TokenPosition::kNoSource, TokenPosition::kNoSource,
Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
scope_->InsertParameterAt(pos++, variable);
result_->type_arguments_variable = variable;
@@ -371,13 +384,16 @@
if (is_method) {
dart::Class& klass = dart::Class::Handle(Z, function.Owner());
Type& klass_type = H.GetCanonicalType(klass);
- LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
+ LocalVariable* variable =
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ Symbols::This(), klass_type);
scope_->InsertParameterAt(pos++, variable);
result_->this_variable = variable;
}
if (is_setter) {
result_->setter_value =
- MakeVariable(Symbols::Value(), AbstractType::dynamic_type());
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ Symbols::Value(), AbstractType::dynamic_type());
scope_->InsertParameterAt(pos++, result_->setter_value);
}
break;
@@ -389,7 +405,9 @@
// Therefore, it isn't necessary to mark it as captured here.
dart::Class& klass = dart::Class::Handle(Z, function.Owner());
Type& klass_type = H.GetCanonicalType(klass);
- LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
+ LocalVariable* variable =
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ Symbols::This(), klass_type);
scope_->InsertParameterAt(0, variable);
result_->this_variable = variable;
break;
@@ -398,6 +416,7 @@
case RawFunction::kInvokeFieldDispatcher:
for (intptr_t i = 0; i < function.NumParameters(); ++i) {
LocalVariable* variable = MakeVariable(
+ TokenPosition::kNoSource, TokenPosition::kNoSource,
dart::String::ZoneHandle(Z, function.ParameterNameAt(i)),
AbstractType::dynamic_type());
scope_->InsertParameterAt(i, variable);
@@ -455,7 +474,7 @@
FunctionNode* saved_function_node = current_function_node_;
ScopeBuilder::DepthState saved_depth_state = depth_;
depth_ = DepthState(depth_.function_ + 1);
- EnterScope(parent);
+ EnterScope(parent, function->position());
current_function_scope_ = scope_;
current_function_node_ = function;
if (depth_.function_ == 1) {
@@ -464,7 +483,7 @@
}
AddParameters(function);
VisitFunctionNode(function);
- ExitScope();
+ ExitScope(function->end_position());
depth_ = saved_depth_state;
current_function_scope_ = saved_function_scope;
current_function_node_ = saved_function_node;
@@ -499,16 +518,16 @@
void ScopeBuilder::VisitLet(Let* node) {
- EnterScope(node);
+ EnterScope(node, node->position());
node->VisitChildren(this);
- ExitScope();
+ ExitScope(node->end_position());
}
void ScopeBuilder::VisitBlock(Block* node) {
- EnterScope(node);
+ EnterScope(node, node->position());
node->VisitChildren(this);
- ExitScope();
+ ExitScope(node->end_position());
}
@@ -539,7 +558,7 @@
void ScopeBuilder::VisitForStatement(ForStatement* node) {
- EnterScope(node);
+ EnterScope(node, node->position());
List<VariableDeclaration>& variables = node->variables();
for (intptr_t i = 0; i < variables.length(); ++i) {
VisitVariableDeclaration(variables[i]);
@@ -554,7 +573,7 @@
updates[i]->AcceptExpressionVisitor(this);
}
--depth_.loop_;
- ExitScope();
+ ExitScope(node->end_position());
}
@@ -563,10 +582,10 @@
++depth_.for_in_;
AddIteratorVariable();
++depth_.loop_;
- EnterScope(node);
+ EnterScope(node, node->position());
VisitVariableDeclaration(node->variable());
node->body()->AcceptStatementVisitor(this);
- ExitScope();
+ ExitScope(node->end_position());
--depth_.loop_;
--depth_.for_in_;
}
@@ -575,7 +594,8 @@
void ScopeBuilder::AddSwitchVariable() {
if ((depth_.function_ == 0) && (result_->switch_variable == NULL)) {
LocalVariable* variable =
- MakeVariable(Symbols::SwitchExpr(), AbstractType::dynamic_type());
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
+ Symbols::SwitchExpr(), AbstractType::dynamic_type());
variable->set_is_forced_stack();
current_function_scope_->AddVariable(variable);
result_->switch_variable = variable;
@@ -593,7 +613,9 @@
if ((depth_.function_ == 0) && (depth_.finally_ > 0) &&
(result_->finally_return_variable == NULL)) {
const dart::String& name = H.DartSymbol(":try_finally_return_value");
- LocalVariable* variable = MakeVariable(name, AbstractType::dynamic_type());
+ LocalVariable* variable =
+ MakeVariable(TokenPosition::kNoSource, TokenPosition::kNoSource, name,
+ AbstractType::dynamic_type());
current_function_scope_->AddVariable(variable);
result_->finally_return_variable = variable;
}
@@ -612,7 +634,7 @@
List<Catch>& catches = node->catches();
for (intptr_t i = 0; i < catches.length(); ++i) {
Catch* ketch = catches[i];
- EnterScope(ketch);
+ EnterScope(ketch, ketch->position());
if (ketch->exception() != NULL) {
VisitVariableDeclaration(ketch->exception());
}
@@ -620,7 +642,7 @@
VisitVariableDeclaration(ketch->stack_trace());
}
ketch->body()->AcceptStatementVisitor(this);
- ExitScope();
+ ExitScope(ketch->end_position());
}
--depth_.catch_;
}
@@ -2012,7 +2034,8 @@
Fragment instructions;
if (depth < context_depth_) {
instructions += LoadContextAt(depth);
- instructions += StoreLocal(parsed_function_->current_context_var());
+ instructions += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->current_context_var());
instructions += Drop();
context_depth_ = depth;
}
@@ -2027,7 +2050,8 @@
instructions += LoadLocal(context);
instructions += LoadLocal(parsed_function_->current_context_var());
instructions += StoreInstanceField(Context::parent_offset());
- instructions += StoreLocal(parsed_function_->current_context_var());
+ instructions += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->current_context_var());
++context_depth_;
return instructions;
}
@@ -2235,7 +2259,8 @@
CurrentCatchContext()->owner()->context_level() == 0);
context_depth_ = 0;
instructions += LoadLocal(CurrentCatchContext());
- instructions += StoreLocal(parsed_function_->current_context_var());
+ instructions += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->current_context_var());
instructions += Drop();
context_depth_ = saved_context_depth;
@@ -2253,7 +2278,7 @@
JoinEntryInstr* entry =
new (Z) JoinEntryInstr(AllocateBlockId(), try_handler_index);
body += LoadLocal(parsed_function_->current_context_var());
- body += StoreLocal(CurrentCatchContext());
+ body += StoreLocal(TokenPosition::kNoSource, CurrentCatchContext());
body += Drop();
body += Goto(entry);
return Fragment(body.entry, entry);
@@ -2287,7 +2312,7 @@
instructions <<= clone_instruction;
Push(clone_instruction);
- instructions += StoreLocal(context_variable);
+ instructions += StoreLocal(TokenPosition::kNoSource, context_variable);
instructions += Drop();
return instructions;
}
@@ -2497,7 +2522,7 @@
}
-Fragment FlowGraphBuilder::Return() {
+Fragment FlowGraphBuilder::Return(TokenPosition position) {
Value* value = Pop();
ASSERT(stack_ == NULL);
ReturnInstr* return_instr =
@@ -2612,7 +2637,8 @@
}
-Fragment FlowGraphBuilder::StoreLocal(LocalVariable* variable) {
+Fragment FlowGraphBuilder::StoreLocal(TokenPosition position,
+ LocalVariable* variable) {
Fragment instructions;
if (variable->is_captured()) {
LocalVariable* value = MakeTemporary();
@@ -2621,8 +2647,9 @@
instructions +=
StoreInstanceField(Context::variable_offset(variable->index()));
} else {
+ Value* value = Pop();
StoreLocalInstr* store =
- new (Z) StoreLocalInstr(*variable, Pop(), TokenPosition::kNoSource);
+ new (Z) StoreLocalInstr(*variable, value, position);
instructions <<= store;
Push(store);
}
@@ -2636,10 +2663,10 @@
}
-Fragment FlowGraphBuilder::StringInterpolate() {
+Fragment FlowGraphBuilder::StringInterpolate(TokenPosition position) {
Value* array = Pop();
StringInterpolateInstr* interpolate =
- new (Z) StringInterpolateInstr(array, TokenPosition::kNoSource);
+ new (Z) StringInterpolateInstr(array, position);
Push(interpolate);
return Fragment(interpolate);
}
@@ -3005,7 +3032,7 @@
body += LoadLocal(parameter);
body += StoreInstanceField(Context::variable_offset(variable->index()));
body += NullConstant();
- body += StoreLocal(parameter);
+ body += StoreLocal(TokenPosition::kNoSource, parameter);
body += Drop();
}
}
@@ -3047,7 +3074,7 @@
// false.
Fragment null_fragment(null_entry);
null_fragment += Constant(Bool::False());
- null_fragment += Return();
+ null_fragment += Return(dart_function.end_token_pos());
body = Fragment(body.entry, non_null_entry);
}
@@ -3059,7 +3086,7 @@
}
if (body.is_open()) {
body += NullConstant();
- body += Return();
+ body += Return(dart_function.end_token_pos());
}
// If functions body contains any yield points build switch statement that
@@ -3082,7 +3109,7 @@
// Load :await_jump_var into a temporary.
dispatch += LoadLocal(scopes_->yield_jump_variable);
- dispatch += StoreLocal(scopes_->switch_variable);
+ dispatch += StoreLocal(TokenPosition::kNoSource, scopes_->switch_variable);
dispatch += Drop();
BlockEntryInstr* block = NULL;
@@ -3093,7 +3120,8 @@
// Note: after this point context_depth_ does not match current context
// depth so we should not access any local variables anymore.
dispatch += LoadLocal(scopes_->yield_context_variable);
- dispatch += StoreLocal(parsed_function_->current_context_var());
+ dispatch += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->current_context_var());
dispatch += Drop();
}
if (i == (yield_continuations_.length() - 1)) {
@@ -3132,6 +3160,7 @@
context_depth_ = current_context_depth;
}
+
normal_entry->LinkTo(body.entry);
// When compiling for OSR, use a depth first search to prune instructions
@@ -3299,7 +3328,7 @@
break;
}
}
- return body + Return();
+ return body + Return(TokenPosition::kNoSource);
}
@@ -3350,7 +3379,7 @@
body += Constant(field);
body += LoadStaticField();
}
- body += Return();
+ body += Return(TokenPosition::kNoSource);
return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
}
@@ -3373,7 +3402,7 @@
} else {
body += TranslateExpression(initializer);
}
- body += Return();
+ body += Return(TokenPosition::kNoSource);
return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
}
@@ -3434,7 +3463,7 @@
Fragment body(normal_entry);
body += CheckStackOverflowInPrologue();
body += BuildImplicitClosureCreation(function);
- body += Return();
+ body += Return(TokenPosition::kNoSource);
return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
}
@@ -3486,7 +3515,7 @@
argument_names);
// Return the result.
- body += Return();
+ body += Return(kernel_function->end_position());
return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
}
@@ -3587,7 +3616,7 @@
Symbols::NoSuchMethod(), two_arguments);
}
body += StaticCall(TokenPosition::kMinSource, no_such_method, 2);
- body += Return();
+ body += Return(TokenPosition::kNoSource);
return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
}
@@ -3674,7 +3703,7 @@
Token::kILLEGAL, descriptor.Count(), argument_names);
}
- body += Return();
+ body += Return(TokenPosition::kNoSource);
return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
}
@@ -3833,7 +3862,7 @@
ASSERT(!declaration->IsConst());
instructions += TranslateExpression(initializer);
- instructions += StoreLocal(variable);
+ instructions += StoreLocal(TokenPosition::kNoSource, variable);
instructions += Drop();
fragment_ = instructions;
@@ -4252,7 +4281,8 @@
void FlowGraphBuilder::VisitVariableSet(VariableSet* node) {
Fragment instructions = TranslateExpression(node->expression());
- instructions += StoreLocal(LookupVariable(node->variable()));
+ instructions +=
+ StoreLocal(node->position(), LookupVariable(node->variable()));
fragment_ = instructions;
}
@@ -4342,7 +4372,7 @@
instructions += TranslateExpression(node->receiver());
instructions += PushArgument();
instructions += TranslateExpression(node->value());
- instructions += StoreLocal(variable);
+ instructions += StoreLocal(TokenPosition::kNoSource, variable);
instructions += PushArgument();
const dart::String& setter_name = H.DartSetterName(node->name());
@@ -4391,7 +4421,7 @@
instructions += TranslateExpression(node->receiver());
instructions += PushArgument();
instructions += TranslateExpression(node->value());
- instructions += StoreLocal(value);
+ instructions += StoreLocal(TokenPosition::kNoSource, value);
instructions += PushArgument();
instructions += StaticCall(node->position(), target, 2);
@@ -4653,7 +4683,7 @@
instructions += PushArgument(); // Negate?.
instructions +=
- InstanceCall(TokenPosition::kNoSource,
+ InstanceCall(node->position(),
dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
Token::kIS, 4);
}
@@ -4713,13 +4743,15 @@
Value* top = stack_;
Fragment then_fragment(then_entry);
then_fragment += TranslateExpression(node->then());
- then_fragment += StoreLocal(parsed_function_->expression_temp_var());
+ then_fragment += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->expression_temp_var());
then_fragment += Drop();
ASSERT(stack_ == top);
Fragment otherwise_fragment(otherwise_entry);
otherwise_fragment += TranslateExpression(node->otherwise());
- otherwise_fragment += StoreLocal(parsed_function_->expression_temp_var());
+ otherwise_fragment += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->expression_temp_var());
otherwise_fragment += Drop();
ASSERT(stack_ == top);
@@ -4750,14 +4782,16 @@
right_fragment += Constant(Bool::True());
right_fragment +=
StrictCompare(negate ? Token::kNE_STRICT : Token::kEQ_STRICT);
- right_fragment += StoreLocal(parsed_function_->expression_temp_var());
+ right_fragment += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->expression_temp_var());
right_fragment += Drop();
ASSERT(top == stack_);
Fragment constant_fragment(constant_entry);
constant_fragment +=
Constant(Bool::Get(node->op() == LogicalExpression::kOr));
- constant_fragment += StoreLocal(parsed_function_->expression_temp_var());
+ constant_fragment += StoreLocal(TokenPosition::kNoSource,
+ parsed_function_->expression_temp_var());
constant_fragment += Drop();
JoinEntryInstr* join = BuildJoinEntry();
@@ -4799,7 +4833,7 @@
instructions += Drop();
}
- instructions += StringInterpolate();
+ instructions += StringInterpolate(node->position());
fragment_ = instructions;
}
@@ -4991,15 +5025,16 @@
if (instructions.is_open()) {
if (inside_try_finally) {
ASSERT(scopes_->finally_return_variable != NULL);
- instructions += StoreLocal(scopes_->finally_return_variable);
+ instructions += StoreLocal(TokenPosition::kNoSource,
+ scopes_->finally_return_variable);
instructions += Drop();
instructions += TranslateFinallyFinalizers(NULL, -1);
if (instructions.is_open()) {
instructions += LoadLocal(scopes_->finally_return_variable);
- instructions += Return();
+ instructions += Return(node->position());
}
} else {
- instructions += Return();
+ instructions += Return(node->position());
}
} else {
Pop();
@@ -5032,7 +5067,7 @@
instructions += TranslateExpression(initializer);
}
}
- instructions += StoreLocal(variable);
+ instructions += StoreLocal(variable->token_pos(), variable);
instructions += Drop();
fragment_ = instructions;
}
@@ -5040,7 +5075,8 @@
void FlowGraphBuilder::VisitFunctionDeclaration(FunctionDeclaration* node) {
Fragment instructions = TranslateFunctionNode(node->function(), node);
- instructions += StoreLocal(LookupVariable(node->variable()));
+ instructions +=
+ StoreLocal(TokenPosition::kNoSource, LookupVariable(node->variable()));
instructions += Drop();
fragment_ = instructions;
}
@@ -5199,7 +5235,7 @@
instructions +=
InstanceCall(TokenPosition::kNoSource, iterator_getter, Token::kGET, 1);
LocalVariable* iterator = scopes_->iterator_variables[for_in_depth_];
- instructions += StoreLocal(iterator);
+ instructions += StoreLocal(TokenPosition::kNoSource, iterator);
instructions += Drop();
++for_in_depth_;
@@ -5220,7 +5256,8 @@
Z, dart::Field::GetterSymbol(Symbols::Current()));
body +=
InstanceCall(TokenPosition::kNoSource, current_getter, Token::kGET, 1);
- body += StoreLocal(LookupVariable(node->variable()));
+ body +=
+ StoreLocal(TokenPosition::kNoSource, LookupVariable(node->variable()));
body += Drop();
body += TranslateStatement(node->body());
body += ExitScope(node);
@@ -5290,7 +5327,8 @@
// Instead of using a variable we should reuse the expression on the stack,
// since it won't be assigned again, we don't need phi nodes.
Fragment head_instructions = TranslateExpression(node->condition());
- head_instructions += StoreLocal(scopes_->switch_variable);
+ head_instructions +=
+ StoreLocal(TokenPosition::kNoSource, scopes_->switch_variable);
head_instructions += Drop();
// Phase 1: Generate bodies and try to find out whether a body will be target
@@ -5645,14 +5683,15 @@
if (catch_clause->exception() != NULL) {
catch_handler_body += LoadLocal(CurrentException());
- catch_handler_body +=
- StoreLocal(LookupVariable(catch_clause->exception()));
+ catch_handler_body += StoreLocal(
+ TokenPosition::kNoSource, LookupVariable(catch_clause->exception()));
catch_handler_body += Drop();
}
if (catch_clause->stack_trace() != NULL) {
catch_handler_body += LoadLocal(CurrentStackTrace());
catch_handler_body +=
- StoreLocal(LookupVariable(catch_clause->stack_trace()));
+ StoreLocal(TokenPosition::kNoSource,
+ LookupVariable(catch_clause->stack_trace()));
catch_handler_body += Drop();
}
AbstractType* type_guard = NULL;
@@ -5742,13 +5781,15 @@
// Continuation<:await_jump_var> upon entry to the function.
//
Fragment instructions = IntConstant(yield_continuations_.length() + 1);
- instructions += StoreLocal(scopes_->yield_jump_variable);
+ instructions +=
+ StoreLocal(TokenPosition::kNoSource, scopes_->yield_jump_variable);
instructions += Drop();
instructions += LoadLocal(parsed_function_->current_context_var());
- instructions += StoreLocal(scopes_->yield_context_variable);
+ instructions +=
+ StoreLocal(TokenPosition::kNoSource, scopes_->yield_context_variable);
instructions += Drop();
instructions += TranslateExpression(node->expression());
- instructions += Return();
+ instructions += Return(TokenPosition::kNoSource);
// Note: DropTempsInstr serves as an anchor instruction. It will not
// be linked into the resulting graph.
@@ -5803,16 +5844,24 @@
Fragment FlowGraphBuilder::TranslateFunctionNode(FunctionNode* node,
TreeNode* parent) {
// The VM has a per-isolate table of functions indexed by the enclosing
- // function and token position. We don't have token positions, so we've
- // simply numbered the immediately-nested functions with respect to the
- // parent.
+ // function and token position.
Function& function = Function::ZoneHandle(Z);
for (intptr_t i = 0; i < scopes_->function_scopes.length(); ++i) {
if (scopes_->function_scopes[i].function != node) continue;
+ TokenPosition position = node->position();
+ if (parent->IsFunctionDeclaration()) {
+ position = FunctionDeclaration::Cast(parent)->position();
+ }
+ if (!position.IsReal()) {
+ // Positions has to be unique in regards to the parent.
+ // A non-real at this point is probably -1, we cannot blindly use that
+ // as others might use it too. Create a new dummy non-real TokenPosition.
+ position = TokenPosition(i).ToSynthetic();
+ }
+
// NOTE: This is not TokenPosition in the general sense!
- function = I->LookupClosureFunction(parsed_function_->function(),
- TokenPosition(i));
+ function = I->LookupClosureFunction(parsed_function_->function(), position);
if (function.IsNull()) {
const dart::String* name;
if (parent->IsFunctionExpression()) {
@@ -5824,8 +5873,9 @@
}
// NOTE: This is not TokenPosition in the general sense!
function = Function::NewClosureFunction(
- *name, parsed_function_->function(), TokenPosition(i));
- function.set_is_debuggable(false);
+ *name, parsed_function_->function(), position);
+ function.set_is_debuggable(node->debuggable());
+ function.set_end_token_pos(node->end_position());
LocalScope* scope = scopes_->function_scopes[i].scope;
const ContextScope& context_scope =
ContextScope::Handle(Z, scope->PreserveOuterScope(context_depth_));
diff --git a/runtime/vm/kernel_to_il.h b/runtime/vm/kernel_to_il.h
index 9a7a71a..b82216a 100644
--- a/runtime/vm/kernel_to_il.h
+++ b/runtime/vm/kernel_to_il.h
@@ -562,11 +562,13 @@
virtual void VisitConstructor(Constructor* node);
private:
- void EnterScope(TreeNode* node);
- void ExitScope();
+ void EnterScope(TreeNode* node, TokenPosition start_position);
+ void ExitScope(TokenPosition end_position);
const Type& TranslateVariableType(VariableDeclaration* variable);
- LocalVariable* MakeVariable(const dart::String& name,
+ LocalVariable* MakeVariable(TokenPosition declaration_pos,
+ TokenPosition token_pos,
+ const dart::String& name,
const AbstractType& type);
void AddParameters(FunctionNode* function, intptr_t pos = 0);
@@ -804,7 +806,7 @@
Fragment NullConstant();
Fragment NativeCall(const dart::String* name, const Function* function);
Fragment PushArgument();
- Fragment Return();
+ Fragment Return(TokenPosition position);
Fragment StaticCall(TokenPosition position,
const Function& target,
intptr_t argument_count);
@@ -820,9 +822,9 @@
Fragment StoreInstanceField(
intptr_t offset,
StoreBarrierType emit_store_barrier = kEmitStoreBarrier);
- Fragment StoreLocal(LocalVariable* variable);
+ Fragment StoreLocal(TokenPosition position, LocalVariable* variable);
Fragment StoreStaticField(const dart::Field& field);
- Fragment StringInterpolate();
+ Fragment StringInterpolate(TokenPosition position);
Fragment ThrowTypeError();
Fragment ThrowNoSuchMethodError();
Fragment BuildImplicitClosureCreation(const Function& target);
diff --git a/runtime/vm/method_recognizer.h b/runtime/vm/method_recognizer.h
index 3a4dff1..1e0a4bc 100644
--- a/runtime/vm/method_recognizer.h
+++ b/runtime/vm/method_recognizer.h
@@ -15,9 +15,9 @@
// correct fingerprint from the mismatch error.
#define OTHER_RECOGNIZED_LIST(V) \
V(::, identical, ObjectIdentical, Bool, 0x49c6e96a) \
- V(ClassID, getID, ClassIDgetID, Smi, 0x528fd455) \
+ V(ClassID, getID, ClassIDgetID, Smi, 0x66d44356) \
V(Object, Object., ObjectConstructor, Dynamic, 0x681617fe) \
- V(_List, ., ObjectArrayAllocate, Array, 0x375519ad) \
+ V(_List, ., ObjectArrayAllocate, Array, 0x6c3b54ee) \
V(_TypedList, _getInt8, ByteArrayBaseGetInt8, Smi, 0x7041895a) \
V(_TypedList, _getUint8, ByteArrayBaseGetUint8, Smi, 0x336fa3ea) \
V(_TypedList, _getInt16, ByteArrayBaseGetInt16, Smi, 0x231bbe2e) \
@@ -30,36 +30,36 @@
V(_TypedList, _getFloat32x4, ByteArrayBaseGetFloat32x4, Float32x4, \
0x5c367ffb) \
V(_TypedList, _getInt32x4, ByteArrayBaseGetInt32x4, Int32x4, 0x772d1c0f) \
- V(_TypedList, _setInt8, ByteArrayBaseSetInt8, Dynamic, 0x68f17de8) \
- V(_TypedList, _setUint8, ByteArrayBaseSetUint8, Dynamic, 0x6bb8b747) \
- V(_TypedList, _setInt16, ByteArrayBaseSetInt16, Dynamic, 0x75b8d278) \
- V(_TypedList, _setUint16, ByteArrayBaseSetUint16, Dynamic, 0x6e54f794) \
- V(_TypedList, _setInt32, ByteArrayBaseSetInt32, Dynamic, 0x54123a05) \
- V(_TypedList, _setUint32, ByteArrayBaseSetUint32, Dynamic, 0x4a3fea0b) \
- V(_TypedList, _setInt64, ByteArrayBaseSetInt64, Dynamic, 0x1d77d3ec) \
- V(_TypedList, _setFloat32, ByteArrayBaseSetFloat32, Dynamic, 0x5a11a2f9) \
- V(_TypedList, _setFloat64, ByteArrayBaseSetFloat64, Dynamic, 0x0edea58b) \
- V(_TypedList, _setFloat32x4, ByteArrayBaseSetFloat32x4, Dynamic, 0x163bc6cc) \
- V(_TypedList, _setInt32x4, ByteArrayBaseSetInt32x4, Dynamic, 0x5def39d2) \
- V(_StringBase, _interpolate, StringBaseInterpolate, Dynamic, 0x084d9f1a) \
- V(_IntegerImplementation, toDouble, IntegerToDouble, Double, 0x0d8f57ab) \
+ V(_TypedList, _setInt8, ByteArrayBaseSetInt8, Dynamic, 0x7dd630a9) \
+ V(_TypedList, _setUint8, ByteArrayBaseSetUint8, Dynamic, 0x009d6a08) \
+ V(_TypedList, _setInt16, ByteArrayBaseSetInt16, Dynamic, 0x0a9d8539) \
+ V(_TypedList, _setUint16, ByteArrayBaseSetUint16, Dynamic, 0x0339aa55) \
+ V(_TypedList, _setInt32, ByteArrayBaseSetInt32, Dynamic, 0x68f6ecc6) \
+ V(_TypedList, _setUint32, ByteArrayBaseSetUint32, Dynamic, 0x5f249ccc) \
+ V(_TypedList, _setInt64, ByteArrayBaseSetInt64, Dynamic, 0x325c86ad) \
+ V(_TypedList, _setFloat32, ByteArrayBaseSetFloat32, Dynamic, 0x6ef655ba) \
+ V(_TypedList, _setFloat64, ByteArrayBaseSetFloat64, Dynamic, 0x23c3584c) \
+ V(_TypedList, _setFloat32x4, ByteArrayBaseSetFloat32x4, Dynamic, 0x2b20798d) \
+ V(_TypedList, _setInt32x4, ByteArrayBaseSetInt32x4, Dynamic, 0x72d3ec93) \
+ V(_StringBase, _interpolate, StringBaseInterpolate, Dynamic, 0x051d283a) \
+ V(_IntegerImplementation, toDouble, IntegerToDouble, Double, 0x09b4f74c) \
V(_Double, _add, DoubleAdd, Double, 0x2a38277b) \
V(_Double, _sub, DoubleSub, Double, 0x4f466391) \
V(_Double, _mul, DoubleMul, Double, 0x175e4f66) \
V(_Double, _div, DoubleDiv, Double, 0x0854181b) \
- V(::, min, MathMin, Dynamic, 0x0bee5d52) \
- V(::, max, MathMax, Dynamic, 0x4f51acb6) \
- V(::, _doublePow, MathDoublePow, Double, 0x01d7b09e) \
- V(Float32x4, Float32x4., Float32x4Constructor, Float32x4, 0x05968999) \
- V(Float32x4, Float32x4.zero, Float32x4Zero, Float32x4, 0x472a4c46) \
- V(Float32x4, Float32x4.splat, Float32x4Splat, Float32x4, 0x00bba1a5) \
+ V(::, min, MathMin, Dynamic, 0x154735b3) \
+ V(::, max, MathMax, Dynamic, 0x217af195) \
+ V(::, _doublePow, MathDoublePow, Double, 0x61369cfd) \
+ V(Float32x4, Float32x4., Float32x4Constructor, Float32x4, 0x5640679a) \
+ V(Float32x4, Float32x4.zero, Float32x4Zero, Float32x4, 0x2f0b7925) \
+ V(Float32x4, Float32x4.splat, Float32x4Splat, Float32x4, 0x750512c4) \
V(Float32x4, Float32x4.fromInt32x4Bits, Float32x4FromInt32x4Bits, Float32x4, \
- 0x46d00995) \
+ 0x3b197ab4) \
V(Float32x4, Float32x4.fromFloat64x2, Float32x4FromFloat64x2, Float32x4, \
- 0x685a86d2) \
+ 0x5ca3f7f1) \
V(_Float32x4, shuffle, Float32x4Shuffle, Float32x4, 0x7829101f) \
V(_Float32x4, shuffleMix, Float32x4ShuffleMix, Float32x4, 0x4182c06b) \
- V(_Float32x4, get:signMask, Float32x4GetSignMask, Dynamic, 0x1d07ca93) \
+ V(_Float32x4, get:signMask, Float32x4GetSignMask, Dynamic, 0x1d083ef2) \
V(_Float32x4, equal, Float32x4Equal, Int32x4, 0x11adb239) \
V(_Float32x4, greaterThan, Float32x4GreaterThan, Int32x4, 0x48adaf58) \
V(_Float32x4, greaterThanOrEqual, Float32x4GreaterThanOrEqual, Int32x4, \
@@ -75,38 +75,38 @@
V(_Float32x4, reciprocalSqrt, Float32x4ReciprocalSqrt, Float32x4, \
0x6264bfe8) \
V(_Float32x4, reciprocal, Float32x4Reciprocal, Float32x4, 0x3cd7e819) \
- V(_Float32x4, unary-, Float32x4Negate, Float32x4, 0x34431a14) \
+ V(_Float32x4, unary-, Float32x4Negate, Float32x4, 0x35f7f2b3) \
V(_Float32x4, abs, Float32x4Absolute, Float32x4, 0x471cdd87) \
V(_Float32x4, clamp, Float32x4Clamp, Float32x4, 0x2cb30492) \
V(_Float32x4, withX, Float32x4WithX, Float32x4, 0x4e336aff) \
V(_Float32x4, withY, Float32x4WithY, Float32x4, 0x0a72b910) \
V(_Float32x4, withZ, Float32x4WithZ, Float32x4, 0x31e93658) \
V(_Float32x4, withW, Float32x4WithW, Float32x4, 0x60ddc105) \
- V(Float64x2, Float64x2., Float64x2Constructor, Float64x2, 0x193be61d) \
- V(Float64x2, Float64x2.zero, Float64x2Zero, Float64x2, 0x7b2ed5df) \
- V(Float64x2, Float64x2.splat, Float64x2Splat, Float64x2, 0x2abbfcb2) \
+ V(Float64x2, Float64x2., Float64x2Constructor, Float64x2, 0x2e2098de) \
+ V(Float64x2, Float64x2.zero, Float64x2Zero, Float64x2, 0x631002be) \
+ V(Float64x2, Float64x2.splat, Float64x2Splat, Float64x2, 0x1f056dd1) \
V(Float64x2, Float64x2.fromFloat32x4, Float64x2FromFloat32x4, Float64x2, \
- 0x2f43d3a6) \
- V(_Float64x2, get:x, Float64x2GetX, Double, 0x58bfb39a) \
- V(_Float64x2, get:y, Float64x2GetY, Double, 0x3cf4fcfa) \
- V(_Float64x2, unary-, Float64x2Negate, Float64x2, 0x3df2eecb) \
+ 0x238d44c5) \
+ V(_Float64x2, get:x, Float64x2GetX, Double, 0x58c027f9) \
+ V(_Float64x2, get:y, Float64x2GetY, Double, 0x3cf57159) \
+ V(_Float64x2, unary-, Float64x2Negate, Float64x2, 0x3fa7c76a) \
V(_Float64x2, abs, Float64x2Abs, Float64x2, 0x031f9e47) \
V(_Float64x2, sqrt, Float64x2Sqrt, Float64x2, 0x77f711dd) \
- V(_Float64x2, get:signMask, Float64x2GetSignMask, Dynamic, 0x27ddf18d) \
+ V(_Float64x2, get:signMask, Float64x2GetSignMask, Dynamic, 0x27de65ec) \
V(_Float64x2, scale, Float64x2Scale, Float64x2, 0x26830a61) \
V(_Float64x2, withX, Float64x2WithX, Float64x2, 0x1d2bcaf5) \
V(_Float64x2, withY, Float64x2WithY, Float64x2, 0x383ed6ac) \
V(_Float64x2, min, Float64x2Min, Float64x2, 0x28d7ddf6) \
V(_Float64x2, max, Float64x2Max, Float64x2, 0x0bd74e5b) \
- V(Int32x4, Int32x4., Int32x4Constructor, Int32x4, 0x26b199a7) \
- V(Int32x4, Int32x4.bool, Int32x4BoolConstructor, Int32x4, 0x1b55a5e1) \
+ V(Int32x4, Int32x4., Int32x4Constructor, Int32x4, 0x775b77a8) \
+ V(Int32x4, Int32x4.bool, Int32x4BoolConstructor, Int32x4, 0x690007a2) \
V(Int32x4, Int32x4.fromFloat32x4Bits, Int32x4FromFloat32x4Bits, Int32x4, \
- 0x7e82564c) \
- V(_Int32x4, get:flagX, Int32x4GetFlagX, Bool, 0x563883c4) \
- V(_Int32x4, get:flagY, Int32x4GetFlagY, Bool, 0x446f5e7a) \
- V(_Int32x4, get:flagZ, Int32x4GetFlagZ, Bool, 0x20d61679) \
- V(_Int32x4, get:flagW, Int32x4GetFlagW, Bool, 0x504478ac) \
- V(_Int32x4, get:signMask, Int32x4GetSignMask, Dynamic, 0x2c1ec9e5) \
+ 0x72cbc76b) \
+ V(_Int32x4, get:flagX, Int32x4GetFlagX, Bool, 0x5638f823) \
+ V(_Int32x4, get:flagY, Int32x4GetFlagY, Bool, 0x446fd2d9) \
+ V(_Int32x4, get:flagZ, Int32x4GetFlagZ, Bool, 0x20d68ad8) \
+ V(_Int32x4, get:flagW, Int32x4GetFlagW, Bool, 0x5044ed0b) \
+ V(_Int32x4, get:signMask, Int32x4GetSignMask, Dynamic, 0x2c1f3e44) \
V(_Int32x4, shuffle, Int32x4Shuffle, Int32x4, 0x20bc0b16) \
V(_Int32x4, shuffleMix, Int32x4ShuffleMix, Int32x4, 0x5c7056e1) \
V(_Int32x4, select, Int32x4Select, Float32x4, 0x6b49654f) \
@@ -114,120 +114,120 @@
V(_Int32x4, withFlagY, Int32x4WithFlagY, Int32x4, 0x6485a9c4) \
V(_Int32x4, withFlagZ, Int32x4WithFlagZ, Int32x4, 0x267acdfa) \
V(_Int32x4, withFlagW, Int32x4WithFlagW, Int32x4, 0x345ac675) \
- V(_Int64List, [], Int64ArrayGetIndexed, Dynamic, 0x680ec59b) \
- V(_Int64List, []=, Int64ArraySetIndexed, Dynamic, 0x0872fc15) \
- V(_Bigint, get:_neg, Bigint_getNeg, Bool, 0x355fa565) \
- V(_Bigint, get:_used, Bigint_getUsed, Smi, 0x33b9dcd2) \
- V(_Bigint, get:_digits, Bigint_getDigits, TypedDataUint32Array, 0x68de883a) \
- V(_HashVMBase, get:_index, LinkedHashMap_getIndex, Dynamic, 0x02468899) \
- V(_HashVMBase, set:_index, LinkedHashMap_setIndex, Dynamic, 0x577d9e20) \
- V(_HashVMBase, get:_data, LinkedHashMap_getData, Array, 0x2d7987ee) \
- V(_HashVMBase, set:_data, LinkedHashMap_setData, Dynamic, 0x1674fb28) \
- V(_HashVMBase, get:_usedData, LinkedHashMap_getUsedData, Smi, 0x0884b12f) \
- V(_HashVMBase, set:_usedData, LinkedHashMap_setUsedData, Dynamic, 0x66f792c6)\
- V(_HashVMBase, get:_hashMask, LinkedHashMap_getHashMask, Smi, 0x32f2c87d) \
- V(_HashVMBase, set:_hashMask, LinkedHashMap_setHashMask, Dynamic, 0x79ce8c9b)\
+ V(_Int64List, [], Int64ArrayGetIndexed, Dynamic, 0x1cfce099) \
+ V(_Int64List, []=, Int64ArraySetIndexed, Dynamic, 0x6b2911f5) \
+ V(_Bigint, get:_neg, Bigint_getNeg, Bool, 0x356019c4) \
+ V(_Bigint, get:_used, Bigint_getUsed, Smi, 0x33ba5131) \
+ V(_Bigint, get:_digits, Bigint_getDigits, TypedDataUint32Array, 0x68defc99) \
+ V(_HashVMBase, get:_index, LinkedHashMap_getIndex, Dynamic, 0x0246fcf8) \
+ V(_HashVMBase, set:_index, LinkedHashMap_setIndex, Dynamic, 0x53a33a00) \
+ V(_HashVMBase, get:_data, LinkedHashMap_getData, Array, 0x2d79fc4d) \
+ V(_HashVMBase, set:_data, LinkedHashMap_setData, Dynamic, 0x129a9708) \
+ V(_HashVMBase, get:_usedData, LinkedHashMap_getUsedData, Smi, 0x0885258e) \
+ V(_HashVMBase, set:_usedData, LinkedHashMap_setUsedData, Dynamic, 0x631d2ea6)\
+ V(_HashVMBase, get:_hashMask, LinkedHashMap_getHashMask, Smi, 0x32f33cdc) \
+ V(_HashVMBase, set:_hashMask, LinkedHashMap_setHashMask, Dynamic, 0x75f4287b)\
V(_HashVMBase, get:_deletedKeys, LinkedHashMap_getDeletedKeys, Smi, \
- 0x55839904) \
+ 0x55840d63) \
V(_HashVMBase, set:_deletedKeys, LinkedHashMap_setDeletedKeys, Dynamic, \
- 0x625e50cd) \
- V(::, _classRangeCheck, ClassRangeCheck, Bool, 0x025e8d82) \
- V(::, _classRangeCheckNegative, ClassRangeCheckNegated, Bool, 0x32451d73) \
+ 0x5e83ecad) \
+ V(::, _classRangeCheck, ClassRangeCheck, Bool, 0x16a2fc83) \
+ V(::, _classRangeCheckNegative, ClassRangeCheckNegated, Bool, 0x46898c74) \
// List of intrinsics:
// (class-name, function-name, intrinsification method, fingerprint).
#define CORE_LIB_INTRINSIC_LIST(V) \
- V(_Smi, ~, Smi_bitNegate, Smi, 0x63bfee11) \
- V(_Smi, get:bitLength, Smi_bitLength, Smi, 0x25b2e24c) \
+ V(_Smi, ~, Smi_bitNegate, Smi, 0x6574c6b0) \
+ V(_Smi, get:bitLength, Smi_bitLength, Smi, 0x25b356ab) \
V(_Smi, _bitAndFromSmi, Smi_bitAndFromSmi, Smi, 0x490a4da1) \
- V(_Bigint, _lsh, Bigint_lsh, Dynamic, 0x0619eb8a) \
- V(_Bigint, _rsh, Bigint_rsh, Dynamic, 0x0e1b80df) \
- V(_Bigint, _absAdd, Bigint_absAdd, Dynamic, 0x1a2b6326) \
- V(_Bigint, _absSub, Bigint_absSub, Dynamic, 0x3bebab4e) \
- V(_Bigint, _mulAdd, Bigint_mulAdd, Dynamic, 0x7d48a0b3) \
- V(_Bigint, _sqrAdd, Bigint_sqrAdd, Dynamic, 0x638b5f5d) \
- V(_Bigint, _estQuotientDigit, Bigint_estQuotientDigit, Dynamic, 0x467dee78) \
- V(_Montgomery, _mulMod, Montgomery_mulMod, Dynamic, 0x36065c30) \
- V(_Double, >, Double_greaterThan, Bool, 0x452cd763) \
- V(_Double, >=, Double_greaterEqualThan, Bool, 0x6c317340) \
- V(_Double, <, Double_lessThan, Bool, 0x26dda4bc) \
- V(_Double, <=, Double_lessEqualThan, Bool, 0x1e869d20) \
- V(_Double, ==, Double_equal, Bool, 0x5244dca3) \
- V(_Double, +, Double_add, Double, 0x49b2a530) \
- V(_Double, -, Double_sub, Double, 0x31833626) \
- V(_Double, *, Double_mul, Double, 0x21d31f1d) \
- V(_Double, /, Double_div, Double, 0x3e584fe8) \
- V(_Double, get:isNaN, Double_getIsNaN, Bool, 0x0af8ebeb) \
- V(_Double, get:isInfinite, Double_getIsInfinite, Bool, 0x0f79e289) \
- V(_Double, get:isNegative, Double_getIsNegative, Bool, 0x3a58ff36) \
- V(_Double, _mulFromInteger, Double_mulFromInteger, Double, 0x7f565534) \
- V(_Double, .fromInteger, DoubleFromInteger, Double, 0x04906d0d) \
- V(_List, []=, ObjectArraySetIndexed, Dynamic, 0x34d2c72c) \
+ V(_Bigint, _lsh, Bigint_lsh, Dynamic, 0x40d9f1cc) \
+ V(_Bigint, _rsh, Bigint_rsh, Dynamic, 0x703f1a40) \
+ V(_Bigint, _absAdd, Bigint_absAdd, Dynamic, 0x50fb1e47) \
+ V(_Bigint, _absSub, Bigint_absSub, Dynamic, 0x2beeb34d) \
+ V(_Bigint, _mulAdd, Bigint_mulAdd, Dynamic, 0x4feffd35) \
+ V(_Bigint, _sqrAdd, Bigint_sqrAdd, Dynamic, 0x1acf0bbe) \
+ V(_Bigint, _estQuotientDigit, Bigint_estQuotientDigit, Dynamic, 0x0a2898bb) \
+ V(_Montgomery, _mulMod, Montgomery_mulMod, Dynamic, 0x26d5b8ee) \
+ V(_Double, >, Double_greaterThan, Bool, 0x0a202683) \
+ V(_Double, >=, Double_greaterEqualThan, Bool, 0x57491a62) \
+ V(_Double, <, Double_lessThan, Bool, 0x2e9d61bb) \
+ V(_Double, <=, Double_lessEqualThan, Bool, 0x099e4442) \
+ V(_Double, ==, Double_equal, Bool, 0x04c399a1) \
+ V(_Double, +, Double_add, Double, 0x0ea5f450) \
+ V(_Double, -, Double_sub, Double, 0x76768546) \
+ V(_Double, *, Double_mul, Double, 0x66c66e3d) \
+ V(_Double, /, Double_div, Double, 0x034b9f08) \
+ V(_Double, get:isNaN, Double_getIsNaN, Bool, 0x0af9604a) \
+ V(_Double, get:isInfinite, Double_getIsInfinite, Bool, 0x0f7a56e8) \
+ V(_Double, get:isNegative, Double_getIsNegative, Bool, 0x3a597395) \
+ V(_Double, _mulFromInteger, Double_mulFromInteger, Double, 0x4fb72915) \
+ V(_Double, .fromInteger, DoubleFromInteger, Double, 0x78d9de2c) \
+ V(_List, []=, ObjectArraySetIndexed, Dynamic, 0x51691f4c) \
V(_GrowableList, .withData, GrowableArray_Allocate, GrowableObjectArray, \
- 0x401f3150) \
- V(_GrowableList, add, GrowableArray_add, Dynamic, 0x71f49ac8) \
+ 0x3468a26f) \
+ V(_GrowableList, add, GrowableArray_add, Dynamic, 0x19eaa9aa) \
V(_RegExp, _ExecuteMatch, RegExp_ExecuteMatch, Dynamic, 0x380184b1) \
V(_RegExp, _ExecuteMatchSticky, RegExp_ExecuteMatchSticky, Dynamic, \
0x79b8f955) \
- V(Object, ==, ObjectEquals, Bool, 0x11662ed8) \
- V(Object, get:runtimeType, ObjectRuntimeType, Type, 0x00e7c26b) \
- V(Object, _haveSameRuntimeType, ObjectHaveSameRuntimeType, Bool, 0x6532255b) \
- V(_StringBase, get:hashCode, String_getHashCode, Smi, 0x78c2eb88) \
- V(_StringBase, get:isEmpty, StringBaseIsEmpty, Bool, 0x74c21fca) \
+ V(Object, ==, ObjectEquals, Bool, 0x464c6a19) \
+ V(Object, get:runtimeType, ObjectRuntimeType, Type, 0x00e836ca) \
+ V(Object, _haveSameRuntimeType, ObjectHaveSameRuntimeType, Bool, 0x597b967a) \
+ V(_StringBase, get:hashCode, String_getHashCode, Smi, 0x78c35fe7) \
+ V(_StringBase, get:isEmpty, StringBaseIsEmpty, Bool, 0x1fa6a4c9) \
V(_StringBase, _substringMatches, StringBaseSubstringMatches, Bool, \
- 0x025b2ece) \
- V(_StringBase, [], StringBaseCharAt, Dynamic, 0x2cf92c45) \
- V(_OneByteString, get:hashCode, OneByteString_getHashCode, Smi, 0x78c2eb88) \
+ 0x649cbeef) \
+ V(_StringBase, [], StringBaseCharAt, Dynamic, 0x14da5924) \
+ V(_OneByteString, get:hashCode, OneByteString_getHashCode, Smi, 0x78c35fe7) \
V(_OneByteString, _substringUncheckedNative, \
OneByteString_substringUnchecked, OneByteString, 0x3538ad86) \
- V(_OneByteString, _setAt, OneByteStringSetAt, Dynamic, 0x6836784f) \
+ V(_OneByteString, _setAt, OneByteStringSetAt, Dynamic, 0x7d1b2b10) \
V(_OneByteString, _allocate, OneByteString_allocate, OneByteString, \
- 0x4c0a5574) \
- V(_OneByteString, ==, OneByteString_equality, Bool, 0x3f59b700) \
- V(_TwoByteString, ==, TwoByteString_equality, Bool, 0x3f59b700) \
+ 0x604ec475) \
+ V(_OneByteString, ==, OneByteString_equality, Bool, 0x4719e83f) \
+ V(_TwoByteString, ==, TwoByteString_equality, Bool, 0x4719e83f) \
#define CORE_INTEGER_LIB_INTRINSIC_LIST(V) \
V(_IntegerImplementation, _addFromInteger, Integer_addFromInteger, \
Dynamic, 0x6a10c54a) \
- V(_IntegerImplementation, +, Integer_add, Dynamic, 0x20192008) \
+ V(_IntegerImplementation, +, Integer_add, Dynamic, 0x5125faaa) \
V(_IntegerImplementation, _subFromInteger, Integer_subFromInteger, Dynamic, \
0x3fa4b1ed) \
- V(_IntegerImplementation, -, Integer_sub, Dynamic, 0x5b877969) \
+ V(_IntegerImplementation, -, Integer_sub, Dynamic, 0x0c94540b) \
V(_IntegerImplementation, _mulFromInteger, Integer_mulFromInteger, \
Dynamic, 0x3216e299) \
- V(_IntegerImplementation, *, Integer_mul, Dynamic, 0x142887aa) \
+ V(_IntegerImplementation, *, Integer_mul, Dynamic, 0x4535624c) \
V(_IntegerImplementation, _moduloFromInteger, Integer_moduloFromInteger, \
Dynamic, 0x6348b974) \
- V(_IntegerImplementation, ~/, Integer_truncDivide, Dynamic, 0x5b740346) \
- V(_IntegerImplementation, unary-, Integer_negate, Dynamic, 0x59dce57c) \
+ V(_IntegerImplementation, ~/, Integer_truncDivide, Dynamic, 0x1f48f4c9) \
+ V(_IntegerImplementation, unary-, Integer_negate, Dynamic, 0x4e346e3b) \
V(_IntegerImplementation, _bitAndFromInteger, Integer_bitAndFromInteger, \
Dynamic, 0x395b1678) \
- V(_IntegerImplementation, &, Integer_bitAnd, Dynamic, 0x50aab6e4) \
+ V(_IntegerImplementation, &, Integer_bitAnd, Dynamic, 0x01b79186) \
V(_IntegerImplementation, _bitOrFromInteger, Integer_bitOrFromInteger, \
Dynamic, 0x6a36b395) \
- V(_IntegerImplementation, |, Integer_bitOr, Dynamic, 0x40b9d4c2) \
+ V(_IntegerImplementation, |, Integer_bitOr, Dynamic, 0x71c6af64) \
V(_IntegerImplementation, _bitXorFromInteger, Integer_bitXorFromInteger, \
Dynamic, 0x72da93f0) \
- V(_IntegerImplementation, ^, Integer_bitXor, Dynamic, 0x16edce03) \
+ V(_IntegerImplementation, ^, Integer_bitXor, Dynamic, 0x47faa8a5) \
V(_IntegerImplementation, _greaterThanFromInteger, \
Integer_greaterThanFromInt, Bool, 0x4a50ed58) \
- V(_IntegerImplementation, >, Integer_greaterThan, Bool, 0x6220711f) \
- V(_IntegerImplementation, ==, Integer_equal, Bool, 0x0d4d7f2c) \
+ V(_IntegerImplementation, >, Integer_greaterThan, Bool, 0x23dd0c00) \
+ V(_IntegerImplementation, ==, Integer_equal, Bool, 0x7d51f04d) \
V(_IntegerImplementation, _equalToInteger, Integer_equalToInteger, Bool, \
0x063be842) \
- V(_IntegerImplementation, <, Integer_lessThan, Bool, 0x26dda4bc) \
- V(_IntegerImplementation, <=, Integer_lessEqualThan, Bool, 0x1e869d20) \
- V(_IntegerImplementation, >=, Integer_greaterEqualThan, Bool, 0x6c317340) \
- V(_IntegerImplementation, <<, Integer_shl, Dynamic, 0x5f43ef06) \
- V(_IntegerImplementation, >>, Integer_sar, Dynamic, 0x08a241c7) \
+ V(_IntegerImplementation, <, Integer_lessThan, Bool, 0x2e9d61bb) \
+ V(_IntegerImplementation, <=, Integer_lessEqualThan, Bool, 0x099e4442) \
+ V(_IntegerImplementation, >=, Integer_greaterEqualThan, Bool, 0x57491a62) \
+ V(_IntegerImplementation, <<, Integer_shl, Dynamic, 0x1050c9a8) \
+ V(_IntegerImplementation, >>, Integer_sar, Dynamic, 0x39af1c69) \
V(_Double, toInt, DoubleToInteger, Dynamic, 0x26ef344b)
#define MATH_LIB_INTRINSIC_LIST(V) \
V(::, sqrt, MathSqrt, Double, 0x70482cf3) \
- V(_Random, _nextState, Random_nextState, Dynamic, 0x24d91397) \
+ V(_Random, _nextState, Random_nextState, Dynamic, 0x268dec36) \
#define GRAPH_MATH_LIB_INTRINSIC_LIST(V) \
V(::, sin, MathSin, Double, 0x3f3a010c) \
@@ -239,94 +239,94 @@
V(::, atan2, MathAtan2, Double, 0x39f1fa41) \
#define TYPED_DATA_LIB_INTRINSIC_LIST(V) \
- V(Int8List, ., TypedData_Int8Array_factory, TypedDataInt8Array, 0x2e7749e3) \
+ V(Int8List, ., TypedData_Int8Array_factory, TypedDataInt8Array, 0x165876c2) \
V(Uint8List, ., TypedData_Uint8Array_factory, TypedDataUint8Array, \
- 0x6ab75439) \
+ 0x52988118) \
V(Uint8ClampedList, ., TypedData_Uint8ClampedArray_factory, \
- TypedDataUint8ClampedArray, 0x183129d7) \
+ TypedDataUint8ClampedArray, 0x001256b6) \
V(Int16List, ., TypedData_Int16Array_factory, TypedDataInt16Array, \
- 0x14b563ea) \
+ 0x7c9690c9) \
V(Uint16List, ., TypedData_Uint16Array_factory, TypedDataUint16Array, \
- 0x07456be4) \
+ 0x6f2698c3) \
V(Int32List, ., TypedData_Int32Array_factory, TypedDataInt32Array, \
- 0x5bd49250) \
+ 0x43b5bf2f) \
V(Uint32List, ., TypedData_Uint32Array_factory, \
- TypedDataUint32Array, 0x3c59b3a4) \
+ TypedDataUint32Array, 0x243ae083) \
V(Int64List, ., TypedData_Int64Array_factory, \
- TypedDataInt64Array, 0x57d85ac7) \
+ TypedDataInt64Array, 0x3fb987a6) \
V(Uint64List, ., TypedData_Uint64Array_factory, \
- TypedDataUint64Array, 0x2c093004) \
+ TypedDataUint64Array, 0x13ea5ce3) \
V(Float32List, ., TypedData_Float32Array_factory, \
- TypedDataFloat32Array, 0x738e124b) \
+ TypedDataFloat32Array, 0x5b6f3f2a) \
V(Float64List, ., TypedData_Float64Array_factory, \
- TypedDataFloat64Array, 0x501be4f1) \
+ TypedDataFloat64Array, 0x37fd11d0) \
V(Float32x4List, ., TypedData_Float32x4Array_factory, \
- TypedDataFloat32x4Array, 0x7a7dd718) \
+ TypedDataFloat32x4Array, 0x625f03f7) \
V(Int32x4List, ., TypedData_Int32x4Array_factory, \
- TypedDataInt32x4Array, 0x1e0dca48) \
+ TypedDataInt32x4Array, 0x05eef727) \
V(Float64x2List, ., TypedData_Float64x2Array_factory, \
- TypedDataFloat64x2Array, 0x18cbf4d9) \
+ TypedDataFloat64x2Array, 0x00ad21b8) \
#define GRAPH_TYPED_DATA_INTRINSICS_LIST(V) \
- V(_Int8List, [], Int8ArrayGetIndexed, Smi, 0x5f9a4430) \
- V(_Int8List, []=, Int8ArraySetIndexed, Dynamic, 0x5f880110) \
- V(_Uint8List, [], Uint8ArrayGetIndexed, Smi, 0x1eb150d8) \
- V(_Uint8List, []=, Uint8ArraySetIndexed, Dynamic, 0x4cf76981) \
- V(_ExternalUint8Array, [], ExternalUint8ArrayGetIndexed, Smi, 0x1eb150d8) \
+ V(_Int8List, [], Int8ArrayGetIndexed, Smi, 0x14885f2e) \
+ V(_Int8List, []=, Int8ArraySetIndexed, Dynamic, 0x423e16f0) \
+ V(_Uint8List, [], Uint8ArrayGetIndexed, Smi, 0x539f6bd6) \
+ V(_Uint8List, []=, Uint8ArraySetIndexed, Dynamic, 0x2fad7f61) \
+ V(_ExternalUint8Array, [], ExternalUint8ArrayGetIndexed, Smi, 0x539f6bd6) \
V(_ExternalUint8Array, []=, ExternalUint8ArraySetIndexed, Dynamic, \
- 0x4cf76981) \
- V(_Uint8ClampedList, [], Uint8ClampedArrayGetIndexed, Smi, 0x1eb150d8) \
- V(_Uint8ClampedList, []=, Uint8ClampedArraySetIndexed, Dynamic, 0x2224afe1) \
+ 0x2fad7f61) \
+ V(_Uint8ClampedList, [], Uint8ClampedArrayGetIndexed, Smi, 0x539f6bd6) \
+ V(_Uint8ClampedList, []=, Uint8ClampedArraySetIndexed, Dynamic, 0x04dac5c1) \
V(_ExternalUint8ClampedArray, [], ExternalUint8ClampedArrayGetIndexed, \
- Smi, 0x1eb150d8) \
+ Smi, 0x539f6bd6) \
V(_ExternalUint8ClampedArray, []=, ExternalUint8ClampedArraySetIndexed, \
- Dynamic, 0x2224afe1) \
- V(_Int16List, [], Int16ArrayGetIndexed, Smi, 0x74ea134c) \
- V(_Int16List, []=, Int16ArraySetIndexed, Dynamic, 0x48e25661) \
- V(_Uint16List, [], Uint16ArrayGetIndexed, Smi, 0x756d9a97) \
- V(_Uint16List, []=, Uint16ArraySetIndexed, Dynamic, 0x698f9d4f) \
- V(_Int32List, [], Int32ArrayGetIndexed, Dynamic, 0x61e49de1) \
- V(_Int32List, []=, Int32ArraySetIndexed, Dynamic, 0x55736c63) \
- V(_Uint32List, [], Uint32ArrayGetIndexed, Dynamic, 0x2eaa22d2) \
- V(_Uint32List, []=, Uint32ArraySetIndexed, Dynamic, 0x3c88eeb9) \
- V(_Float64List, [], Float64ArrayGetIndexed, Double, 0x20950e8a) \
- V(_Float64List, []=, Float64ArraySetIndexed, Dynamic, 0x556a0727) \
- V(_Float32List, [], Float32ArrayGetIndexed, Double, 0x7101fa23) \
- V(_Float32List, []=, Float32ArraySetIndexed, Dynamic, 0x5e32c1eb) \
- V(_Float32x4List, [], Float32x4ArrayGetIndexed, Float32x4, 0x28b0a7ef) \
- V(_Float32x4List, []=, Float32x4ArraySetIndexed, Dynamic, 0x4babf032) \
- V(_Int32x4List, [], Int32x4ArrayGetIndexed, Int32x4, 0x619c79a0) \
- V(_Int32x4List, []=, Int32x4ArraySetIndexed, Dynamic, 0x021bd16b) \
- V(_Float64x2List, [], Float64x2ArrayGetIndexed, Float64x2, 0x7a6dd5e5) \
- V(_Float64x2List, []=, Float64x2ArraySetIndexed, Dynamic, 0x3c59fecb) \
- V(_TypedList, get:length, TypedDataLength, Smi, 0x2090dc1a) \
- V(_Float32x4, get:x, Float32x4ShuffleX, Double, 0x63d0c13f) \
- V(_Float32x4, get:y, Float32x4ShuffleY, Double, 0x20343b1b) \
- V(_Float32x4, get:z, Float32x4ShuffleZ, Double, 0x13181dba) \
- V(_Float32x4, get:w, Float32x4ShuffleW, Double, 0x69895020) \
- V(_Float32x4, *, Float32x4Mul, Float32x4, 0x0e2a0ef4) \
- V(_Float32x4, -, Float32x4Sub, Float32x4, 0x6edeeaa3) \
- V(_Float32x4, +, Float32x4Add, Float32x4, 0x303a9943) \
+ Dynamic, 0x04dac5c1) \
+ V(_Int16List, [], Int16ArrayGetIndexed, Smi, 0x29d82e4a) \
+ V(_Int16List, []=, Int16ArraySetIndexed, Dynamic, 0x2b986c41) \
+ V(_Uint16List, [], Uint16ArrayGetIndexed, Smi, 0x2a5bb595) \
+ V(_Uint16List, []=, Uint16ArraySetIndexed, Dynamic, 0x4c45b32f) \
+ V(_Int32List, [], Int32ArrayGetIndexed, Dynamic, 0x16d2b8df) \
+ V(_Int32List, []=, Int32ArraySetIndexed, Dynamic, 0x38298243) \
+ V(_Uint32List, [], Uint32ArrayGetIndexed, Dynamic, 0x63983dd0) \
+ V(_Uint32List, []=, Uint32ArraySetIndexed, Dynamic, 0x1f3f0499) \
+ V(_Float64List, [], Float64ArrayGetIndexed, Double, 0x55832988) \
+ V(_Float64List, []=, Float64ArraySetIndexed, Dynamic, 0x2cfebd47) \
+ V(_Float32List, [], Float32ArrayGetIndexed, Double, 0x25f01521) \
+ V(_Float32List, []=, Float32ArraySetIndexed, Dynamic, 0x35c7780b) \
+ V(_Float32x4List, [], Float32x4ArrayGetIndexed, Float32x4, 0x5d9ec2ed) \
+ V(_Float32x4List, []=, Float32x4ArraySetIndexed, Dynamic, 0x2340a652) \
+ V(_Int32x4List, [], Int32x4ArrayGetIndexed, Int32x4, 0x168a949e) \
+ V(_Int32x4List, []=, Int32x4ArraySetIndexed, Dynamic, 0x59b0878b) \
+ V(_Float64x2List, [], Float64x2ArrayGetIndexed, Float64x2, 0x2f5bf0e3) \
+ V(_Float64x2List, []=, Float64x2ArraySetIndexed, Dynamic, 0x13eeb4eb) \
+ V(_TypedList, get:length, TypedDataLength, Smi, 0x20915079) \
+ V(_Float32x4, get:x, Float32x4ShuffleX, Double, 0x63d1359e) \
+ V(_Float32x4, get:y, Float32x4ShuffleY, Double, 0x2034af7a) \
+ V(_Float32x4, get:z, Float32x4ShuffleZ, Double, 0x13189219) \
+ V(_Float32x4, get:w, Float32x4ShuffleW, Double, 0x6989c47f) \
+ V(_Float32x4, *, Float32x4Mul, Float32x4, 0x760b3bd3) \
+ V(_Float32x4, -, Float32x4Sub, Float32x4, 0x56c01782) \
+ V(_Float32x4, +, Float32x4Add, Float32x4, 0x181bc622) \
#define GRAPH_CORE_INTRINSICS_LIST(V) \
- V(_List, get:length, ObjectArrayLength, Smi, 0x25943ad2) \
- V(_List, [], ObjectArrayGetIndexed, Dynamic, 0x157b4670) \
- V(_ImmutableList, get:length, ImmutableArrayLength, Smi, 0x25943ad2) \
- V(_ImmutableList, [], ImmutableArrayGetIndexed, Dynamic, 0x157b4670) \
- V(_GrowableList, get:length, GrowableArrayLength, Smi, 0x18dc9df6) \
- V(_GrowableList, get:_capacity, GrowableArrayCapacity, Smi, 0x2e03d5a2) \
- V(_GrowableList, _setData, GrowableArraySetData, Dynamic, 0x6dfc498a) \
- V(_GrowableList, _setLength, GrowableArraySetLength, Dynamic, 0x257bfc1c) \
- V(_GrowableList, [], GrowableArrayGetIndexed, Dynamic, 0x74ad8832) \
- V(_GrowableList, []=, GrowableArraySetIndexed, Dynamic, 0x0d6cfe96) \
- V(_StringBase, get:length, StringBaseLength, Smi, 0x2a2c1b13) \
+ V(_List, get:length, ObjectArrayLength, Smi, 0x2594af31) \
+ V(_List, [], ObjectArrayGetIndexed, Dynamic, 0x7d5c734f) \
+ V(_ImmutableList, get:length, ImmutableArrayLength, Smi, 0x2594af31) \
+ V(_ImmutableList, [], ImmutableArrayGetIndexed, Dynamic, 0x7d5c734f) \
+ V(_GrowableList, get:length, GrowableArrayLength, Smi, 0x18dd1255) \
+ V(_GrowableList, get:_capacity, GrowableArrayCapacity, Smi, 0x2e044a01) \
+ V(_GrowableList, _setData, GrowableArraySetData, Dynamic, 0x55dd7669) \
+ V(_GrowableList, _setLength, GrowableArraySetLength, Dynamic, 0x0d5d28fb) \
+ V(_GrowableList, [], GrowableArrayGetIndexed, Dynamic, 0x5c8eb511) \
+ V(_GrowableList, []=, GrowableArraySetIndexed, Dynamic, 0x2a0356b6) \
+ V(_StringBase, get:length, StringBaseLength, Smi, 0x2a2c8f72) \
V(_OneByteString, codeUnitAt, OneByteStringCodeUnitAt, Smi, 0x55a0a1f3) \
V(_TwoByteString, codeUnitAt, TwoByteStringCodeUnitAt, Smi, 0x55a0a1f3) \
V(_ExternalOneByteString, codeUnitAt, ExternalOneByteStringCodeUnitAt, \
Smi, 0x55a0a1f3) \
V(_ExternalTwoByteString, codeUnitAt, ExternalTwoByteStringCodeUnitAt, \
Smi, 0x55a0a1f3) \
- V(_Double, unary-, DoubleFlipSignBit, Double, 0x6a4ab611) \
+ V(_Double, unary-, DoubleFlipSignBit, Double, 0x6bff8eb0) \
V(_Double, truncateToDouble, DoubleTruncate, Double, 0x2f27e5d3) \
V(_Double, roundToDouble, DoubleRound, Double, 0x2f89c512) \
V(_Double, floorToDouble, DoubleFloor, Double, 0x6aa87a5f) \
@@ -363,71 +363,71 @@
// A list of core function that should always be inlined.
#define INLINE_WHITE_LIST(V) \
- V(Object, ==, ObjectEquals, 0x11662ed8) \
- V(_List, get:length, ObjectArrayLength, 0x25943ad2) \
- V(_ImmutableList, get:length, ImmutableArrayLength, 0x25943ad2) \
- V(_TypedList, get:length, TypedDataLength, 0x2090dc1a) \
- V(_GrowableList, get:length, GrowableArrayLength, 0x18dc9df6) \
- V(_GrowableList, get:_capacity, GrowableArrayCapacity, 0x2e03d5a2) \
- V(_GrowableList, add, GrowableListAdd, 0x71f49ac8) \
- V(_GrowableList, removeLast, GrowableListRemoveLast, 0x7add0363) \
- V(_StringBase, get:length, StringBaseLength, 0x2a2c1b13) \
- V(ListIterator, moveNext, ListIteratorMoveNext, 0x4f8ff9cc) \
- V(_FixedSizeArrayIterator, moveNext, FixedListIteratorMoveNext, 0x50e0604b) \
- V(_GrowableList, get:iterator, GrowableArrayIterator, 0x6db11a73) \
- V(_GrowableList, forEach, GrowableArrayForEach, 0x250036fe) \
- V(_List, ., ObjectArrayAllocate, 0x375519ad) \
- V(ListMixin, get:isEmpty, ListMixinIsEmpty, 0x787d9bc6) \
- V(_List, get:iterator, ObjectArrayIterator, 0x7e634791) \
- V(_List, forEach, ObjectArrayForEach, 0x0abce191) \
- V(_List, _slice, ObjectArraySlice, 0x01b71c13) \
- V(_ImmutableList, get:iterator, ImmutableArrayIterator, 0x7e634791) \
- V(_ImmutableList, forEach, ImmutableArrayForEach, 0x0abce191) \
- V(_Uint8ArrayView, [], Uint8ArrayViewGetIndexed, 0x760ba8c2) \
- V(_Uint8ArrayView, []=, Uint8ArrayViewSetIndexed, 0x44fc1997) \
- V(_Int8ArrayView, [], Int8ArrayViewGetIndexed, 0x7735aad3) \
- V(_Int8ArrayView, []=, Int8ArrayViewSetIndexed, 0x4237db0d) \
- V(_ByteDataView, setInt8, ByteDataViewSetInt8, 0x66702980) \
- V(_ByteDataView, setUint8, ByteDataViewSetUint8, 0x7c729d61) \
- V(_ByteDataView, setInt16, ByteDataViewSetInt16, 0x203478e8) \
- V(_ByteDataView, setUint16, ByteDataViewSetUint16, 0x16c35617) \
- V(_ByteDataView, setInt32, ByteDataViewSetInt32, 0x200c1aae) \
- V(_ByteDataView, setUint32, ByteDataViewSetUint32, 0x281c378e) \
- V(_ByteDataView, setInt64, ByteDataViewSetInt64, 0x10595a04) \
- V(_ByteDataView, setUint64, ByteDataViewSetUint64, 0x364fcc46) \
- V(_ByteDataView, setFloat32, ByteDataViewSetFloat32, 0x30628609) \
- V(_ByteDataView, setFloat64, ByteDataViewSetFloat64, 0x331b1f4b) \
- V(_ByteDataView, getInt8, ByteDataViewGetInt8, 0x62761d8f) \
- V(_ByteDataView, getUint8, ByteDataViewGetUint8, 0x579a5e34) \
- V(_ByteDataView, getInt16, ByteDataViewGetInt16, 0x73e0175b) \
- V(_ByteDataView, getUint16, ByteDataViewGetUint16, 0x3691576a) \
- V(_ByteDataView, getInt32, ByteDataViewGetInt32, 0x44d407a8) \
- V(_ByteDataView, getUint32, ByteDataViewGetUint32, 0x160c7450) \
- V(_ByteDataView, getInt64, ByteDataViewGetInt64, 0x02a2ffca) \
- V(_ByteDataView, getUint64, ByteDataViewGetUint64, 0x4dd4eedd) \
- V(_ByteDataView, getFloat32, ByteDataViewGetFloat32, 0x474b4719) \
- V(_ByteDataView, getFloat64, ByteDataViewGetFloat64, 0x47207cf7) \
+ V(Object, ==, ObjectEquals, 0x464c6a19) \
+ V(_List, get:length, ObjectArrayLength, 0x2594af31) \
+ V(_ImmutableList, get:length, ImmutableArrayLength, 0x2594af31) \
+ V(_TypedList, get:length, TypedDataLength, 0x20915079) \
+ V(_GrowableList, get:length, GrowableArrayLength, 0x18dd1255) \
+ V(_GrowableList, get:_capacity, GrowableArrayCapacity, 0x2e044a01) \
+ V(_GrowableList, add, GrowableListAdd, 0x19eaa9aa) \
+ V(_GrowableList, removeLast, GrowableListRemoveLast, 0x3daaaca4) \
+ V(_StringBase, get:length, StringBaseLength, 0x2a2c8f72) \
+ V(ListIterator, moveNext, ListIteratorMoveNext, 0x7ead154d) \
+ V(_FixedSizeArrayIterator, moveNext, FixedListIteratorMoveNext, 0x4197892b) \
+ V(_GrowableList, get:iterator, GrowableArrayIterator, 0x64c204d5) \
+ V(_GrowableList, forEach, GrowableArrayForEach, 0x4cc8215b) \
+ V(_List, ., ObjectArrayAllocate, 0x6c3b54ee) \
+ V(ListMixin, get:isEmpty, ListMixinIsEmpty, 0x7a327465) \
+ V(_List, get:iterator, ObjectArrayIterator, 0x757431f3) \
+ V(_List, forEach, ObjectArrayForEach, 0x4dfea652) \
+ V(_List, _slice, ObjectArraySlice, 0x671ebc98) \
+ V(_ImmutableList, get:iterator, ImmutableArrayIterator, 0x757431f3) \
+ V(_ImmutableList, forEach, ImmutableArrayForEach, 0x4dfea652) \
+ V(_Uint8ArrayView, [], Uint8ArrayViewGetIndexed, 0x4e8a9e40) \
+ V(_Uint8ArrayView, []=, Uint8ArrayViewSetIndexed, 0x46f85777) \
+ V(_Int8ArrayView, [], Int8ArrayViewGetIndexed, 0x4fb4a051) \
+ V(_Int8ArrayView, []=, Int8ArrayViewSetIndexed, 0x443418ed) \
+ V(_ByteDataView, setInt8, ByteDataViewSetInt8, 0x6502a95f) \
+ V(_ByteDataView, setUint8, ByteDataViewSetUint8, 0x7b051d40) \
+ V(_ByteDataView, setInt16, ByteDataViewSetInt16, 0x41bf9a68) \
+ V(_ByteDataView, setUint16, ByteDataViewSetUint16, 0x384e7797) \
+ V(_ByteDataView, setInt32, ByteDataViewSetInt32, 0x41973c2e) \
+ V(_ByteDataView, setUint32, ByteDataViewSetUint32, 0x49a7590e) \
+ V(_ByteDataView, setInt64, ByteDataViewSetInt64, 0x31e47b84) \
+ V(_ByteDataView, setUint64, ByteDataViewSetUint64, 0x57daedc6) \
+ V(_ByteDataView, setFloat32, ByteDataViewSetFloat32, 0x6c92cb69) \
+ V(_ByteDataView, setFloat64, ByteDataViewSetFloat64, 0x6f4b64ab) \
+ V(_ByteDataView, getInt8, ByteDataViewGetInt8, 0x655d546e) \
+ V(_ByteDataView, getUint8, ByteDataViewGetUint8, 0x5a819513) \
+ V(_ByteDataView, getInt16, ByteDataViewGetInt16, 0x449cf8de) \
+ V(_ByteDataView, getUint16, ByteDataViewGetUint16, 0x2f585007) \
+ V(_ByteDataView, getInt32, ByteDataViewGetInt32, 0x1590e92b) \
+ V(_ByteDataView, getUint32, ByteDataViewGetUint32, 0x0ed36ced) \
+ V(_ByteDataView, getInt64, ByteDataViewGetInt64, 0x535fe14d) \
+ V(_ByteDataView, getUint64, ByteDataViewGetUint64, 0x469be77a) \
+ V(_ByteDataView, getFloat32, ByteDataViewGetFloat32, 0x32567817) \
+ V(_ByteDataView, getFloat64, ByteDataViewGetFloat64, 0x322badf5) \
V(::, exp, MathExp, 0x32ab9efa) \
V(::, log, MathLog, 0x1ee8f9fc) \
- V(::, max, MathMax, 0x4f51acb6) \
- V(::, min, MathMin, 0x0bee5d52) \
- V(::, pow, MathPow, 0x443379a8) \
- V(::, _classRangeCheck, ClassRangeCheck, 0x025e8d82) \
- V(::, _classRangeCheckNegative, ClassRangeCheckNegated, 0x32451d73) \
- V(Lists, copy, ListsCopy, 0x21a194fa) \
- V(_Bigint, get:_neg, Bigint_getNeg, 0x355fa565) \
- V(_Bigint, get:_used, Bigint_getUsed, 0x33b9dcd2) \
- V(_Bigint, get:_digits, Bigint_getDigits, 0x68de883a) \
- V(_HashVMBase, get:_index, LinkedHashMap_getIndex, 0x02468899) \
- V(_HashVMBase, set:_index, LinkedHashMap_setIndex, 0x577d9e20) \
- V(_HashVMBase, get:_data, LinkedHashMap_getData, 0x2d7987ee) \
- V(_HashVMBase, set:_data, LinkedHashMap_setData, 0x1674fb28) \
- V(_HashVMBase, get:_usedData, LinkedHashMap_getUsedData, 0x0884b12f) \
- V(_HashVMBase, set:_usedData, LinkedHashMap_setUsedData, 0x66f792c6) \
- V(_HashVMBase, get:_hashMask, LinkedHashMap_getHashMask, 0x32f2c87d) \
- V(_HashVMBase, set:_hashMask, LinkedHashMap_setHashMask, 0x79ce8c9b) \
- V(_HashVMBase, get:_deletedKeys, LinkedHashMap_getDeletedKeys, 0x55839904) \
- V(_HashVMBase, set:_deletedKeys, LinkedHashMap_setDeletedKeys, 0x625e50cd) \
+ V(::, max, MathMax, 0x217af195) \
+ V(::, min, MathMin, 0x154735b3) \
+ V(::, pow, MathPow, 0x5f119fa5) \
+ V(::, _classRangeCheck, ClassRangeCheck, 0x16a2fc83) \
+ V(::, _classRangeCheckNegative, ClassRangeCheckNegated, 0x46898c74) \
+ V(Lists, copy, ListsCopy, 0x714584f8) \
+ V(_Bigint, get:_neg, Bigint_getNeg, 0x356019c4) \
+ V(_Bigint, get:_used, Bigint_getUsed, 0x33ba5131) \
+ V(_Bigint, get:_digits, Bigint_getDigits, 0x68defc99) \
+ V(_HashVMBase, get:_index, LinkedHashMap_getIndex, 0x0246fcf8) \
+ V(_HashVMBase, set:_index, LinkedHashMap_setIndex, 0x53a33a00) \
+ V(_HashVMBase, get:_data, LinkedHashMap_getData, 0x2d79fc4d) \
+ V(_HashVMBase, set:_data, LinkedHashMap_setData, 0x129a9708) \
+ V(_HashVMBase, get:_usedData, LinkedHashMap_getUsedData, 0x0885258e) \
+ V(_HashVMBase, set:_usedData, LinkedHashMap_setUsedData, 0x631d2ea6) \
+ V(_HashVMBase, get:_hashMask, LinkedHashMap_getHashMask, 0x32f33cdc) \
+ V(_HashVMBase, set:_hashMask, LinkedHashMap_setHashMask, 0x75f4287b) \
+ V(_HashVMBase, get:_deletedKeys, LinkedHashMap_getDeletedKeys, 0x55840d63) \
+ V(_HashVMBase, set:_deletedKeys, LinkedHashMap_setDeletedKeys, 0x5e83ecad) \
// A list of core function that should never be inlined.
#define INLINE_BLACK_LIST(V) \
@@ -439,42 +439,42 @@
V(::, sin, MathSin, 0x3f3a010c) \
V(::, sqrt, MathSqrt, 0x70482cf3) \
V(::, tan, MathTan, 0x0f8b9eaa) \
- V(_Bigint, _lsh, Bigint_lsh, 0x0619eb8a) \
- V(_Bigint, _rsh, Bigint_rsh, 0x0e1b80df) \
- V(_Bigint, _absAdd, Bigint_absAdd, 0x1a2b6326) \
- V(_Bigint, _absSub, Bigint_absSub, 0x3bebab4e) \
- V(_Bigint, _mulAdd, Bigint_mulAdd, 0x7d48a0b3) \
- V(_Bigint, _sqrAdd, Bigint_sqrAdd, 0x638b5f5d) \
- V(_Bigint, _estQuotientDigit, Bigint_estQuotientDigit, 0x467dee78) \
- V(_Montgomery, _mulMod, Montgomery_mulMod, 0x36065c30) \
- V(_Double, >, Double_greaterThan, 0x452cd763) \
- V(_Double, >=, Double_greaterEqualThan, 0x6c317340) \
- V(_Double, <, Double_lessThan, 0x26dda4bc) \
- V(_Double, <=, Double_lessEqualThan, 0x1e869d20) \
- V(_Double, ==, Double_equal, 0x5244dca3) \
- V(_Double, +, Double_add, 0x49b2a530) \
- V(_Double, -, Double_sub, 0x31833626) \
- V(_Double, *, Double_mul, 0x21d31f1d) \
- V(_Double, /, Double_div, 0x3e584fe8) \
- V(_IntegerImplementation, +, Integer_add, 0x20192008) \
- V(_IntegerImplementation, -, Integer_sub, 0x5b877969) \
- V(_IntegerImplementation, *, Integer_mul, 0x142887aa) \
- V(_IntegerImplementation, ~/, Integer_truncDivide, 0x5b740346) \
- V(_IntegerImplementation, unary-, Integer_negate, 0x59dce57c) \
- V(_IntegerImplementation, &, Integer_bitAnd, 0x50aab6e4) \
- V(_IntegerImplementation, |, Integer_bitOr, 0x40b9d4c2) \
- V(_IntegerImplementation, ^, Integer_bitXor, 0x16edce03) \
- V(_IntegerImplementation, >, Integer_greaterThan, 0x6220711f) \
- V(_IntegerImplementation, ==, Integer_equal, 0x0d4d7f2c) \
- V(_IntegerImplementation, <, Integer_lessThan, 0x26dda4bc) \
- V(_IntegerImplementation, <=, Integer_lessEqualThan, 0x1e869d20) \
- V(_IntegerImplementation, >=, Integer_greaterEqualThan, 0x6c317340) \
- V(_IntegerImplementation, <<, Integer_shl, 0x5f43ef06) \
- V(_IntegerImplementation, >>, Integer_sar, 0x08a241c7) \
+ V(_Bigint, _lsh, Bigint_lsh, 0x40d9f1cc) \
+ V(_Bigint, _rsh, Bigint_rsh, 0x703f1a40) \
+ V(_Bigint, _absAdd, Bigint_absAdd, 0x50fb1e47) \
+ V(_Bigint, _absSub, Bigint_absSub, 0x2beeb34d) \
+ V(_Bigint, _mulAdd, Bigint_mulAdd, 0x4feffd35) \
+ V(_Bigint, _sqrAdd, Bigint_sqrAdd, 0x1acf0bbe) \
+ V(_Bigint, _estQuotientDigit, Bigint_estQuotientDigit, 0x0a2898bb) \
+ V(_Montgomery, _mulMod, Montgomery_mulMod, 0x26d5b8ee) \
+ V(_Double, >, Double_greaterThan, 0x0a202683) \
+ V(_Double, >=, Double_greaterEqualThan, 0x57491a62) \
+ V(_Double, <, Double_lessThan, 0x2e9d61bb) \
+ V(_Double, <=, Double_lessEqualThan, 0x099e4442) \
+ V(_Double, ==, Double_equal, 0x04c399a1) \
+ V(_Double, +, Double_add, 0x0ea5f450) \
+ V(_Double, -, Double_sub, 0x76768546) \
+ V(_Double, *, Double_mul, 0x66c66e3d) \
+ V(_Double, /, Double_div, 0x034b9f08) \
+ V(_IntegerImplementation, +, Integer_add, 0x5125faaa) \
+ V(_IntegerImplementation, -, Integer_sub, 0x0c94540b) \
+ V(_IntegerImplementation, *, Integer_mul, 0x4535624c) \
+ V(_IntegerImplementation, ~/, Integer_truncDivide, 0x1f48f4c9) \
+ V(_IntegerImplementation, unary-, Integer_negate, 0x4e346e3b) \
+ V(_IntegerImplementation, &, Integer_bitAnd, 0x01b79186) \
+ V(_IntegerImplementation, |, Integer_bitOr, 0x71c6af64) \
+ V(_IntegerImplementation, ^, Integer_bitXor, 0x47faa8a5) \
+ V(_IntegerImplementation, >, Integer_greaterThan, 0x23dd0c00) \
+ V(_IntegerImplementation, ==, Integer_equal, 0x7d51f04d) \
+ V(_IntegerImplementation, <, Integer_lessThan, 0x2e9d61bb) \
+ V(_IntegerImplementation, <=, Integer_lessEqualThan, 0x099e4442) \
+ V(_IntegerImplementation, >=, Integer_greaterEqualThan, 0x57491a62) \
+ V(_IntegerImplementation, <<, Integer_shl, 0x1050c9a8) \
+ V(_IntegerImplementation, >>, Integer_sar, 0x39af1c69) \
// A list of core functions that internally dispatch based on received id.
#define POLYMORPHIC_TARGET_LIST(V) \
- V(_StringBase, [], StringBaseCharAt, 0x2cf92c45) \
+ V(_StringBase, [], StringBaseCharAt, 0x14da5924) \
V(_TypedList, _getInt8, ByteArrayBaseGetInt8, 0x7041895a) \
V(_TypedList, _getUint8, ByteArrayBaseGetUint8, 0x336fa3ea) \
V(_TypedList, _getInt16, ByteArrayBaseGetInt16, 0x231bbe2e) \
@@ -485,17 +485,17 @@
V(_TypedList, _getFloat64, ByteArrayBaseGetFloat64, 0x236c6e7a) \
V(_TypedList, _getFloat32x4, ByteArrayBaseGetFloat32x4, 0x5c367ffb) \
V(_TypedList, _getInt32x4, ByteArrayBaseGetInt32x4, 0x772d1c0f) \
- V(_TypedList, _setInt8, ByteArrayBaseSetInt8, 0x68f17de8) \
- V(_TypedList, _setUint8, ByteArrayBaseSetInt8, 0x6bb8b747) \
- V(_TypedList, _setInt16, ByteArrayBaseSetInt16, 0x75b8d278) \
- V(_TypedList, _setUint16, ByteArrayBaseSetInt16, 0x6e54f794) \
- V(_TypedList, _setInt32, ByteArrayBaseSetInt32, 0x54123a05) \
- V(_TypedList, _setUint32, ByteArrayBaseSetUint32, 0x4a3fea0b) \
- V(_TypedList, _setFloat32, ByteArrayBaseSetFloat32, 0x5a11a2f9) \
- V(_TypedList, _setFloat64, ByteArrayBaseSetFloat64, 0x0edea58b) \
- V(_TypedList, _setFloat32x4, ByteArrayBaseSetFloat32x4, 0x163bc6cc) \
- V(_TypedList, _setInt32x4, ByteArrayBaseSetInt32x4, 0x5def39d2) \
- V(Object, get:runtimeType, ObjectRuntimeType, 0x00e7c26b)
+ V(_TypedList, _setInt8, ByteArrayBaseSetInt8, 0x7dd630a9) \
+ V(_TypedList, _setUint8, ByteArrayBaseSetInt8, 0x009d6a08) \
+ V(_TypedList, _setInt16, ByteArrayBaseSetInt16, 0x0a9d8539) \
+ V(_TypedList, _setUint16, ByteArrayBaseSetInt16, 0x0339aa55) \
+ V(_TypedList, _setInt32, ByteArrayBaseSetInt32, 0x68f6ecc6) \
+ V(_TypedList, _setUint32, ByteArrayBaseSetUint32, 0x5f249ccc) \
+ V(_TypedList, _setFloat32, ByteArrayBaseSetFloat32, 0x6ef655ba) \
+ V(_TypedList, _setFloat64, ByteArrayBaseSetFloat64, 0x23c3584c) \
+ V(_TypedList, _setFloat32x4, ByteArrayBaseSetFloat32x4, 0x2b20798d) \
+ V(_TypedList, _setInt32x4, ByteArrayBaseSetInt32x4, 0x72d3ec93) \
+ V(Object, get:runtimeType, ObjectRuntimeType, 0x00e836ca)
// clang-format on
@@ -543,27 +543,27 @@
// (factory-name-symbol, class-name-string, constructor-name-string,
// result-cid, fingerprint).
#define RECOGNIZED_LIST_FACTORY_LIST(V) \
- V(_ListFactory, _List, ., kArrayCid, 0x375519ad) \
+ V(_ListFactory, _List, ., kArrayCid, 0x6c3b54ee) \
V(_GrowableListWithData, _GrowableList, .withData, kGrowableObjectArrayCid, \
- 0x401f3150) \
+ 0x3468a26f) \
V(_GrowableListFactory, _GrowableList, ., kGrowableObjectArrayCid, \
- 0x0b8d9feb) \
- V(_Int8ArrayFactory, Int8List, ., kTypedDataInt8ArrayCid, 0x2e7749e3) \
- V(_Uint8ArrayFactory, Uint8List, ., kTypedDataUint8ArrayCid, 0x6ab75439) \
+ 0x3bd724aa) \
+ V(_Int8ArrayFactory, Int8List, ., kTypedDataInt8ArrayCid, 0x165876c2) \
+ V(_Uint8ArrayFactory, Uint8List, ., kTypedDataUint8ArrayCid, 0x52988118) \
V(_Uint8ClampedArrayFactory, Uint8ClampedList, ., \
- kTypedDataUint8ClampedArrayCid, 0x183129d7) \
- V(_Int16ArrayFactory, Int16List, ., kTypedDataInt16ArrayCid, 0x14b563ea) \
- V(_Uint16ArrayFactory, Uint16List, ., kTypedDataUint16ArrayCid, 0x07456be4) \
- V(_Int32ArrayFactory, Int32List, ., kTypedDataInt32ArrayCid, 0x5bd49250) \
- V(_Uint32ArrayFactory, Uint32List, ., kTypedDataUint32ArrayCid, 0x3c59b3a4) \
- V(_Int64ArrayFactory, Int64List, ., kTypedDataInt64ArrayCid, 0x57d85ac7) \
- V(_Uint64ArrayFactory, Uint64List, ., kTypedDataUint64ArrayCid, 0x2c093004) \
+ kTypedDataUint8ClampedArrayCid, 0x001256b6) \
+ V(_Int16ArrayFactory, Int16List, ., kTypedDataInt16ArrayCid, 0x7c9690c9) \
+ V(_Uint16ArrayFactory, Uint16List, ., kTypedDataUint16ArrayCid, 0x6f2698c3) \
+ V(_Int32ArrayFactory, Int32List, ., kTypedDataInt32ArrayCid, 0x43b5bf2f) \
+ V(_Uint32ArrayFactory, Uint32List, ., kTypedDataUint32ArrayCid, 0x243ae083) \
+ V(_Int64ArrayFactory, Int64List, ., kTypedDataInt64ArrayCid, 0x3fb987a6) \
+ V(_Uint64ArrayFactory, Uint64List, ., kTypedDataUint64ArrayCid, 0x13ea5ce3) \
V(_Float64ArrayFactory, Float64List, ., kTypedDataFloat64ArrayCid, \
- 0x501be4f1) \
+ 0x37fd11d0) \
V(_Float32ArrayFactory, Float32List, ., kTypedDataFloat32ArrayCid, \
- 0x738e124b) \
+ 0x5b6f3f2a) \
V(_Float32x4ArrayFactory, Float32x4List, ., kTypedDataFloat32x4ArrayCid, \
- 0x7a7dd718)
+ 0x625f03f7)
// clang-format on
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 2da9eb6..3675bfb 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -3474,12 +3474,28 @@
if (is_synthesized_class() || IsMixinApplication() || IsTopLevel()) {
return token_pos();
}
+
Zone* zone = Thread::Current()->zone();
const Script& scr = Script::Handle(zone, script());
ASSERT(!scr.IsNull());
if (scr.kind() == RawScript::kKernelTag) {
- return TokenPosition::kMinSource;
+ TokenPosition largest_seen = token_pos();
+
+ // Walk through all functions and get their end_tokens to find the classes
+ // "end token".
+ // TODO(jensj): Should probably walk though all fields as well.
+ Function& function = Function::Handle(zone);
+ const Array& arr = Array::Handle(functions());
+ for (int i = 0; i < arr.Length(); i++) {
+ function ^= arr.At(i);
+ if (function.script() == script()) {
+ if (largest_seen < function.end_token_pos()) {
+ largest_seen = function.end_token_pos();
+ }
+ }
+ }
+ return TokenPosition(largest_seen);
}
const TokenStream& tkns = TokenStream::Handle(zone, scr.tokens());
@@ -5222,7 +5238,8 @@
void Function::InstallOptimizedCode(const Code& code, bool is_osr) const {
DEBUG_ASSERT(IsMutatorOrAtSafepoint());
// We may not have previous code if FLAG_precompile is set.
- if (!is_osr && HasCode()) {
+ // Hot-reload may have already disabled the current code.
+ if (!is_osr && HasCode() && !Code::Handle(CurrentCode()).IsDisabled()) {
Code::Handle(CurrentCode()).DisableDartCode();
}
AttachCode(code);
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 2726cf5..61a8051 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -3548,7 +3548,10 @@
}
void set_compile_time_constants(const Array& value) const;
- RawTokenStream* tokens() const { return raw_ptr()->tokens_; }
+ RawTokenStream* tokens() const {
+ ASSERT(kind() != RawScript::kKernelTag);
+ return raw_ptr()->tokens_;
+ }
void set_line_starts(const Array& value) const;
diff --git a/runtime/vm/pages.cc b/runtime/vm/pages.cc
index 1d7cb9a..6d959cd 100644
--- a/runtime/vm/pages.cc
+++ b/runtime/vm/pages.cc
@@ -600,6 +600,17 @@
}
+bool PageSpace::DataContains(uword addr) const {
+ for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
+ if ((it.page()->type() != HeapPage::kExecutable) &&
+ it.page()->Contains(addr)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+
void PageSpace::AddRegionsToObjectSet(ObjectSet* set) const {
ASSERT((pages_ != NULL) || (exec_pages_ != NULL) || (large_pages_ != NULL));
for (ExclusivePageIterator it(this); !it.Done(); it.Advance()) {
diff --git a/runtime/vm/pages.h b/runtime/vm/pages.h
index d1cfad2..b3aa2cd 100644
--- a/runtime/vm/pages.h
+++ b/runtime/vm/pages.h
@@ -227,6 +227,7 @@
bool Contains(uword addr) const;
bool Contains(uword addr, HeapPage::PageType type) const;
+ bool DataContains(uword addr) const;
bool IsValidAddress(uword addr) const { return Contains(addr); }
void VisitObjects(ObjectVisitor* visitor) const;
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index 7c250ae..afa023a 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -673,7 +673,8 @@
var(NULL),
is_final(false),
is_field_initializer(false),
- has_explicit_type(false) {}
+ has_explicit_type(false),
+ is_covariant(false) {}
const AbstractType* type;
TokenPosition name_pos;
const String* name;
@@ -683,6 +684,7 @@
bool is_final;
bool is_field_initializer;
bool has_explicit_type;
+ bool is_covariant;
};
@@ -696,6 +698,7 @@
has_optional_named_parameters = false;
has_explicit_default_values = false;
has_field_initializer = false;
+ has_covariant = false;
implicitly_final = false;
skipped = false;
this->parameters = new ZoneGrowableArray<ParamDesc>();
@@ -757,6 +760,7 @@
bool has_optional_named_parameters;
bool has_explicit_default_values;
bool has_field_initializer;
+ bool has_covariant;
bool implicitly_final;
bool skipped;
ZoneGrowableArray<ParamDesc>* parameters;
@@ -769,6 +773,7 @@
void Clear() {
has_abstract = false;
has_external = false;
+ has_covariant = false;
has_final = false;
has_const = false;
has_static = false;
@@ -816,6 +821,7 @@
String* DictName() const { return (dict_name != NULL) ? dict_name : name; }
bool has_abstract;
bool has_external;
+ bool has_covariant;
bool has_final;
bool has_const;
bool has_static;
@@ -1946,6 +1952,12 @@
SkipMetadata();
}
+ if (CurrentToken() == Token::kCOVARIANT &&
+ (LookaheadToken(1) == Token::kFINAL || LookaheadToken(1) == Token::kVAR ||
+ Token::IsIdentifier(LookaheadToken(1)))) {
+ parameter.is_covariant = true;
+ ConsumeToken();
+ }
if (CurrentToken() == Token::kFINAL) {
ConsumeToken();
final_seen = true;
@@ -2163,6 +2175,9 @@
parameter.is_final = true;
}
params->parameters->Add(parameter);
+ if (parameter.is_covariant) {
+ params->has_covariant = true;
+ }
}
@@ -3674,6 +3689,10 @@
ASSERT(method->type != NULL); // May still be unresolved.
ASSERT(current_member_ == method);
+ if (method->has_covariant) {
+ ReportError(method->name_pos,
+ "methods and constructors cannot be declared covariant");
+ }
if (method->has_var) {
ReportError(method->name_pos, "keyword var not allowed for methods");
}
@@ -4041,6 +4060,13 @@
// All const fields are also final.
ASSERT(!field->has_const || field->has_final);
+ if (field->has_covariant) {
+ if (field->has_static) {
+ ReportError("static fields cannot be declared covariant");
+ } else if (field->has_final) {
+ ReportError("final fields cannot be declared covariant");
+ }
+ }
if (field->has_abstract) {
ReportError("keyword 'abstract' not allowed in field declaration");
}
@@ -4252,6 +4278,10 @@
ConsumeToken();
member.has_static = true;
}
+ if (CurrentToken() == Token::kCOVARIANT) {
+ ConsumeToken();
+ member.has_covariant = true;
+ }
if (CurrentToken() == Token::kCONST) {
ConsumeToken();
member.has_const = true;
@@ -7313,6 +7343,13 @@
"only generative constructors may have "
"initializing formal parameters");
}
+ if (param_desc.is_covariant) {
+ if (!func.IsDynamicFunction(true)) {
+ ReportError(param_desc.name_pos,
+ "only instance functions may have "
+ "covariant parameters");
+ }
+ }
}
}
@@ -9918,7 +9955,7 @@
ReportError(jump_pos, "label '%s' not found", target_name.ToCString());
}
} else if (FLAG_enable_debug_break && (CurrentToken() == Token::kSTRING)) {
- const char* message = strdup(CurrentLiteral()->ToCString());
+ const char* message = Z->MakeCopyOfString(CurrentLiteral()->ToCString());
ConsumeToken();
return new (Z) StopNode(jump_pos, message);
} else {
diff --git a/runtime/vm/parser_test.cc b/runtime/vm/parser_test.cc
index a4f3ce2..2e35b12 100644
--- a/runtime/vm/parser_test.cc
+++ b/runtime/vm/parser_test.cc
@@ -375,7 +375,7 @@
EXPECT_STREQ(
// bb captures only value2 from aa. No others.
"a.b.aa.bb\n"
- " 0 ContextVar level=0 begin=33 end=43 name=value2\n"
+ " 0 ContextVar level=0 begin=34 end=44 name=value2\n"
" 1 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
@@ -391,9 +391,9 @@
"a.b.aa\n"
" 0 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 1 ContextLevel level=1 scope=2 begin=22 end=52\n"
- " 2 ContextVar level=1 begin=28 end=52 name=value2\n"
- " 3 StackVar scope=2 begin=30 end=52 name=bb\n"
+ " 1 ContextLevel level=1 scope=2 begin=22 end=53\n"
+ " 2 ContextVar level=1 begin=29 end=53 name=value2\n"
+ " 3 StackVar scope=2 begin=31 end=53 name=bb\n"
// Closure call saves current context.
"_Closure.call\n"
@@ -403,10 +403,10 @@
// b captures value1 from a.
"a.b\n"
- " 0 ContextVar level=0 begin=14 end=62 name=value1\n"
+ " 0 ContextVar level=0 begin=14 end=63 name=value1\n"
" 1 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 2 StackVar scope=2 begin=18 end=62 name=aa\n"
+ " 2 StackVar scope=2 begin=18 end=63 name=aa\n"
// Closure call saves current context.
"_Closure.call\n"
@@ -418,9 +418,9 @@
"a\n"
" 0 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 1 ContextLevel level=1 scope=2 begin=4 end=70\n"
- " 2 ContextVar level=1 begin=10 end=70 name=value1\n"
- " 3 StackVar scope=2 begin=12 end=70 name=b\n",
+ " 1 ContextLevel level=1 scope=2 begin=4 end=71\n"
+ " 2 ContextVar level=1 begin=10 end=71 name=value1\n"
+ " 3 StackVar scope=2 begin=12 end=71 name=b\n",
vars);
free(vars);
}
@@ -458,8 +458,8 @@
EXPECT_STREQ(
// This frame saves the entry context instead of chaining. Good.
"doIt.<anonymous closure>\n"
- " 0 ContextLevel level=1 scope=1 begin=41 end=62\n"
- " 1 ContextVar level=1 begin=42 end=62 name=y\n"
+ " 0 ContextLevel level=1 scope=1 begin=41 end=65\n"
+ " 1 ContextVar level=1 begin=42 end=65 name=y\n"
" 2 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
@@ -478,7 +478,7 @@
"doIt\n"
" 0 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 1 StackVar scope=2 begin=35 end=77 name=x\n",
+ " 1 StackVar scope=2 begin=35 end=80 name=x\n",
vars);
free(vars);
}
@@ -506,7 +506,7 @@
EXPECT_STREQ(
// inner function captures variable value. That's fine.
"outer.inner\n"
- " 0 ContextVar level=0 begin=32 end=42 name=value\n"
+ " 0 ContextVar level=0 begin=33 end=43 name=value\n"
" 1 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
@@ -521,10 +521,10 @@
"outer\n"
" 0 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 1 StackVar scope=3 begin=12 end=50 name=i\n"
- " 2 ContextLevel level=1 scope=4 begin=20 end=50\n"
- " 3 ContextVar level=1 begin=28 end=50 name=value\n"
- " 4 StackVar scope=4 begin=30 end=50 name=inner\n",
+ " 1 StackVar scope=3 begin=12 end=52 name=i\n"
+ " 2 ContextLevel level=1 scope=4 begin=20 end=52\n"
+ " 3 ContextVar level=1 begin=28 end=52 name=value\n"
+ " 4 StackVar scope=4 begin=30 end=52 name=inner\n",
vars);
free(vars);
}
@@ -551,7 +551,7 @@
char* vars = CaptureVarsAtLine(lib, "a", 10);
EXPECT_STREQ(
"a.b.c\n"
- " 0 ContextVar level=0 begin=50 end=62 name=x\n"
+ " 0 ContextVar level=0 begin=51 end=64 name=x\n"
" 1 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
"_Closure.call\n"
@@ -561,13 +561,13 @@
// Doesn't save the entry context. Chains to parent instead.
"a.b\n"
- " 0 ContextVar level=0 begin=12 end=71 name=x\n"
+ " 0 ContextVar level=0 begin=12 end=73 name=x\n"
" 1 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 2 StackVar scope=2 begin=47 end=71 name=c\n"
- " 3 ContextLevel level=1 scope=3 begin=18 end=47\n"
- " 4 ContextVar level=1 begin=22 end=47 name=i\n"
- " 5 StackVar scope=4 begin=32 end=47 name=d\n"
+ " 2 StackVar scope=2 begin=48 end=73 name=c\n"
+ " 3 ContextLevel level=1 scope=3 begin=18 end=48\n"
+ " 4 ContextVar level=1 begin=22 end=48 name=i\n"
+ " 5 StackVar scope=4 begin=33 end=48 name=d\n"
"_Closure.call\n"
" 0 StackVar scope=1 begin=0 end=4 name=this\n"
@@ -577,9 +577,9 @@
"a\n"
" 0 CurrentCtx scope=0 begin=0 end=0"
" name=:current_context_var\n"
- " 1 ContextLevel level=1 scope=2 begin=3 end=79\n"
- " 2 ContextVar level=1 begin=9 end=79 name=x\n"
- " 3 StackVar scope=2 begin=11 end=79 name=b\n",
+ " 1 ContextLevel level=1 scope=2 begin=3 end=81\n"
+ " 2 ContextVar level=1 begin=9 end=81 name=x\n"
+ " 3 StackVar scope=2 begin=11 end=81 name=b\n",
vars);
free(vars);
}
diff --git a/runtime/vm/precompiler.cc b/runtime/vm/precompiler.cc
index 57381a3..738ab2d 100644
--- a/runtime/vm/precompiler.cc
+++ b/runtime/vm/precompiler.cc
@@ -220,12 +220,11 @@
RawError* Precompiler::CompileAll(
Dart_QualifiedFunctionName embedder_entry_points[],
- bool reset_fields,
uint8_t* jit_feedback,
intptr_t jit_feedback_length) {
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
- Precompiler precompiler(Thread::Current(), reset_fields);
+ Precompiler precompiler(Thread::Current());
precompiler.LoadFeedback(jit_feedback, jit_feedback_length);
precompiler.DoCompileAll(embedder_entry_points);
return Error::null();
@@ -332,11 +331,10 @@
}
-Precompiler::Precompiler(Thread* thread, bool reset_fields)
+Precompiler::Precompiler(Thread* thread)
: thread_(thread),
zone_(NULL),
isolate_(thread->isolate()),
- reset_fields_(reset_fields),
jit_feedback_(NULL),
changed_(false),
function_count_(0),
@@ -686,9 +684,9 @@
{"dart:typed_data", "ByteData", "ByteData."},
{"dart:typed_data", "ByteData", "ByteData._view"},
{"dart:typed_data", "_ByteBuffer", "_ByteBuffer._New"},
- {"dart:_vmservice", "::", "_registerIsolate"},
{"dart:_vmservice", "::", "boot"},
#if !defined(PRODUCT)
+ {"dart:_vmservice", "::", "_registerIsolate"},
{"dart:developer", "Metrics", "_printMetrics"},
{"dart:developer", "::", "_runExtension"},
{"dart:isolate", "::", "_runPendingImmediateCallback"},
@@ -1184,9 +1182,6 @@
// Should not be in the middle of initialization while precompiling.
ASSERT(value.raw() != Object::transition_sentinel().raw());
- const bool is_initialized = value.raw() != Object::sentinel().raw();
- if (is_initialized && !reset_fields_) return;
-
if (!field.HasPrecompiledInitializer() ||
!Function::Handle(Z, field.PrecompiledInitializer()).HasCode()) {
if (FLAG_trace_precompiler) {
diff --git a/runtime/vm/precompiler.h b/runtime/vm/precompiler.h
index f4af735..08fc79e 100644
--- a/runtime/vm/precompiler.h
+++ b/runtime/vm/precompiler.h
@@ -386,7 +386,6 @@
public:
static RawError* CompileAll(
Dart_QualifiedFunctionName embedder_entry_points[],
- bool reset_fields,
uint8_t* jit_feedback,
intptr_t jit_feedback_length);
@@ -419,7 +418,7 @@
void TryApplyFeedback(ParsedJSONArray* js_icdatas, const ICData& ic);
private:
- Precompiler(Thread* thread, bool reset_fields);
+ explicit Precompiler(Thread* thread);
void LoadFeedback(uint8_t* jit_feedback, intptr_t jit_feedback_length);
ParsedJSONObject* LookupFeedback(const Function& function);
@@ -486,8 +485,6 @@
Zone* zone_;
Isolate* isolate_;
- const bool reset_fields_;
-
ParsedJSONObject* jit_feedback_;
bool changed_;
diff --git a/runtime/vm/scavenger.cc b/runtime/vm/scavenger.cc
index 1ca9e3f..f728f6b 100644
--- a/runtime/vm/scavenger.cc
+++ b/runtime/vm/scavenger.cc
@@ -79,9 +79,11 @@
visiting_old_object_(NULL) {}
void VisitPointers(RawObject** first, RawObject** last) {
- ASSERT((visiting_old_object_ != NULL) ||
- scavenger_->Contains(reinterpret_cast<uword>(first)) ||
- !heap_->Contains(reinterpret_cast<uword>(first)));
+ if (FLAG_verify_gc_contains) {
+ ASSERT((visiting_old_object_ != NULL) ||
+ scavenger_->Contains(reinterpret_cast<uword>(first)) ||
+ !heap_->Contains(reinterpret_cast<uword>(first)));
+ }
for (RawObject** current = first; current <= last; current++) {
ScavengePointer(current);
}
@@ -96,11 +98,12 @@
private:
void UpdateStoreBuffer(RawObject** p, RawObject* obj) {
- uword ptr = reinterpret_cast<uword>(p);
ASSERT(obj->IsHeapObject());
- ASSERT(!scavenger_->Contains(ptr));
- ASSERT(!heap_->CodeContains(ptr));
- ASSERT(heap_->Contains(ptr));
+ if (FLAG_verify_gc_contains) {
+ uword ptr = reinterpret_cast<uword>(p);
+ ASSERT(!scavenger_->Contains(ptr));
+ ASSERT(heap_->DataContains(ptr));
+ }
// If the newly written object is not a new object, drop it immediately.
if (!obj->IsNewObject() || visiting_old_object_->IsRemembered()) {
return;
diff --git a/runtime/vm/service_isolate.cc b/runtime/vm/service_isolate.cc
index 042e808..a067c4e 100644
--- a/runtime/vm/service_isolate.cc
+++ b/runtime/vm/service_isolate.cc
@@ -36,11 +36,17 @@
false,
"Provide extra service tracing information.");
-static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
+static uint8_t* malloc_allocator(uint8_t* ptr,
+ intptr_t old_size,
+ intptr_t new_size) {
void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
return reinterpret_cast<uint8_t*>(new_ptr);
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(reinterpret_cast<void*>(ptr));
+}
+
// These must be kept in sync with service/constants.dart
#define VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID 0
@@ -106,7 +112,7 @@
sp, VM_SERVICE_SERVER_INFO_MESSAGE_ID, false /* ignored */));
ASSERT(!message.IsNull());
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(message);
intptr_t len = writer.BytesWritten();
PortMap::PostMessage(new Message(port_, data, len, Message::kNormalPriority));
@@ -118,7 +124,7 @@
sp, VM_SERVICE_WEB_SERVER_CONTROL_MESSAGE_ID, enable));
ASSERT(!message.IsNull());
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(message);
intptr_t len = writer.BytesWritten();
PortMap::PostMessage(new Message(port_, data, len, Message::kNormalPriority));
@@ -205,7 +211,7 @@
Dart_GetMainPortId(), VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID, name));
ASSERT(!list.IsNull());
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(list);
intptr_t len = writer.BytesWritten();
if (FLAG_trace_service) {
@@ -234,7 +240,7 @@
Dart_GetMainPortId(), VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID, name));
ASSERT(!list.IsNull());
uint8_t* data = NULL;
- MessageWriter writer(&data, &allocator, false);
+ MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
writer.WriteMessage(list);
intptr_t len = writer.BytesWritten();
if (FLAG_trace_service) {
@@ -311,7 +317,8 @@
ASSERT(exit_message_length_ == 0);
const Array& list = Array::Handle(Z, MakeServiceExitMessage());
ASSERT(!list.IsNull());
- MessageWriter writer(&exit_message_, &allocator, false);
+ MessageWriter writer(&exit_message_, &malloc_allocator, &malloc_deallocator,
+ false);
writer.WriteMessage(list);
exit_message_length_ = writer.BytesWritten();
ASSERT(exit_message_ != NULL);
diff --git a/runtime/vm/simulator_arm64.cc b/runtime/vm/simulator_arm64.cc
index 65a2034..4e8fde2 100644
--- a/runtime/vm/simulator_arm64.cc
+++ b/runtime/vm/simulator_arm64.cc
@@ -2656,18 +2656,30 @@
// Format(instr, "smulh 'rd, 'rn, 'rm");
const int64_t rn_val = get_register(rn, R31IsZR);
const int64_t rm_val = get_register(rm, R31IsZR);
+#if defined(TARGET_OS_WINDOWS)
+ // Visual Studio does not support __int128.
+ int64_t alu_out;
+ Multiply128(rn_val, rm_val, &alu_out);
+#else
const __int128 res =
static_cast<__int128>(rn_val) * static_cast<__int128>(rm_val);
const int64_t alu_out = static_cast<int64_t>(res >> 64);
+#endif // TARGET_OS_WINDOWS
set_register(instr, rd, alu_out, R31IsZR);
} else if ((instr->Bits(29, 2) == 0) && (instr->Bits(21, 3) == 6) &&
(instr->Bit(15) == 0)) {
// Format(instr, "umulh 'rd, 'rn, 'rm");
const uint64_t rn_val = get_register(rn, R31IsZR);
const uint64_t rm_val = get_register(rm, R31IsZR);
+#if defined(TARGET_OS_WINDOWS)
+ // Visual Studio does not support __int128.
+ int64_t alu_out;
+ Multiply128(rn_val, rm_val, &alu_out);
+#else
const __int128 res =
static_cast<__int128>(rn_val) * static_cast<__int128>(rm_val);
const int64_t alu_out = static_cast<int64_t>(res >> 64);
+#endif // TARGET_OS_WINDOWS
set_register(instr, rd, alu_out, R31IsZR);
} else if ((instr->Bits(29, 3) == 4) && (instr->Bits(21, 3) == 5) &&
(instr->Bit(15) == 0)) {
diff --git a/runtime/vm/snapshot.cc b/runtime/vm/snapshot.cc
index b073188..c992cc3 100644
--- a/runtime/vm/snapshot.cc
+++ b/runtime/vm/snapshot.cc
@@ -1218,10 +1218,11 @@
Snapshot::Kind kind,
uint8_t** buffer,
ReAlloc alloc,
+ DeAlloc dealloc,
intptr_t initial_size,
ForwardList* forward_list,
bool can_send_any_object)
- : BaseWriter(buffer, alloc, initial_size),
+ : BaseWriter(buffer, alloc, dealloc, initial_size),
thread_(thread),
kind_(kind),
object_store_(isolate()->object_store()),
@@ -1883,6 +1884,7 @@
Snapshot::kScript,
buffer,
alloc,
+ NULL,
kInitialSize,
&forward_list_,
true /* can_send_any_object */),
@@ -1932,11 +1934,13 @@
MessageWriter::MessageWriter(uint8_t** buffer,
ReAlloc alloc,
+ DeAlloc dealloc,
bool can_send_any_object)
: SnapshotWriter(Thread::Current(),
Snapshot::kMessage,
buffer,
alloc,
+ dealloc,
kInitialSize,
&forward_list_,
can_send_any_object),
@@ -1957,6 +1961,7 @@
NoSafepointScope no_safepoint;
WriteObject(obj.raw());
} else {
+ FreeBuffer();
ThrowException(exception_type(), exception_msg());
}
}
diff --git a/runtime/vm/snapshot.h b/runtime/vm/snapshot.h
index 76f48a6..03ad684 100644
--- a/runtime/vm/snapshot.h
+++ b/runtime/vm/snapshot.h
@@ -637,8 +637,13 @@
}
protected:
- BaseWriter(uint8_t** buffer, ReAlloc alloc, intptr_t initial_size)
- : StackResource(Thread::Current()), stream_(buffer, alloc, initial_size) {
+ BaseWriter(uint8_t** buffer,
+ ReAlloc alloc,
+ DeAlloc dealloc,
+ intptr_t initial_size)
+ : StackResource(Thread::Current()),
+ stream_(buffer, alloc, initial_size),
+ dealloc_(dealloc) {
ASSERT(buffer != NULL);
ASSERT(alloc != NULL);
}
@@ -655,8 +660,11 @@
data[Snapshot::kSnapshotFlagIndex] = kind;
}
+ void FreeBuffer() { dealloc_(stream_.buffer()); }
+
private:
WriteStream stream_;
+ DeAlloc dealloc_;
DISALLOW_IMPLICIT_CONSTRUCTORS(BaseWriter);
};
@@ -862,6 +870,7 @@
Snapshot::Kind kind,
uint8_t** buffer,
ReAlloc alloc,
+ DeAlloc dealloc,
intptr_t initial_size,
ForwardList* forward_list,
bool can_send_any_object);
@@ -992,7 +1001,10 @@
class MessageWriter : public SnapshotWriter {
public:
static const intptr_t kInitialSize = 512;
- MessageWriter(uint8_t** buffer, ReAlloc alloc, bool can_send_any_object);
+ MessageWriter(uint8_t** buffer,
+ ReAlloc alloc,
+ DeAlloc dealloc,
+ bool can_send_any_object);
~MessageWriter() {}
void WriteMessage(const Object& obj);
diff --git a/runtime/vm/snapshot_test.cc b/runtime/vm/snapshot_test.cc
index fec51a0..aa51a40 100644
--- a/runtime/vm/snapshot_test.cc
+++ b/runtime/vm/snapshot_test.cc
@@ -57,6 +57,11 @@
}
+static void malloc_deallocator(uint8_t* ptr) {
+ free(ptr);
+}
+
+
static uint8_t* zone_allocator(uint8_t* ptr,
intptr_t old_size,
intptr_t new_size) {
@@ -65,6 +70,9 @@
}
+static void zone_deallocator(uint8_t* ptr) {}
+
+
// Compare two Dart_CObject object graphs rooted in first and
// second. The second graph will be destroyed by this operation no matter
// whether the graphs are equal or not.
@@ -159,7 +167,7 @@
// Write snapshot with object content.
const Object& null_object = Object::Handle();
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(null_object);
intptr_t buffer_len = writer.BytesWritten();
@@ -184,7 +192,7 @@
// Write snapshot with object content.
const Smi& smi = Smi::Handle(Smi::New(124));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(smi);
intptr_t buffer_len = writer.BytesWritten();
@@ -210,7 +218,7 @@
// Write snapshot with object content.
const Smi& smi = Smi::Handle(Smi::New(-1));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(smi);
intptr_t buffer_len = writer.BytesWritten();
@@ -233,7 +241,7 @@
Dart_CObject* SerializeAndDeserializeMint(const Mint& mint) {
// Write snapshot with object content.
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(mint);
intptr_t buffer_len = writer.BytesWritten();
@@ -308,7 +316,7 @@
// Write snapshot with object content.
const Double& dbl = Double::Handle(Double::New(101.29));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(dbl);
intptr_t buffer_len = writer.BytesWritten();
@@ -334,7 +342,7 @@
// Write snapshot with true object.
const Bool& bl = Bool::True();
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(bl);
intptr_t buffer_len = writer.BytesWritten();
@@ -362,7 +370,7 @@
// Write snapshot with false object.
const Bool& bl = Bool::False();
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(bl);
intptr_t buffer_len = writer.BytesWritten();
@@ -386,7 +394,7 @@
// Write snapshot with object content.
const Capability& capability = Capability::Handle(Capability::New(12345));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(capability);
intptr_t buffer_len = writer.BytesWritten();
@@ -416,7 +424,7 @@
Bigint& bigint = Bigint::Handle();
bigint ^= Integer::NewCanonical(str);
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(bigint);
intptr_t buffer_len = writer.BytesWritten();
@@ -444,7 +452,7 @@
Dart_CObject* SerializeAndDeserializeBigint(const Bigint& bigint) {
// Write snapshot with object content.
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(bigint);
intptr_t buffer_len = writer.BytesWritten();
@@ -497,7 +505,7 @@
TEST_CASE(SerializeSingletons) {
// Write snapshot with object content.
uint8_t* buffer;
- MessageWriter writer(&buffer, &malloc_allocator, true);
+ MessageWriter writer(&buffer, &malloc_allocator, &malloc_deallocator, true);
writer.WriteObject(Object::class_class());
writer.WriteObject(Object::type_arguments_class());
writer.WriteObject(Object::function_class());
@@ -539,7 +547,7 @@
// Write snapshot with object content.
String& str = String::Handle(String::New(cstr));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(str);
intptr_t buffer_len = writer.BytesWritten();
@@ -585,7 +593,7 @@
array.SetAt(i, smi);
}
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(array);
intptr_t buffer_len = writer.BytesWritten();
@@ -667,7 +675,7 @@
const int kArrayLength = 0;
Array& array = Array::Handle(Array::New(kArrayLength));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(array);
intptr_t buffer_len = writer.BytesWritten();
@@ -697,7 +705,7 @@
typed_data.SetUint8(i, i);
}
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(typed_data);
intptr_t buffer_len = writer.BytesWritten();
@@ -731,7 +739,7 @@
array.Set##darttype((i * scale), i); \
} \
uint8_t* buffer; \
- MessageWriter writer(&buffer, &zone_allocator, true); \
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true); \
writer.WriteMessage(array); \
intptr_t buffer_len = writer.BytesWritten(); \
MessageSnapshotReader reader(buffer, buffer_len, thread); \
@@ -754,7 +762,7 @@
reinterpret_cast<uint8_t*>(data), length)); \
intptr_t scale = array.ElementSizeInBytes(); \
uint8_t* buffer; \
- MessageWriter writer(&buffer, &zone_allocator, true); \
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true); \
writer.WriteMessage(array); \
intptr_t buffer_len = writer.BytesWritten(); \
MessageSnapshotReader reader(buffer, buffer_len, thread); \
@@ -801,7 +809,7 @@
TypedData& typed_data = TypedData::Handle(
TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteMessage(typed_data);
intptr_t buffer_len = writer.BytesWritten();
@@ -831,6 +839,7 @@
Snapshot::kScript,
buffer,
alloc,
+ NULL,
kInitialSize,
&forward_list_,
true /* can_send_any_object */),
@@ -1716,7 +1725,7 @@
// Serialize the object into a message.
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, false);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
writer.WriteMessage(obj);
*buffer_len = writer.BytesWritten();
return buffer;
@@ -1736,7 +1745,7 @@
String& str = String::Handle();
str ^= Api::UnwrapHandle(dart_string);
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, false);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
writer.WriteMessage(str);
intptr_t buffer_len = writer.BytesWritten();
@@ -1756,7 +1765,7 @@
String& str = String::Handle();
str ^= Api::UnwrapHandle(dart_string);
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, false);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
writer.WriteMessage(str);
intptr_t buffer_len = writer.BytesWritten();
@@ -1867,7 +1876,7 @@
Smi& smi = Smi::Handle();
smi ^= Api::UnwrapHandle(smi_result);
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, false);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
writer.WriteMessage(smi);
intptr_t buffer_len = writer.BytesWritten();
@@ -1885,7 +1894,7 @@
Bigint& bigint = Bigint::Handle();
bigint ^= Api::UnwrapHandle(bigint_result);
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, false);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, false);
writer.WriteMessage(bigint);
intptr_t buffer_len = writer.BytesWritten();
@@ -2990,7 +2999,7 @@
TEST_CASE(OmittedObjectEncodingLength) {
StackZone zone(Thread::Current());
uint8_t* buffer;
- MessageWriter writer(&buffer, &zone_allocator, true);
+ MessageWriter writer(&buffer, &zone_allocator, &zone_deallocator, true);
writer.WriteInlinedObjectHeader(kOmittedObjectId);
// For performance, we'd like single-byte headers when ids are omitted.
// If this starts failing, consider renumbering the snapshot ids.
diff --git a/runtime/vm/timeline.cc b/runtime/vm/timeline.cc
index f0b0ee1..4c23d78 100644
--- a/runtime/vm/timeline.cc
+++ b/runtime/vm/timeline.cc
@@ -1505,6 +1505,16 @@
TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
: head_(NULL), block_index_(0) {}
+TimelineEventEndlessRecorder::~TimelineEventEndlessRecorder() {
+ TimelineEventBlock* current = head_;
+ head_ = NULL;
+
+ while (current != NULL) {
+ TimelineEventBlock* next = current->next();
+ delete current;
+ current = next;
+ }
+}
void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js,
TimelineEventFilter* filter) {
diff --git a/runtime/vm/timeline.h b/runtime/vm/timeline.h
index cc93040..c7c6016 100644
--- a/runtime/vm/timeline.h
+++ b/runtime/vm/timeline.h
@@ -461,7 +461,7 @@
TimelineStream* stream,
const char* label);
- ~TimelineDurationScope();
+ virtual ~TimelineDurationScope();
private:
int64_t timestamp_;
@@ -479,7 +479,7 @@
TimelineStream* stream,
const char* label);
- ~TimelineBeginEndScope();
+ virtual ~TimelineBeginEndScope();
private:
void EmitBegin();
@@ -681,7 +681,7 @@
static const intptr_t kDefaultCapacity = 8192;
explicit TimelineEventFixedBufferRecorder(intptr_t capacity);
- ~TimelineEventFixedBufferRecorder();
+ virtual ~TimelineEventFixedBufferRecorder();
void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
@@ -708,7 +708,7 @@
public:
explicit TimelineEventRingRecorder(intptr_t capacity = kDefaultCapacity)
: TimelineEventFixedBufferRecorder(capacity) {}
- ~TimelineEventRingRecorder() {}
+ virtual ~TimelineEventRingRecorder() {}
const char* name() const { return "Ring"; }
@@ -723,8 +723,7 @@
class TimelineEventSystraceRecorder : public TimelineEventFixedBufferRecorder {
public:
explicit TimelineEventSystraceRecorder(intptr_t capacity = kDefaultCapacity);
-
- ~TimelineEventSystraceRecorder();
+ virtual ~TimelineEventSystraceRecorder();
const char* name() const { return "Systrace"; }
@@ -742,7 +741,7 @@
public:
explicit TimelineEventStartupRecorder(intptr_t capacity = kDefaultCapacity)
: TimelineEventFixedBufferRecorder(capacity) {}
- ~TimelineEventStartupRecorder() {}
+ virtual ~TimelineEventStartupRecorder() {}
const char* name() const { return "Startup"; }
@@ -756,7 +755,7 @@
class TimelineEventCallbackRecorder : public TimelineEventRecorder {
public:
TimelineEventCallbackRecorder();
- ~TimelineEventCallbackRecorder();
+ virtual ~TimelineEventCallbackRecorder();
void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
@@ -782,6 +781,7 @@
class TimelineEventEndlessRecorder : public TimelineEventRecorder {
public:
TimelineEventEndlessRecorder();
+ virtual ~TimelineEventEndlessRecorder();
void PrintJSON(JSONStream* js, TimelineEventFilter* filter);
void PrintTraceEvent(JSONStream* js, TimelineEventFilter* filter);
diff --git a/runtime/vm/token.h b/runtime/vm/token.h
index 3d2e821..376796f 100644
--- a/runtime/vm/token.h
+++ b/runtime/vm/token.h
@@ -155,6 +155,7 @@
KW(kCLASS, "class", 0, kKeyword) \
KW(kCONST, "const", 0, kKeyword) \
KW(kCONTINUE, "continue", 0, kKeyword) \
+ KW(kCOVARIANT, "covariant", 0, kPseudoKeyword) \
KW(kDEFAULT, "default", 0, kKeyword) \
KW(kDO, "do", 0, kKeyword) \
KW(kELSE, "else", 0, kKeyword) \
diff --git a/samples/samples.status b/samples/samples.status
index caf91ca..d6e08b9 100644
--- a/samples/samples.status
+++ b/samples/samples.status
@@ -25,3 +25,6 @@
[ $compiler == app_jit ]
sample_extension/test/*: Skip # Shared use of a temp directory
+
+[ $builder_tag == asan && $arch == x64 ]
+sample_extension/test/sample_extension_app_snapshot_test: RuntimeError # Leak in subprocess
diff --git a/sdk/lib/core/uri.dart b/sdk/lib/core/uri.dart
index 847521a..fa7d01b 100644
--- a/sdk/lib/core/uri.dart
+++ b/sdk/lib/core/uri.dart
@@ -1470,10 +1470,13 @@
path = _makePath(path, 0, _stringOrNullLength(path), pathSegments,
scheme, hasAuthority);
if (scheme.isEmpty && host == null && !path.startsWith('/')) {
- path = _normalizeRelativePath(path);
+ path = _normalizeRelativePath(path, scheme.isNotEmpty || host != null);
} else {
path = _removeDotSegments(path);
}
+ if (host == null && path.startsWith("//")) {
+ host = "";
+ }
return new _Uri._internal(scheme, userInfo, host, port,
path, query, fragment);
}
@@ -2058,7 +2061,7 @@
/// Otherwise it follows the RFC 3986 "remove dot segments" algorithm.
static String _normalizePath(String path, String scheme, bool hasAuthority) {
if (scheme.isEmpty && !hasAuthority && !path.startsWith('/')) {
- return _normalizeRelativePath(path);
+ return _normalizeRelativePath(path, scheme.isNotEmpty || hasAuthority);
}
return _removeDotSegments(path);
}
@@ -2354,15 +2357,21 @@
/// Removes all `.` segments and any non-leading `..` segments.
///
+ /// If the path starts with something that looks like a scheme,
+ /// and [allowScheme] is false, the colon is escaped.
+ ///
/// Removing the ".." from a "bar/foo/.." sequence results in "bar/"
/// (trailing "/"). If the entire path is removed (because it contains as
/// many ".." segments as real segments), the result is "./".
/// This is different from an empty string, which represents "no path",
/// when you resolve it against a base URI with a path with a non-empty
/// final segment.
- static String _normalizeRelativePath(String path) {
+ static String _normalizeRelativePath(String path, bool allowScheme) {
assert(!path.startsWith('/')); // Only get called for relative paths.
- if (!_mayContainDotSegments(path)) return path;
+ if (!_mayContainDotSegments(path)) {
+ if (!allowScheme) path = _escapeScheme(path);
+ return path;
+ }
assert(path.isNotEmpty); // An empty path would not have dot segments.
List<String> output = [];
bool appendSlash = false;
@@ -2385,9 +2394,27 @@
return "./";
}
if (appendSlash || output.last == '..') output.add("");
+ if (!allowScheme) output[0] = _escapeScheme(output[0]);
return output.join("/");
}
+ /// If [path] starts with a valid scheme, escape the percent.
+ static String _escapeScheme(String path) {
+ if (path.length >= 2 && _isAlphabeticCharacter(path.codeUnitAt(0))) {
+ for (int i = 1; i < path.length; i++) {
+ int char = path.codeUnitAt(i);
+ if (char == _COLON) {
+ return "${path.substring(0, i)}%3A${path.substring(i + 1)}";
+ }
+ if (char > 127 ||
+ ((_schemeTable[char >> 4] & (1 << (char & 0x0f))) == 0)) {
+ break;
+ }
+ }
+ }
+ return path;
+ }
+
Uri resolve(String reference) {
return resolveUri(Uri.parse(reference));
}
@@ -2459,7 +2486,8 @@
// If both base and reference are relative paths,
// allow the merged path to start with "..".
// The RFC only specifies the case where the base has a scheme.
- targetPath = _normalizeRelativePath(mergedPath);
+ targetPath = _normalizeRelativePath(mergedPath,
+ this.hasScheme || this.hasAuthority);
}
}
}
@@ -2596,7 +2624,7 @@
assert(_text == null);
StringBuffer sb = new StringBuffer();
if (scheme.isNotEmpty) sb..write(scheme)..write(":");
- if (hasAuthority || path.startsWith("//") || (scheme == "file")) {
+ if (hasAuthority || (scheme == "file")) {
// File URIS always have the authority, even if it is empty.
// The empty URI means "localhost".
sb.write("//");
diff --git a/sdk/lib/io/bytes_builder.dart b/sdk/lib/io/bytes_builder.dart
index 2dca39d..1b61d30 100644
--- a/sdk/lib/io/bytes_builder.dart
+++ b/sdk/lib/io/bytes_builder.dart
@@ -83,24 +83,22 @@
// Start with 1024 bytes.
static const int _INIT_SIZE = 1024;
+ static final _emptyList = new Uint8List(0);
+
int _length = 0;
Uint8List _buffer;
+ _CopyingBytesBuilder([int initialCapacity = 0])
+ : _buffer = (initialCapacity <= 0)
+ ? _emptyList
+ : new Uint8List(_pow2roundup(initialCapacity));
+
void add(List<int> bytes) {
int bytesLength = bytes.length;
if (bytesLength == 0) return;
int required = _length + bytesLength;
- if (_buffer == null) {
- int size = _pow2roundup(required);
- size = max(size, _INIT_SIZE);
- _buffer = new Uint8List(size);
- } else if (_buffer.length < required) {
- // We will create a list in the range of 2-4 times larger than
- // required.
- int size = _pow2roundup(required) * 2;
- var newBuffer = new Uint8List(size);
- newBuffer.setRange(0, _buffer.length, _buffer);
- _buffer = newBuffer;
+ if (_buffer.length < required) {
+ _grow(required);
}
assert(_buffer.length >= required);
if (bytes is Uint8List) {
@@ -113,17 +111,40 @@
_length = required;
}
- void addByte(int byte) { add([byte]); }
+ void addByte(int byte) {
+ if (_buffer.length == _length) {
+ // The grow algorithm always at least doubles.
+ // If we added one to _length it would quadruple unnecessarily.
+ _grow(_length);
+ }
+ assert(_buffer.length > _length);
+ _buffer[_length] = byte;
+ _length++;
+ }
+
+ void _grow(int required) {
+ // We will create a list in the range of 2-4 times larger than
+ // required.
+ int newSize = required * 2;
+ if (newSize < _INIT_SIZE) {
+ newSize = _INIT_SIZE;
+ } else {
+ newSize = _pow2roundup(newSize);
+ }
+ var newBuffer = new Uint8List(newSize);
+ newBuffer.setRange(0, _buffer.length, _buffer);
+ _buffer = newBuffer;
+ }
List<int> takeBytes() {
- if (_buffer == null) return new Uint8List(0);
+ if (_length == 0) return _emptyList;
var buffer = new Uint8List.view(_buffer.buffer, 0, _length);
clear();
return buffer;
}
List<int> toBytes() {
- if (_buffer == null) return new Uint8List(0);
+ if (_length == 0) return _emptyList;
return new Uint8List.fromList(
new Uint8List.view(_buffer.buffer, 0, _length));
}
@@ -136,10 +157,11 @@
void clear() {
_length = 0;
- _buffer = null;
+ _buffer = _emptyList;
}
- int _pow2roundup(int x) {
+ static int _pow2roundup(int x) {
+ assert(x > 0);
--x;
x |= x >> 1;
x |= x >> 2;
@@ -166,12 +188,15 @@
_length += typedBytes.length;
}
- void addByte(int byte) { add([byte]); }
+ void addByte(int byte) {
+ _chunks.add(new Uint8List(1)..[0] = byte);
+ _length++;
+ }
List<int> takeBytes() {
- if (_chunks.length == 0) return new Uint8List(0);
+ if (_length == 0) return _CopyingBytesBuilder._emptyList;
if (_chunks.length == 1) {
- var buffer = _chunks.single;
+ var buffer = _chunks[0];
clear();
return buffer;
}
@@ -186,7 +211,7 @@
}
List<int> toBytes() {
- if (_chunks.length == 0) return new Uint8List(0);
+ if (_length == 0) return _CopyingBytesBuilder._emptyList;
var buffer = new Uint8List(_length);
int offset = 0;
for (var chunk in _chunks) {
diff --git a/sdk/lib/io/http_headers.dart b/sdk/lib/io/http_headers.dart
index 3769b3f..40df48a 100644
--- a/sdk/lib/io/http_headers.dart
+++ b/sdk/lib/io/http_headers.dart
@@ -465,42 +465,32 @@
_mutable = false;
}
- int _write(Uint8List buffer, int offset) {
- void write(List<int> bytes) {
- int len = bytes.length;
- for (int i = 0; i < len; i++) {
- buffer[offset + i] = bytes[i];
- }
- offset += len;
- }
-
- // Format headers.
+ void _build(BytesBuilder builder) {
for (String name in _headers.keys) {
List<String> values = _headers[name];
bool fold = _foldHeader(name);
var nameData = name.codeUnits;
- write(nameData);
- buffer[offset++] = _CharCode.COLON;
- buffer[offset++] = _CharCode.SP;
+ builder.add(nameData);
+ builder.addByte(_CharCode.COLON);
+ builder.addByte(_CharCode.SP);
for (int i = 0; i < values.length; i++) {
if (i > 0) {
if (fold) {
- buffer[offset++] = _CharCode.COMMA;
- buffer[offset++] = _CharCode.SP;
+ builder.addByte(_CharCode.COMMA);
+ builder.addByte(_CharCode.SP);
} else {
- buffer[offset++] = _CharCode.CR;
- buffer[offset++] = _CharCode.LF;
- write(nameData);
- buffer[offset++] = _CharCode.COLON;
- buffer[offset++] = _CharCode.SP;
+ builder.addByte(_CharCode.CR);
+ builder.addByte(_CharCode.LF);
+ builder.add(nameData);
+ builder.addByte(_CharCode.COLON);
+ builder.addByte(_CharCode.SP);
}
}
- write(values[i].codeUnits);
+ builder.add(values[i].codeUnits);
}
- buffer[offset++] = _CharCode.CR;
- buffer[offset++] = _CharCode.LF;
+ builder.addByte(_CharCode.CR);
+ builder.addByte(_CharCode.LF);
}
- return offset;
}
String toString() {
diff --git a/sdk/lib/io/http_impl.dart b/sdk/lib/io/http_impl.dart
index a965afa..ac7d67a 100644
--- a/sdk/lib/io/http_impl.dart
+++ b/sdk/lib/io/http_impl.dart
@@ -574,29 +574,20 @@
}
void _writeHeader() {
- Uint8List buffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
- int offset = 0;
-
- void write(List<int> bytes) {
- int len = bytes.length;
- for (int i = 0; i < len; i++) {
- buffer[offset + i] = bytes[i];
- }
- offset += len;
- }
+ BytesBuilder buffer = new _CopyingBytesBuilder(_OUTGOING_BUFFER_SIZE);
// Write status line.
if (headers.protocolVersion == "1.1") {
- write(_Const.HTTP11);
+ buffer.add(_Const.HTTP11);
} else {
- write(_Const.HTTP10);
+ buffer.add(_Const.HTTP10);
}
- buffer[offset++] = _CharCode.SP;
- write(statusCode.toString().codeUnits);
- buffer[offset++] = _CharCode.SP;
- write(reasonPhrase.codeUnits);
- buffer[offset++] = _CharCode.CR;
- buffer[offset++] = _CharCode.LF;
+ buffer.addByte(_CharCode.SP);
+ buffer.add(statusCode.toString().codeUnits);
+ buffer.addByte(_CharCode.SP);
+ buffer.add(reasonPhrase.codeUnits);
+ buffer.addByte(_CharCode.CR);
+ buffer.addByte(_CharCode.LF);
var session = _httpRequest._session;
if (session != null && !session._destroyed) {
@@ -630,10 +621,11 @@
headers._finalize();
// Write headers.
- offset = headers._write(buffer, offset);
- buffer[offset++] = _CharCode.CR;
- buffer[offset++] = _CharCode.LF;
- _outgoing.setHeader(buffer, offset);
+ headers._build(buffer);
+ buffer.addByte(_CharCode.CR);
+ buffer.addByte(_CharCode.LF);
+ Uint8List headerBytes = buffer.takeBytes();
+ _outgoing.setHeader(headerBytes, headerBytes.length);
}
String _findReasonPhrase(int statusCode) {
@@ -821,27 +813,18 @@
}
void _writeHeader() {
- Uint8List buffer = new Uint8List(_OUTGOING_BUFFER_SIZE);
- int offset = 0;
-
- void write(List<int> bytes) {
- int len = bytes.length;
- for (int i = 0; i < len; i++) {
- buffer[offset + i] = bytes[i];
- }
- offset += len;
- }
+ BytesBuilder buffer = new _CopyingBytesBuilder(_OUTGOING_BUFFER_SIZE);
// Write the request method.
- write(method.codeUnits);
- buffer[offset++] = _CharCode.SP;
+ buffer.add(method.codeUnits);
+ buffer.addByte(_CharCode.SP);
// Write the request URI.
- write(_requestUri().codeUnits);
- buffer[offset++] = _CharCode.SP;
+ buffer.add(_requestUri().codeUnits);
+ buffer.addByte(_CharCode.SP);
// Write HTTP/1.1.
- write(_Const.HTTP11);
- buffer[offset++] = _CharCode.CR;
- buffer[offset++] = _CharCode.LF;
+ buffer.add(_Const.HTTP11);
+ buffer.addByte(_CharCode.CR);
+ buffer.addByte(_CharCode.LF);
// Add the cookies to the headers.
if (!cookies.isEmpty) {
@@ -856,10 +839,11 @@
headers._finalize();
// Write headers.
- offset = headers._write(buffer, offset);
- buffer[offset++] = _CharCode.CR;
- buffer[offset++] = _CharCode.LF;
- _outgoing.setHeader(buffer, offset);
+ headers._build(buffer);
+ buffer.addByte(_CharCode.CR);
+ buffer.addByte(_CharCode.LF);
+ Uint8List headerBytes = buffer.takeBytes();
+ _outgoing.setHeader(headerBytes, headerBytes.length);
}
}
@@ -935,18 +919,6 @@
// Returns either a future or 'null', if it was able to write headers
// immediately.
Future writeHeaders({bool drainRequest: true, bool setOutgoing: true}) {
- Future write() {
- try {
- outbound._writeHeader();
- } catch (_) {
- // Headers too large.
- return new Future.error(new HttpException(
- "Headers size exceeded the of '$_OUTGOING_BUFFER_SIZE'"
- " bytes"));
- }
- return null;
- }
-
if (headersWritten) return null;
headersWritten = true;
Future drainFuture;
@@ -975,22 +947,22 @@
} else {
drainRequest = false;
}
- if (ignoreBody) {
- return write();
- }
- if (setOutgoing) {
- int contentLength = outbound.headers.contentLength;
- if (outbound.headers.chunkedTransferEncoding) {
- chunked = true;
- if (gzip) this.gzip = true;
- } else if (contentLength >= 0) {
- this.contentLength = contentLength;
+ if (!ignoreBody) {
+ if (setOutgoing) {
+ int contentLength = outbound.headers.contentLength;
+ if (outbound.headers.chunkedTransferEncoding) {
+ chunked = true;
+ if (gzip) this.gzip = true;
+ } else if (contentLength >= 0) {
+ this.contentLength = contentLength;
+ }
+ }
+ if (drainFuture != null) {
+ return drainFuture.then((_) => outbound._writeHeader());
}
}
- if (drainFuture != null) {
- return drainFuture.then((_) => write());
- }
- return write();
+ outbound._writeHeader();
+ return null;
}
@@ -1160,7 +1132,6 @@
void setHeader(List<int> data, int length) {
assert(_length == 0);
- assert(data.length == _OUTGOING_BUFFER_SIZE);
_buffer = data;
_length = length;
}
diff --git a/sdk/lib/io/platform.dart b/sdk/lib/io/platform.dart
index d881ce5..75f7ffd 100644
--- a/sdk/lib/io/platform.dart
+++ b/sdk/lib/io/platform.dart
@@ -120,6 +120,11 @@
static final bool isIOS = (_operatingSystem == "ios");
/**
+ * Returns true if the operating system is Fuchsia
+ */
+ static final bool isFuchsia = (_operatingSystem == "fuchsia");
+
+ /**
* Get the environment for this process.
*
* The returned environment is an unmodifiable map which content is
diff --git a/tests/co19/co19-kernel.status b/tests/co19/co19-kernel.status
index 953714c..14b67f9 100644
--- a/tests/co19/co19-kernel.status
+++ b/tests/co19/co19-kernel.status
@@ -181,7 +181,6 @@
# dartk: JIT failures (debug)
[ $compiler == dartk && $runtime == vm && $mode == debug ]
-Language/Expressions/Shift/syntax_t15: Crash # Invalid class id during isolate shutdown Heap::VerifyGC
Language/Libraries_and_Scripts/Scripts/top_level_main_t05: Crash # !main_obj.IsNull()
# dartk: precompilation failures
diff --git a/tests/co19/co19-runtime.status b/tests/co19/co19-runtime.status
index fcf344b..d2ef2f8 100644
--- a/tests/co19/co19-runtime.status
+++ b/tests/co19/co19-runtime.status
@@ -283,11 +283,11 @@
Language/Expressions/Property_Extraction/General_Super_Property_Extraction: CompileTimeError # Issue 26287
Language/Expressions/Property_Extraction/Super_Closurization: CompileTimeError # Issue 26287
-[ $noopt || $runtime == dart_precompiled || $mode == product ]
+[ $runtime == dart_precompiled || $mode == product ]
Language/Metadata/*: SkipByDesign # Uses dart:mirrors
Language/Expressions/Null/instance_of_class_null_t01: Skip # Uses dart:mirrors
-[ $noopt || $compiler == precompiler || $compiler == app_jit || $mode == product ]
+[ $compiler == precompiler || $compiler == app_jit || $mode == product ]
Language/Libraries_and_Scripts/Imports/deferred_import_t01: Skip # Eager loading
Language/Libraries_and_Scripts/Imports/deferred_import_t02: Skip # Eager loading
Language/Libraries_and_Scripts/Imports/invalid_uri_deferred_t01: Skip # Eager loading
@@ -296,13 +296,13 @@
[ $runtime == dart_precompiled || $compiler == app_jit ]
LibTest/isolate/Isolate/spawnUri*: SkipByDesign # Isolate.spawnUri
-[ $noopt || $compiler == precompiler ]
+[ $compiler == precompiler ]
LibTest/collection/ListBase/ListBase_class_A01_t02: Pass, Timeout
LibTest/collection/ListMixin/ListMixin_class_A01_t02: Pass, Timeout
LibTest/core/Map/Map_class_A01_t04: Pass, Timeout
LibTest/core/Uri/encodeQueryComponent_A01_t02: Pass, Timeout
-[ $noopt || $compiler == precompiler || $compiler == app_jit ]
+[ $compiler == precompiler || $compiler == app_jit ]
Language/Mixins/Mixin_Application/error_t01: Pass
Language/Mixins/Mixin_Application/error_t02: Pass
Language/Mixins/declaring_constructor_t01: Pass
diff --git a/tests/compiler/dart2js/assert_message_throw_test.dart b/tests/compiler/dart2js/assert_message_throw_test.dart
index 898e3aa..a876232 100644
--- a/tests/compiler/dart2js/assert_message_throw_test.dart
+++ b/tests/compiler/dart2js/assert_message_throw_test.dart
@@ -59,7 +59,8 @@
memorySourceFiles: {'main.dart': SOURCE},
options: [Flags.enableCheckedMode, Flags.enableAssertMessage]);
Compiler compiler = result.compiler;
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
void check(String methodName, TypeMask expectedReturnType) {
Element element = compiler.mainApp.find(methodName);
diff --git a/tests/compiler/dart2js/check_elements_invariants_test.dart b/tests/compiler/dart2js/check_elements_invariants_test.dart
index e0c5ee5..fa6bd53 100644
--- a/tests/compiler/dart2js/check_elements_invariants_test.dart
+++ b/tests/compiler/dart2js/check_elements_invariants_test.dart
@@ -19,8 +19,8 @@
Iterable<ClassElement> computeLiveClasses(CompilerImpl compiler) {
return new Set<ClassElement>()
- ..addAll(compiler.resolverWorld.directlyInstantiatedClasses)
- ..addAll(compiler.codegenWorld.directlyInstantiatedClasses);
+ ..addAll(compiler.resolutionWorldBuilder.directlyInstantiatedClasses)
+ ..addAll(compiler.codegenWorldBuilder.directlyInstantiatedClasses);
}
void checkClassInvariants(ClassElement cls) {
diff --git a/tests/compiler/dart2js/concrete_type_inference_test.dart b/tests/compiler/dart2js/concrete_type_inference_test.dart
index 2efb5d7..7f6b8cc 100644
--- a/tests/compiler/dart2js/concrete_type_inference_test.dart
+++ b/tests/compiler/dart2js/concrete_type_inference_test.dart
@@ -20,7 +20,7 @@
asyncTest(() => compileAndFind('main() { print($expression); }', 'print',
(compiler, printElement) {
var parameter = printElement.functionSignature.requiredParameters.first;
- checkType(compiler.resolverWorld.closedWorldForTesting,
+ checkType(compiler.resolutionWorldBuilder.closedWorldForTesting,
_typeOf(compiler, parameter));
}));
@@ -28,7 +28,7 @@
compileAndFind('main() { var x = print; print($expression); }', 'print',
(compiler, printElement) {
var parameter = printElement.functionSignature.requiredParameters.first;
- checkType(compiler.resolverWorld.closedWorldForTesting,
+ checkType(compiler.resolutionWorldBuilder.closedWorldForTesting,
_typeOf(compiler, parameter));
}));
@@ -36,7 +36,7 @@
'main() { print($expression); print($expression); }', 'print',
(compiler, printElement) {
var parameter = printElement.functionSignature.requiredParameters.first;
- checkType(compiler.resolverWorld.closedWorldForTesting,
+ checkType(compiler.resolutionWorldBuilder.closedWorldForTesting,
_typeOf(compiler, parameter));
}));
}
@@ -71,7 +71,8 @@
var firstParameter = fiskElement.functionSignature.requiredParameters[0];
var secondParameter = fiskElement.functionSignature.optionalParameters[0];
var thirdParameter = fiskElement.functionSignature.optionalParameters[1];
- var commonMasks = compiler.resolverWorld.closedWorldForTesting.commonMasks;
+ var commonMasks =
+ compiler.resolutionWorldBuilder.closedWorldForTesting.commonMasks;
Expect.identical(commonMasks.uint31Type, _typeOf(compiler, firstParameter));
Expect.identical(commonMasks.nullType, _typeOf(compiler, secondParameter));
Expect.identical(commonMasks.nullType, _typeOf(compiler, thirdParameter));
diff --git a/tests/compiler/dart2js/dump_info_test.dart b/tests/compiler/dart2js/dump_info_test.dart
index 3778de3..b25f243 100644
--- a/tests/compiler/dart2js/dump_info_test.dart
+++ b/tests/compiler/dart2js/dump_info_test.dart
@@ -104,7 +104,8 @@
var dumpTask = compiler.dumpInfoTask;
StringBuffer sb = new StringBuffer();
- dumpTask.dumpInfoJson(sb, compiler.resolverWorld.closedWorldForTesting);
+ dumpTask.dumpInfoJson(
+ sb, compiler.resolutionWorldBuilder.closedWorldForTesting);
String json = sb.toString();
Map<String, dynamic> map = JSON.decode(json);
diff --git a/tests/compiler/dart2js/expect_annotations_test.dart b/tests/compiler/dart2js/expect_annotations_test.dart
index 9af76b7..851dc65 100644
--- a/tests/compiler/dart2js/expect_annotations_test.dart
+++ b/tests/compiler/dart2js/expect_annotations_test.dart
@@ -52,7 +52,8 @@
CompilationResult result =
await runCompiler(memorySourceFiles: MEMORY_SOURCE_FILES);
Compiler compiler = result.compiler;
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
Expect.isFalse(compiler.compilationFailed, 'Unsuccessful compilation');
JavaScriptBackend backend = compiler.backend;
Expect.isNotNull(backend.annotations.expectNoInlineClass,
diff --git a/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart b/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
index d4e866e..205682c 100644
--- a/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
+++ b/tests/compiler/dart2js/gvn_dynamic_field_get_test.dart
@@ -36,7 +36,7 @@
var element = cls.lookupLocalMember(name);
Expect.isNotNull(element);
Selector selector = new Selector.getter(new PublicName(name));
- Expect.isFalse(compiler.resolverWorld.closedWorldForTesting
+ Expect.isFalse(compiler.resolutionWorldBuilder.closedWorldForTesting
.hasAnyUserDefinedGetter(selector, null));
}));
}
diff --git a/tests/compiler/dart2js/instantiated_classes_test.dart b/tests/compiler/dart2js/instantiated_classes_test.dart
index adeca4c..35232db 100644
--- a/tests/compiler/dart2js/instantiated_classes_test.dart
+++ b/tests/compiler/dart2js/instantiated_classes_test.dart
@@ -93,7 +93,7 @@
Iterable<ClassElement> expectedClasses =
directlyInstantiatedClasses.map(env.getElement);
Iterable<ClassElement> actualClasses = env
- .compiler.resolverWorld.directlyInstantiatedClasses
+ .compiler.resolutionWorldBuilder.directlyInstantiatedClasses
.where((c) => c.library == env.compiler.mainApp);
Expect.setEquals(expectedClasses, actualClasses);
});
diff --git a/tests/compiler/dart2js/kernel/closed_world_test.dart b/tests/compiler/dart2js/kernel/closed_world_test.dart
index 8757183..6a3f583 100644
--- a/tests/compiler/dart2js/kernel/closed_world_test.dart
+++ b/tests/compiler/dart2js/kernel/closed_world_test.dart
@@ -76,11 +76,11 @@
Flags.enableAssertMessage
]);
ResolutionWorldBuilderImpl worldBuilder =
- compiler.enqueuer.resolution.universe;
+ compiler.enqueuer.resolution.worldBuilder;
worldBuilder.useInstantiationMap = true;
compiler.resolution.retainCachesForTesting = true;
await compiler.run(entryPoint);
- compiler.resolverWorld.closeWorld(compiler.reporter);
+ compiler.resolutionWorldBuilder.closeWorld(compiler.reporter);
JavaScriptBackend backend = compiler.backend;
// Create a new resolution enqueuer and feed it with the [WorldImpact]s
@@ -114,7 +114,8 @@
.transformResolutionImpact(enqueuer, resolutionImpact);
enqueuer.applyImpact(worldImpact, impactSource: element);
});
- ClosedWorld closedWorld = enqueuer.universe.closeWorld(compiler.reporter);
+ ClosedWorld closedWorld =
+ enqueuer.worldBuilder.closeWorld(compiler.reporter);
checkResolutionEnqueuers(compiler.enqueuer.resolution, enqueuer,
typeEquivalence: (ResolutionDartType a, ResolutionDartType b) {
@@ -135,7 +136,8 @@
}
return true;
}, verbose: arguments.verbose);
- checkClosedWorlds(compiler.resolverWorld.closedWorldForTesting, closedWorld,
+ checkClosedWorlds(
+ compiler.resolutionWorldBuilder.closedWorldForTesting, closedWorld,
verbose: arguments.verbose);
});
}
diff --git a/tests/compiler/dart2js/minimal_resolution_test.dart b/tests/compiler/dart2js/minimal_resolution_test.dart
index 72b524b..14dec29 100644
--- a/tests/compiler/dart2js/minimal_resolution_test.dart
+++ b/tests/compiler/dart2js/minimal_resolution_test.dart
@@ -25,7 +25,7 @@
void checkInstantiated(Compiler compiler, ClassElement cls, bool expected) {
ResolutionEnqueuer enqueuer = compiler.enqueuer.resolution;
bool isInstantiated =
- enqueuer.universe.directlyInstantiatedClasses.contains(cls);
+ enqueuer.worldBuilder.directlyInstantiatedClasses.contains(cls);
bool isProcessed = enqueuer.processedClasses.contains(cls);
Expect.equals(expected, isInstantiated,
'Unexpected instantiation state of class $cls.');
diff --git a/tests/compiler/dart2js/patch_test.dart b/tests/compiler/dart2js/patch_test.dart
index 1c84bbe..c95cd5d 100644
--- a/tests/compiler/dart2js/patch_test.dart
+++ b/tests/compiler/dart2js/patch_test.dart
@@ -974,7 +974,7 @@
runCompiler: true,
analyzeOnly: true);
compiler.closeResolution();
- ClosedWorld world = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld world = compiler.resolutionWorldBuilder.closedWorldForTesting;
ClassElement cls = ensure(
compiler, "A", compiler.commonElements.coreLibrary.find,
diff --git a/tests/compiler/dart2js/related_types.dart b/tests/compiler/dart2js/related_types.dart
index de75f5b..8b48303 100644
--- a/tests/compiler/dart2js/related_types.dart
+++ b/tests/compiler/dart2js/related_types.dart
@@ -78,7 +78,8 @@
: this.resolvedAst = resolvedAst,
super(resolvedAst.elements);
- ClosedWorld get world => compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld get world =>
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
CommonElements get commonElements => compiler.commonElements;
diff --git a/tests/compiler/dart2js/resolver_test.dart b/tests/compiler/dart2js/resolver_test.dart
index 3035fbf..d1c90be 100644
--- a/tests/compiler/dart2js/resolver_test.dart
+++ b/tests/compiler/dart2js/resolver_test.dart
@@ -149,8 +149,9 @@
visitor.visit(definition.type);
ResolutionInterfaceType type =
visitor.registry.mapping.getType(definition.type);
+ NominalTypeAnnotation annotation = definition.type;
Expect.equals(
- definition.type.typeArguments.slowLength(), type.typeArguments.length);
+ annotation.typeArguments.slowLength(), type.typeArguments.length);
int index = 0;
for (ResolutionDartType argument in type.typeArguments) {
Expect.equals(true, index < expectedElements.length);
@@ -700,7 +701,8 @@
Expect.equals(ElementKind.FIELD, element.kind);
VariableDefinitions node =
element.variables.parseNode(element, compiler.parsingContext);
- Identifier typeName = node.type.typeName;
+ NominalTypeAnnotation annotation = node.type;
+ Identifier typeName = annotation.typeName;
Expect.equals(typeName.source, 'int');
compiler.parseScript("var b, c;");
diff --git a/tests/compiler/dart2js/serialization/members_test.dart b/tests/compiler/dart2js/serialization/members_test.dart
index 22e0899..42b9c87 100644
--- a/tests/compiler/dart2js/serialization/members_test.dart
+++ b/tests/compiler/dart2js/serialization/members_test.dart
@@ -87,12 +87,13 @@
Name convertName(Name name, Compiler compiler) {
if (name.isPrivate) {
- LibraryElement library =
- compiler.libraryLoader.lookupLibrary(name.library.canonicalUri);
- if (!areElementsEquivalent(name.library, library)) {
- throw 'Libraries ${name.library} and ${library} are not equivalent';
+ LibraryElement library1 = name.library;
+ LibraryElement library2 =
+ compiler.libraryLoader.lookupLibrary(library1.canonicalUri);
+ if (!areElementsEquivalent(library1, library2)) {
+ throw 'Libraries ${library1} and ${library2} are not equivalent';
}
- name = new Name(name.text, library, isSetter: name.isSetter);
+ name = new Name(name.text, library2, isSetter: name.isSetter);
}
return name;
}
diff --git a/tests/compiler/dart2js/serialization/model_test_helper.dart b/tests/compiler/dart2js/serialization/model_test_helper.dart
index 5e1c667..66e73cb 100644
--- a/tests/compiler/dart2js/serialization/model_test_helper.dart
+++ b/tests/compiler/dart2js/serialization/model_test_helper.dart
@@ -98,8 +98,9 @@
checkResolutionEnqueuers(compilerNormal.enqueuer.resolution,
compilerDeserialized.enqueuer.resolution,
verbose: verbose);
- checkClosedWorlds(compilerNormal.resolverWorld.closedWorldForTesting,
- compilerDeserialized.resolverWorld.closedWorldForTesting,
+ checkClosedWorlds(
+ compilerNormal.resolutionWorldBuilder.closedWorldForTesting,
+ compilerDeserialized.resolutionWorldBuilder.closedWorldForTesting,
verbose: verbose);
checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
});
@@ -115,8 +116,8 @@
"Processed element mismatch", areElementsEquivalent,
elementFilter: elementFilter, verbose: verbose);
- ResolutionWorldBuilderImpl worldBuilder1 = enqueuer1.universe;
- ResolutionWorldBuilderImpl worldBuilder2 = enqueuer2.universe;
+ ResolutionWorldBuilderImpl worldBuilder1 = enqueuer1.worldBuilder;
+ ResolutionWorldBuilderImpl worldBuilder2 = enqueuer2.worldBuilder;
checkMaps(
worldBuilder1.getInstantiationMap(),
@@ -127,20 +128,20 @@
verbose: verbose);
checkSets(
- enqueuer1.universe.directlyInstantiatedClasses,
- enqueuer2.universe.directlyInstantiatedClasses,
+ enqueuer1.worldBuilder.directlyInstantiatedClasses,
+ enqueuer2.worldBuilder.directlyInstantiatedClasses,
"Directly instantiated classes mismatch",
areElementsEquivalent,
verbose: verbose);
checkSets(
- enqueuer1.universe.instantiatedTypes,
- enqueuer2.universe.instantiatedTypes,
+ enqueuer1.worldBuilder.instantiatedTypes,
+ enqueuer2.worldBuilder.instantiatedTypes,
"Instantiated types mismatch",
typeEquivalence,
verbose: verbose);
- checkSets(enqueuer1.universe.isChecks, enqueuer2.universe.isChecks,
+ checkSets(enqueuer1.worldBuilder.isChecks, enqueuer2.worldBuilder.isChecks,
"Is-check mismatch", typeEquivalence,
verbose: verbose);
diff --git a/tests/compiler/dart2js/simple_inferrer_callers_test.dart b/tests/compiler/dart2js/simple_inferrer_callers_test.dart
index dc2b4f9..6bf7e6a 100644
--- a/tests/compiler/dart2js/simple_inferrer_callers_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_callers_test.dart
@@ -40,7 +40,8 @@
var compiler = compilerFor(TEST, uri, analyzeOnly: true);
asyncTest(() => compiler.run(uri).then((_) {
ClosedWorldRefiner closedWorldRefiner = compiler.closeResolution();
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
var inferrer =
new MyInferrer(compiler, closedWorld, closedWorldRefiner);
compiler.globalInference.typesInferrerInternal = inferrer;
diff --git a/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart b/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
index dcddd20..b54fd01 100644
--- a/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
+++ b/tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart
@@ -174,7 +174,7 @@
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST1, uri);
await compiler.run(uri);
- var closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', closedWorld.commonMasks.uint31Type);
checkReturn(
compiler, 'test2', closedWorld.commonMasks.dynamicType.nonNullable());
@@ -190,7 +190,7 @@
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST2, uri);
await compiler.run(uri);
- var closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', closedWorld.commonMasks.mapType.nonNullable());
checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
@@ -209,7 +209,7 @@
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST3, uri);
await compiler.run(uri);
- var closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', const TypeMask.nonNullEmpty());
checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
@@ -222,7 +222,7 @@
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(TEST4, uri);
await compiler.run(uri);
- var closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
checkReturn(compiler, 'test1', const TypeMask.nonNullEmpty());
checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
diff --git a/tests/compiler/dart2js/type_combination_test.dart b/tests/compiler/dart2js/type_combination_test.dart
index 9638ca2..153ef44 100644
--- a/tests/compiler/dart2js/type_combination_test.dart
+++ b/tests/compiler/dart2js/type_combination_test.dart
@@ -102,7 +102,8 @@
}
void testUnion(MockCompiler compiler) {
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
RuleSet ruleSet = new RuleSet(
'union', (t1, t2) => simplify(t1.union(t2, closedWorld), closedWorld));
rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@@ -416,7 +417,8 @@
void testIntersection(MockCompiler compiler) {
JavaScriptBackend backend = compiler.backend;
BackendHelpers helpers = backend.helpers;
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
RuleSet ruleSet =
new RuleSet('intersection', (t1, t2) => t1.intersection(t2, closedWorld));
rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@@ -726,7 +728,8 @@
}
void testRegressions(MockCompiler compiler) {
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
TypeMask nonNullPotentialString =
new TypeMask.nonNullSubtype(patternClass, closedWorld);
Expect.equals(potentialString,
@@ -760,7 +763,8 @@
.registerTypeUse(new TypeUse.instantiation(patternImplClass.rawType));
compiler.enqueuer.resolution.applyImpact(impactBuilder);
compiler.closeResolution();
- ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ ClosedWorld closedWorld =
+ compiler.resolutionWorldBuilder.closedWorldForTesting;
// Grab hold of a supertype for String so we can produce potential
// string types.
diff --git a/tests/compiler/dart2js/type_mask_disjoint_test.dart b/tests/compiler/dart2js/type_mask_disjoint_test.dart
index 928bedf..48d3a98 100644
--- a/tests/compiler/dart2js/type_mask_disjoint_test.dart
+++ b/tests/compiler/dart2js/type_mask_disjoint_test.dart
@@ -36,7 +36,7 @@
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(CODE, uri);
-var world = compiler.resolverWorld.closedWorldForTesting;
+var world = compiler.resolutionWorldBuilder.closedWorldForTesting;
main() {
asyncTest(() => compiler.run(uri).then((_) {
diff --git a/tests/compiler/dart2js/type_mask_test.dart b/tests/compiler/dart2js/type_mask_test.dart
index 6d0d958..e3fd1cb 100644
--- a/tests/compiler/dart2js/type_mask_test.dart
+++ b/tests/compiler/dart2js/type_mask_test.dart
@@ -22,7 +22,7 @@
Uri uri = new Uri(scheme: 'source');
var compiler = compilerFor(CODE, uri);
compiler.closeResolution();
- var closedWorld = compiler.resolverWorld.closedWorldForTesting;
+ var closedWorld = compiler.resolutionWorldBuilder.closedWorldForTesting;
asyncTest(() => compiler.run(uri).then((_) {
var classA = findElement(compiler, 'A');
diff --git a/tests/compiler/dart2js/type_test_helper.dart b/tests/compiler/dart2js/type_test_helper.dart
index c221dfe..10a5cea 100644
--- a/tests/compiler/dart2js/type_test_helper.dart
+++ b/tests/compiler/dart2js/type_test_helper.dart
@@ -94,6 +94,8 @@
return element;
}
+ ClassElement getClass(String name) => getElement(name);
+
ResolutionDartType getElementType(String name) {
var element = getElement(name);
return element.computeType(compiler.resolution);
@@ -145,6 +147,6 @@
}
ClosedWorld get closedWorld {
- return compiler.resolverWorld.closedWorldForTesting;
+ return compiler.resolutionWorldBuilder.closedWorldForTesting;
}
}
diff --git a/tests/compiler/dart2js/union_type_test.dart b/tests/compiler/dart2js/union_type_test.dart
index 243a066..28edfa5 100644
--- a/tests/compiler/dart2js/union_type_test.dart
+++ b/tests/compiler/dart2js/union_type_test.dart
@@ -24,8 +24,8 @@
useMockCompiler: false);
env.compiler.closeResolution();
ClosedWorld world = env.closedWorld;
- FlatTypeMask mask1 = new FlatTypeMask.exact(env.getElement('A'));
- FlatTypeMask mask2 = new FlatTypeMask.exact(env.getElement('B'));
+ FlatTypeMask mask1 = new FlatTypeMask.exact(env.getClass('A'));
+ FlatTypeMask mask2 = new FlatTypeMask.exact(env.getClass('B'));
UnionTypeMask union1 = mask1.nonNullable().union(mask2, world);
UnionTypeMask union2 = mask2.nonNullable().union(mask1, world);
Expect.equals(union1, union2);
diff --git a/tests/compiler/dart2js/world_test.dart b/tests/compiler/dart2js/world_test.dart
index b8f49f9..6b03817 100644
--- a/tests/compiler/dart2js/world_test.dart
+++ b/tests/compiler/dart2js/world_test.dart
@@ -11,13 +11,14 @@
import 'package:compiler/src/elements/elements.dart'
show Element, ClassElement, LibraryElement;
import 'package:compiler/src/universe/class_set.dart';
-import 'package:compiler/src/world.dart' show ClosedWorld;
+import 'package:compiler/src/world.dart' show ClassQuery, ClosedWorld;
void main() {
asyncTest(() async {
await testClassSets();
await testProperties();
await testNativeClasses();
+ await testCommonSubclasses();
});
}
@@ -510,3 +511,99 @@
instantiatedSubclassCount: 0,
instantiatedSubtypeCount: 0);
}
+
+testCommonSubclasses() async {
+ var env = await TypeEnvironment.create('',
+ mainSource: r"""
+ class A {}
+ class B {}
+ class C extends A {}
+ class D implements A {}
+ class E extends B {}
+ class F implements C, E {}
+ class G extends C implements E {}
+ class H implements C {}
+ class I extends D implements E {}
+ class J extends E implements D {}
+ main() {
+ new A();
+ new B();
+ new C();
+ new D();
+ new E();
+ new F();
+ new G();
+ new H();
+ new I();
+ new J();
+ }
+ """,
+ useMockCompiler: false);
+ ClosedWorld closedWorld = env.closedWorld;
+
+ ClassElement Object_ = env.getElement("Object");
+ ClassElement A = env.getElement("A");
+ ClassElement B = env.getElement("B");
+ ClassElement C = env.getElement("C");
+ ClassElement D = env.getElement("D");
+ ClassElement F = env.getElement("F");
+ ClassElement G = env.getElement("G");
+ ClassElement H = env.getElement("H");
+ ClassElement I = env.getElement("I");
+ ClassElement J = env.getElement("J");
+
+ void check(ClassElement cls1, ClassQuery query1, ClassElement cls2,
+ ClassQuery query2, List<ClassElement> expectedResult) {
+ Iterable<ClassElement> result1 =
+ closedWorld.commonSubclasses(cls1, query1, cls2, query2);
+ Iterable<ClassElement> result2 =
+ closedWorld.commonSubclasses(cls2, query2, cls1, query1);
+ Expect.setEquals(
+ result1,
+ result2,
+ "Asymmetric results for ($cls1,$query1) vs ($cls2,$query2):"
+ "\n a vs b: $result1\n b vs a: $result2");
+ Expect.setEquals(
+ expectedResult,
+ result1,
+ "Unexpected results for ($cls1,$query1) vs ($cls2,$query2):"
+ "\n expected: $expectedResult\n actual: $result1");
+ }
+
+ check(A, ClassQuery.EXACT, A, ClassQuery.EXACT, []);
+ check(A, ClassQuery.EXACT, A, ClassQuery.SUBCLASS, []);
+ check(A, ClassQuery.EXACT, A, ClassQuery.SUBTYPE, []);
+ check(A, ClassQuery.SUBCLASS, A, ClassQuery.SUBCLASS, [C]);
+ check(A, ClassQuery.SUBCLASS, A, ClassQuery.SUBTYPE, [C]);
+ check(A, ClassQuery.SUBTYPE, A, ClassQuery.SUBTYPE, [C, D]);
+
+ check(A, ClassQuery.EXACT, B, ClassQuery.EXACT, []);
+ check(A, ClassQuery.EXACT, B, ClassQuery.SUBCLASS, []);
+ check(A, ClassQuery.SUBCLASS, B, ClassQuery.EXACT, []);
+ check(A, ClassQuery.EXACT, B, ClassQuery.SUBTYPE, []);
+ check(A, ClassQuery.SUBTYPE, B, ClassQuery.EXACT, []);
+ check(A, ClassQuery.SUBCLASS, B, ClassQuery.SUBCLASS, []);
+ check(A, ClassQuery.SUBCLASS, B, ClassQuery.SUBTYPE, [G]);
+ check(A, ClassQuery.SUBTYPE, B, ClassQuery.SUBCLASS, [J]);
+ check(A, ClassQuery.SUBTYPE, B, ClassQuery.SUBTYPE, [F, G, I, J]);
+
+ check(A, ClassQuery.EXACT, C, ClassQuery.EXACT, []);
+ check(A, ClassQuery.EXACT, C, ClassQuery.SUBCLASS, []);
+ check(A, ClassQuery.SUBCLASS, C, ClassQuery.EXACT, []);
+ check(A, ClassQuery.EXACT, C, ClassQuery.SUBTYPE, []);
+ check(A, ClassQuery.SUBTYPE, C, ClassQuery.EXACT, []);
+ check(A, ClassQuery.SUBCLASS, C, ClassQuery.SUBCLASS, [G]);
+ check(A, ClassQuery.SUBCLASS, C, ClassQuery.SUBTYPE, [G]);
+ check(A, ClassQuery.SUBTYPE, C, ClassQuery.SUBCLASS, [G]);
+ check(A, ClassQuery.SUBTYPE, C, ClassQuery.SUBTYPE, [F, G, H]);
+
+ check(B, ClassQuery.EXACT, C, ClassQuery.EXACT, []);
+ check(B, ClassQuery.EXACT, C, ClassQuery.SUBCLASS, []);
+ check(B, ClassQuery.SUBCLASS, C, ClassQuery.EXACT, []);
+ check(B, ClassQuery.EXACT, C, ClassQuery.SUBTYPE, []);
+ check(B, ClassQuery.SUBTYPE, C, ClassQuery.EXACT, []);
+ check(B, ClassQuery.SUBCLASS, C, ClassQuery.SUBCLASS, []);
+ check(B, ClassQuery.SUBCLASS, C, ClassQuery.SUBTYPE, []);
+ check(B, ClassQuery.SUBTYPE, C, ClassQuery.SUBCLASS, [G]);
+ check(B, ClassQuery.SUBTYPE, C, ClassQuery.SUBTYPE, [F, G]);
+}
diff --git a/tests/corelib/corelib.status b/tests/corelib/corelib.status
index c730f6e..f64a564 100644
--- a/tests/corelib/corelib.status
+++ b/tests/corelib/corelib.status
@@ -188,15 +188,14 @@
regexp/pcre_test: Crash # Stack Overflow
collection_removes_test: Crash # Issue 25911
-[ $noopt || $compiler == precompiler ]
+[ $compiler == precompiler || $mode == product ]
+apply3_test: SkipByDesign # Imports dart:mirrors
+
+[ $compiler == precompiler ]
# Stacktraces in precompilation omit inlined frames.
stacktrace_current_test: Pass, RuntimeError
error_stack_trace1_test: Pass, RuntimeError
-[ $noopt || $compiler == precompiler || $mode == product ]
-apply3_test: SkipByDesign # Imports dart:mirrors
-
-[ $noopt || $compiler == precompiler ]
regexp/stack-overflow_test: RuntimeError, OK # Smaller limit with irregex interpreter
big_integer_huge_mul_vm_test: Pass, Timeout # --no_intrinsify
big_integer_parsed_mul_div_vm_test: Pass, Timeout # --no_intrinsify
diff --git a/tests/corelib/uri_test.dart b/tests/corelib/uri_test.dart
index 9e4b24f..d4ca36d 100644
--- a/tests/corelib/uri_test.dart
+++ b/tests/corelib/uri_test.dart
@@ -755,6 +755,25 @@
Expect.equals("s://:1/b/c?d#e", uri.replace(host: "").toString());
}
+void testRegression28359() {
+ var uri = new Uri(path: "//");
+ // This is an invalid path for a URI reference with no authority
+ // since it looks like an authority.
+ // Normalized to have an authority.
+ Expect.equals("////", "$uri");
+ Expect.equals("//", uri.path);
+ Expect.isTrue(uri.hasAuthority, "$uri has authority");
+
+ uri = new Uri(path: "file:///wat");
+ // This is an invalid pat for a URI reference with no authority or scheme
+ // since the path looks like it starts with a scheme.
+ // Normalized by escaping the ":".
+ Expect.equals("file%3A///wat", uri.path);
+ Expect.equals("file%3A///wat", "$uri");
+ Expect.isFalse(uri.hasAuthority);
+ Expect.isFalse(uri.hasScheme);
+}
+
main() {
testUri("http:", true);
testUri("file:///", true);
@@ -921,6 +940,7 @@
testInvalidUrls();
testNormalization();
testReplace();
+ testRegression28359();
}
String dump(Uri uri) {
diff --git a/tests/isolate/isolate.status b/tests/isolate/isolate.status
index 02c7df0..7d5e61ef 100644
--- a/tests/isolate/isolate.status
+++ b/tests/isolate/isolate.status
@@ -156,6 +156,12 @@
message3_test/int32x4: RuntimeError, OK # Uses Isolate.spawn.
browser/package_resolve_browser_hook*: Skip # Tests that use defaultPackagesBase (not supported in Dartium).
+[ ($compiler == none) && ( $runtime == dartium || $runtime == drt) ]
+browser/package_resolve_browser_test: Fail # Issue 28382
+
+[ ($compiler == none) && ( $runtime == dartium || $runtime == drt) && ($system == windows) ]
+browser/package_resolve_browser_test: Skip # Temporarily disabled working on CL to fix under Windows.
+
[ $compiler == dart2analyzer ]
browser/typed_data_message_test: StaticWarning
mint_maker_test: StaticWarning
@@ -170,7 +176,7 @@
spawn_uri_fail_test: SkipByDesign # Uses dart:io.
scenarios/*: SkipByDesign # Use automatic package resolution, spawnFunction and .dart URIs.
-[ $noopt || $compiler == precompiler || $mode == product ]
+[ $compiler == precompiler || $mode == product ]
# Imports dart:mirrors
count_test: SkipByDesign
cross_isolate_message_test: SkipByDesign
diff --git a/tests/language/covariant_test.dart b/tests/language/covariant_test.dart
index b93c901..c98fbb0 100644
--- a/tests/language/covariant_test.dart
+++ b/tests/language/covariant_test.dart
@@ -16,6 +16,10 @@
covariant /// 00: compile-time error
int x0;
+covariant int covariant; /// 00b: compile-time error
+
+int covariant; /// 00c: ok
+
// Getters may never have `covariant`. (Neither on the top-level nor as members)
covariant /// 01: compile-time error
int get x1 => 499;
@@ -48,6 +52,8 @@
// Since `covariant` is a built-in identifier, it is not allowed here.
covariant x6; /// 06: compile-time error
+covariant covariant; /// 06b: compile-time error
+
// Getters may never have `covariant`.
covariant /// 07: compile-time error
get x7 => 499;
@@ -112,6 +118,8 @@
// On its own, `covariant` is just a parameter name.
int f18(covariant) => covariant;
+covariant; /// 19: compile-time error
+
// All of the above as statics in a class.
class A {
// Static fields may not have a covariant.
@@ -120,6 +128,10 @@
covariant /// 20: compile-time error
int x20;
+ static covariant int covariant /// 20b: compile-time error
+
+ static int covariant; /// 20c: ok
+
// Getters may never have `covariant`.
static
covariant /// 21: compile-time error
@@ -154,6 +166,7 @@
// Since `covariant` is a built-in identifier, it is not allowed here.
static covariant x26; /// 26: compile-time error
+ static covariant covariant; /// 26b: compile-time error
// Getters may never have `covariant`.
static
@@ -233,17 +246,27 @@
// `Covariant` on its own is just a parameter name.
static int f38(covariant) => covariant;
+
+ static covariant; /// 39: compile-time error
+
}
// All of the above as instance members in a class.
class B {
- covariant int x40;
+ covariant /// 40: ok
+ int x40;
+
+ covariant int covariant; /// 40b: ok
+
+ int covariant; /// 40c: ok
// Getters may never have `covariant`.
covariant /// 41: compile-time error
int get x41 => 499;
- void set x42(covariant int val) {}
+ void set x42(
+ covariant /// 42: ok
+ int val) {}
// `covariant` in the wrong position.
int
@@ -262,12 +285,15 @@
// Since `covariant` is a built-in identifier, it is not allowed here.
covariant x46; /// 46: compile-time error
+ covariant covariant; /// 46b: compile-time error
// Getters may never have `covariant`.
covariant /// 47: compile-time error
get x47 => 499;
- void set x48(covariant val) {}
+ void set x48(
+ covariant /// 48: ok
+ val) {}
// If there is no type, then `covariant` is simply the parameter name:
void set x49(covariant) {}
@@ -280,7 +306,9 @@
covariant /// 51: compile-time error
f51() => 499;
- int f52(covariant int x) => 499;
+ int f52(
+ covariant /// 52: ok
+ int x) => 499;
// `Covariant` must be in front of the types.
int f53(
@@ -288,7 +316,9 @@
covariant /// 53: compile-time error
x) => 499;
- int f54(covariant final x) => 499;
+ int f54(
+ covariant /// 54: ok
+ final x) => 499;
// `Covariant` must be in front of modifiers.
int f55(
@@ -296,7 +326,9 @@
covariant /// 55: compile-time error
x) => 499;
- int f56(covariant final int x) => 499;
+ int f56(
+ covariant /// 56: ok
+ final int x) => 499;
// `Covariant` must be in front of modifiers.
int f57(
@@ -307,18 +339,23 @@
// `Covariant` on its own is just a parameter name.
int f58(covariant) => covariant;
+
+ covariant; /// 59: compile-time error
}
void use(x) {}
main() {
x0 = 0;
+ covariant = 0; /// 00b: continued
+ covariant = 0; /// 00c: continued
use(x1);
x2 = 499;
use(x3);
use(x4);
x5 = 42;
x6 = 0; /// 06: continued
+ covariant = 0; /// 06b: continued
use(x7);
x8 = 11;
x9 = 12;
@@ -331,8 +368,11 @@
use(f16(3));
use(f17(3));
Expect.equals(123, f18(123));
+ use(covariant); /// 19: continued
A.x20 = 0;
+ A.covariant = 0; /// 20b: continued
+ A.covariant = 0; /// 20c: continued
use(A.x21);
use(A.x21b);
A.x22 = 499;
@@ -340,6 +380,7 @@
use(A.x24);
A.x25 = 42;
A.x26 = 0; /// 26: continued
+ A.covariant = 0; /// 26b: continued
use(A.x27);
use(A.x27b);
A.x28 = 11;
@@ -354,15 +395,19 @@
use(A.f36(3));
use(A.f37(3));
Expect.equals(1234, A.f38(1234));
+ use(A.covariant); /// 39: continued
var b = new B();
b.x40 = 0;
+ b.covariant = 0; /// 40b: continued
+ b.covariant = 0; /// 40c: continued
use(b.x41);
b.x42 = 499;
use(b.x43);
use(b.x44);
b.x45 = 42;
b.x46 = 0; /// 46: continued
+ b.covariant = 0; /// 46b: continued
use(b.x47);
b.x48 = 11;
b.x49 = 12;
@@ -375,4 +420,5 @@
use(b.f56(3));
use(b.f57(3));
Expect.equals(12345, b.f58(12345));
+ use(B.covariant); /// 59: continued
}
\ No newline at end of file
diff --git a/tests/language/generalized_function_type_test.dart b/tests/language/generalized_function_type_test.dart
new file mode 100644
index 0000000..a369241
--- /dev/null
+++ b/tests/language/generalized_function_type_test.dart
@@ -0,0 +1,795 @@
+// 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.
+
+import 'generated_function_syntax_tests.dart';
+
+// By convention:
+//
+// T: generic type of typedef.
+// A: generic type of returned function.
+// B: generic type of function.
+//
+// Example:
+// typedef F<T>: Function<A> Function<B>();
+//
+// We only use: Function, List, int (and function types).
+// We import 'dart:core' directly and with prefix 'core'.
+
+abstract class Printable {
+ /// Builds a descriptive string that can be used as an identifier.
+ ///
+ /// The string is mainly used for disambiguation, and not for its readability.
+ void writeIdentifier(StringBuffer buffer);
+}
+
+abstract class TypeLike implements Printable {
+ /// Prints `this` as valid Dart code for a Type.
+ void writeType(StringBuffer buffer);
+
+ /// Whether this instance uses T in some way.
+ bool get usesT;
+}
+
+/// Provides a unique integer for every parameter in a function.
+int parameterNameCounter = 0;
+
+/// Whether `T` should be replaced with `int`.
+bool shouldReplaceTWithInt = false;
+
+class Parameter implements Printable {
+ final TypeLike type;
+ final String name;
+
+ Parameter(this.type, this.name);
+
+ // Type or name can be null.
+ @override
+ writeIdentifier(buffer) {
+ if (type == null) {
+ buffer.write("null");
+ } else {
+ type.writeIdentifier(buffer);
+ }
+ buffer.write("_");
+ buffer.write(name);
+ }
+
+ void writeType(StringBuffer buffer) {
+ assert(type != null || name != null);
+ if (name == null) {
+ type.writeType(buffer);
+ } else if (type == null) {
+ buffer.write(name);
+ } else {
+ type.writeType(buffer);
+ buffer.write(" ");
+ buffer.write(name);
+ }
+ }
+
+ void writeInFunction(StringBuffer buffer) {
+ assert(type != null || name != null);
+ if (name == null) {
+ type.writeType(buffer);
+ buffer.write(" x");
+ buffer.write(parameterNameCounter++);
+ } else if (type == null) {
+ buffer.write(name);
+ } else {
+ type.writeType(buffer);
+ buffer.write(" ");
+ buffer.write(name);
+ }
+ }
+
+ bool operator ==(other) {
+ return other is Parameter && name == other.name && type == other.type;
+ }
+
+ int get hashCode {
+ return ((name.hashCode * 37) ^ type.hashCode) & 0xFFFFFFFF;
+ }
+
+ bool get usesT => type?.usesT == true;
+}
+
+class GenericParameter implements TypeLike {
+ final String name;
+ final TypeLike bound;
+
+ GenericParameter(this.name, [this.bound]);
+
+ // Bound may be null.
+ @override
+ writeIdentifier(buffer) {
+ buffer.write(name);
+ buffer.write("_");
+ if (bound == null) {
+ buffer.write("null");
+ } else {
+ bound.writeIdentifier(buffer);
+ }
+ }
+
+ @override
+ writeType(buffer) {
+ buffer.write(name);
+ if (bound != null) {
+ buffer.write(" extends ");
+ bound.writeType(buffer);
+ }
+ }
+
+ bool operator ==(other) {
+ return other is GenericParameter &&
+ name == other.name &&
+ bound == other.bound;
+ }
+
+ int get hashCode {
+ return ((name.hashCode * 23) ^ bound.hashCode) & 0xFFFFFFFF;
+ }
+
+ bool get usesT {
+ return bound?.usesT == true;
+ }
+}
+
+void _describeList(StringBuffer buffer, List<Printable> list) {
+ if (list == null) {
+ buffer.write("0");
+ return;
+ }
+ buffer.write(list.length.toString());
+ buffer.write("_");
+ for (int i = 0; i < list.length; i++) {
+ if (i != 0) buffer.write("_");
+ list[i].writeIdentifier(buffer);
+ }
+}
+
+void _writeTypes(StringBuffer buffer, List<TypeLike> list,
+ [String prefix = "", String postfix = ""]) {
+ if (list == null || list.isEmpty) return;
+ buffer.write(prefix);
+ for (int i = 0; i < list.length; i++) {
+ if (i != 0) buffer.write(", ");
+ list[i].writeType(buffer);
+ }
+ buffer.write(postfix);
+}
+
+void _writeParameters(
+ StringBuffer buffer, List<Parameter> list, bool inFunction,
+ [String prefix = "", String postfix = ""]) {
+ if (list == null || list.isEmpty) return;
+ buffer.write(prefix);
+ for (int i = 0; i < list.length; i++) {
+ if (i != 0) buffer.write(", ");
+ if (inFunction) {
+ list[i].writeInFunction(buffer);
+ } else {
+ list[i].writeType(buffer);
+ }
+ }
+ buffer.write(postfix);
+}
+
+bool _listUsesT(List elements) {
+ if (elements == null) return false;
+ return elements.any((p) => p.usesT);
+}
+
+bool _listEquals(List list1, List list2) {
+ if (list1 == list2) return true; // Also covers both being null.
+ if (list1 == null || list2 == null) return false;
+ for (int i = 0; i < list1.length; i++) {
+ if (list1[i] != list2[i]) return false;
+ }
+ return true;
+}
+
+int _listHash(List list) {
+ if (list == null) return null.hashCode;
+ int result = 71;
+ for (int i = 0; i < list.length; i++) {
+ result = ((result * 11) ^ list[i].hashCode) & 0xFFFFFFFF;
+ }
+ return result;
+}
+
+class FunctionType implements TypeLike {
+ final TypeLike returnType;
+ final List<GenericParameter> generic;
+ final List<Parameter> required;
+ final List<Parameter> optional;
+ final List<Parameter> named;
+
+ FunctionType(this.returnType, this.generic, this.required,
+ [this.optional, this.named]);
+
+ @override
+ writeIdentifier(buffer) {
+ buffer.write("Fun_");
+ if (returnType == null) {
+ buffer.write("null");
+ } else {
+ returnType.writeIdentifier(buffer);
+ }
+ buffer.write("_");
+ _describeList(buffer, generic);
+ buffer.write("_");
+ _describeList(buffer, required);
+ buffer.write("_");
+ _describeList(buffer, optional);
+ buffer.write("_");
+ _describeList(buffer, named);
+ }
+
+ @override
+ writeType(buffer) {
+ if (returnType != null) {
+ returnType.writeType(buffer);
+ buffer.write(" ");
+ }
+ buffer.write("Function");
+ if (generic != null) _writeTypes(buffer, generic, "<", ">");
+ buffer.write("(");
+ bool notInFunction = true;
+ _writeParameters(buffer, required, notInFunction);
+ if ((optional != null || named != null) &&
+ required != null &&
+ required.isNotEmpty) {
+ buffer.write(", ");
+ }
+ _writeParameters(buffer, optional, notInFunction, "[", "]");
+ _writeParameters(buffer, named, notInFunction, "{", "}");
+ buffer.write(")");
+ }
+
+ /// Writes this type as if it was a function.
+ void writeFunction(StringBuffer buffer, String name, {bool replaceT: true}) {
+ shouldReplaceTWithInt = replaceT;
+ parameterNameCounter = 0;
+
+ if (returnType != null) {
+ returnType.writeType(buffer);
+ buffer.write(" ");
+ }
+
+ buffer.write(name);
+ if (generic != null) _writeTypes(buffer, generic, "<", ">");
+ buffer.write("(");
+ bool inFunction = true;
+ _writeParameters(buffer, required, inFunction);
+ if ((optional != null || named != null) &&
+ required != null &&
+ required.isNotEmpty) {
+ buffer.write(", ");
+ }
+ _writeParameters(buffer, optional, inFunction, "[", "]");
+ _writeParameters(buffer, named, inFunction, "{", "}");
+ buffer.write(") => null;");
+
+ shouldReplaceTWithInt = false;
+ }
+
+ bool operator ==(other) {
+ return returnType == other.returnType &&
+ _listEquals(generic, other.generic) &&
+ _listEquals(required, other.required) &&
+ _listEquals(optional, other.optional) &&
+ _listEquals(named, other.named);
+ }
+
+ int get hashCode {
+ return ((returnType.hashCode * 13) ^
+ (_listHash(generic) * 17) ^
+ (_listHash(required) * 53) ^
+ (_listHash(optional) ^ 31) ^
+ (_listHash(named) * 87)) &
+ 0xFFFFFFFF;
+ }
+
+ bool get usesT {
+ return returnType?.usesT == true ||
+ [generic, required, optional, named].any(_listUsesT);
+ }
+}
+
+class NominalType implements TypeLike {
+ final String prefix;
+ final String name;
+ final List<TypeLike> generic;
+
+ NominalType(this.name, [this.prefix, this.generic]);
+
+ @override
+ writeIdentifier(buffer) {
+ buffer.write(prefix);
+ buffer.write("_");
+ buffer.write(name);
+ _describeList(buffer, generic);
+ }
+
+ @override
+ writeType(buffer) {
+ if (prefix != null && prefix != "") {
+ buffer.write(prefix);
+ buffer.write(".");
+ }
+ if (shouldReplaceTWithInt && name == "T") {
+ buffer.write("int");
+ } else {
+ buffer.write(name);
+ }
+ _writeTypes(buffer, generic, "<", ">");
+ }
+
+ bool operator ==(other) {
+ return other is NominalType && prefix == other.prefix && name == other.name;
+ }
+
+ int get hashCode {
+ return ((prefix.hashCode * 37) ^ name.hashCode) & 0xFFFFFFFF;
+ }
+
+ bool get usesT => name == "T" || _listUsesT(generic);
+}
+
+List<FunctionType> buildFunctionTypes() {
+ List<GenericParameter> as = [
+ new GenericParameter("A"),
+ // new GenericParameter("A", new NominalType("int")),
+ // new GenericParameter("A", new NominalType("int", "core")),
+ ];
+ List<GenericParameter> bs = [
+ // new GenericParameter("B"),
+ // new GenericParameter("B", new NominalType("int")),
+ new GenericParameter("B", new NominalType("int", "core")),
+ ];
+ List<TypeLike> basicTypes = [
+ new NominalType("int"),
+ // new NominalType("int", "core"),
+ // new NominalType("List"),
+ // new NominalType("List", "core"),
+ new NominalType("Function"),
+ new NominalType("List", "", [new NominalType("Function")]),
+ new NominalType("List", "core", [new NominalType("int", "core")]),
+ new NominalType("List", "", [new NominalType("T")]),
+ // new NominalType("List", "", [new NominalType("Function")]),
+ ];
+
+ List<TypeLike> basicsPlusNull = [
+ basicTypes,
+ [null]
+ ].expand((x) => x).toList();
+
+ List<TypeLike> basicsPlusNullPlusB = [
+ basicsPlusNull,
+ [
+ new NominalType("B"),
+ new NominalType("List", "", [new NominalType("B")])
+ ]
+ ].expand((x) => x).toList();
+
+ List<TypeLike> basicsPlusNullPlusA = [
+ basicsPlusNull,
+ [
+ new NominalType("A"),
+ new NominalType("List", "", [new NominalType("A")])
+ ]
+ ].expand((x) => x).toList();
+
+ List<TypeLike> buildFunctionTypes(TypeLike returnType, TypeLike parameterType,
+ [List<GenericParameter> generics,
+ bool generateMoreCombinations = false]) {
+ List<TypeLike> result = [];
+
+ if (parameterType == null) {
+ // int Function().
+ result.add(new FunctionType(returnType, generics, null));
+ return result;
+ }
+
+ // int Function(int x).
+ result.add(new FunctionType(
+ returnType, generics, [new Parameter(parameterType, "x")]));
+
+ if (!generateMoreCombinations) return result;
+
+ // int Function([int x]).
+ result.add(new FunctionType(
+ returnType, generics, null, [new Parameter(parameterType, "x")]));
+ // int Function(int, [int x])
+ result.add(new FunctionType(
+ returnType,
+ generics,
+ [new Parameter(new NominalType("int"), null)],
+ [new Parameter(parameterType, "x")]));
+ // int Function(int x, [int x])
+ result.add(new FunctionType(
+ returnType,
+ generics,
+ [new Parameter(new NominalType("int"), "y")],
+ [new Parameter(parameterType, "x")]));
+ // int Function(int);
+ result.add(new FunctionType(
+ returnType, generics, [new Parameter(parameterType, null)]));
+ // int Function([int]);
+ result.add(new FunctionType(
+ returnType, generics, null, [new Parameter(parameterType, null)]));
+ // int Function(int, [int])
+ result.add(new FunctionType(
+ returnType,
+ generics,
+ [new Parameter(new NominalType("int"), null)],
+ [new Parameter(parameterType, null)]));
+ // int Function(int x, [int])
+ result.add(new FunctionType(
+ returnType,
+ generics,
+ [new Parameter(new NominalType("int"), "x")],
+ [new Parameter(parameterType, null)]));
+ // int Function({int x}).
+ result.add(new FunctionType(returnType, generics, null, null,
+ [new Parameter(parameterType, "x")]));
+ // int Function(int, {int x})
+ result.add(new FunctionType(
+ returnType,
+ generics,
+ [new Parameter(new NominalType("int"), null)],
+ null,
+ [new Parameter(parameterType, "x")]));
+ // int Function(int x, {int x})
+ result.add(new FunctionType(
+ returnType,
+ generics,
+ [new Parameter(new NominalType("int"), "y")],
+ null,
+ [new Parameter(parameterType, "x")]));
+ return result;
+ }
+
+ // The "smaller" function types. May also be used non-nested.
+ List<TypeLike> functionTypes = [];
+
+ for (TypeLike returnType in basicsPlusNull) {
+ for (TypeLike parameterType in basicsPlusNull) {
+ bool generateMoreCombinations = true;
+ functionTypes.addAll(buildFunctionTypes(
+ returnType, parameterType, null, generateMoreCombinations));
+ }
+ }
+
+ // These use `B` from the generic type of the enclosing function.
+ List<TypeLike> returnFunctionTypesB = [];
+ for (TypeLike returnType in basicsPlusNullPlusB) {
+ TypeLike parameterType = new NominalType("B");
+ returnFunctionTypesB.addAll(buildFunctionTypes(returnType, parameterType));
+ }
+ for (TypeLike parameterType in basicsPlusNull) {
+ TypeLike returnType = new NominalType("B");
+ returnFunctionTypesB.addAll(buildFunctionTypes(returnType, parameterType));
+ }
+
+ for (TypeLike returnType in basicsPlusNullPlusA) {
+ for (TypeLike parameterType in basicsPlusNullPlusA) {
+ for (GenericParameter a in as) {
+ functionTypes
+ .addAll(buildFunctionTypes(returnType, parameterType, [a]));
+ }
+ }
+ }
+
+ List<TypeLike> types = [];
+ types.addAll(functionTypes);
+
+ // Now add some higher-order function types.
+ for (TypeLike returnType in functionTypes) {
+ types.addAll(buildFunctionTypes(returnType, null));
+ types.addAll(buildFunctionTypes(returnType, new NominalType("int")));
+ for (var b in bs) {
+ types.addAll(buildFunctionTypes(returnType, null, [b]));
+ types.addAll(buildFunctionTypes(returnType, new NominalType("int"), [b]));
+ }
+ }
+ for (TypeLike returnType in returnFunctionTypesB) {
+ for (var b in bs) {
+ types.addAll(buildFunctionTypes(returnType, null, [b]));
+ types.addAll(buildFunctionTypes(returnType, new NominalType("int"), [b]));
+ }
+ }
+
+ return types;
+}
+
+class Cls {
+ final String name;
+ final StringBuffer tests = new StringBuffer();
+ final StringBuffer fields = new StringBuffer();
+ final StringBuffer statics = new StringBuffer();
+ final StringBuffer testMethods = new StringBuffer();
+ final StringBuffer methods = new StringBuffer();
+
+ Cls(this.name);
+
+ void write(StringBuffer buffer) {
+ buffer.write("""
+class $name<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+$fields
+
+ $name({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+$methods
+
+ runTests() {\n$tests }
+
+$testMethods
+}
+ """);
+ }
+}
+
+
+final String HEADER = """
+// 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;
+
+final bool inCheckedMode =
+ (() { bool result = false; assert(result = true); return result; })();
+""";
+
+final TEST_METHOD_HEADER = """
+ void #testName() {
+ // #typeCode""";
+
+// Tests that apply for every type.
+final COMMON_TESTS_TEMPLATE = """
+ Expect.isTrue(#staticFunName is #typeName);
+ Expect.isTrue(confuse(#staticFunName) is #typeName);
+ // In checked mode, verifies the type.
+ #typeCode #localName;
+ // The static function #staticFunName sets `T` to `int`.
+ if (!tIsBool) {
+ #fieldName = #staticFunName as dynamic;
+ #localName = #staticFunName as dynamic;
+ #fieldName = confuse(#staticFunName);
+ #localName = confuse(#staticFunName);
+ }
+
+ Expect.isTrue(#methodFunName is #typeName);
+ Expect.isTrue(#methodFunName is #typeCode);
+ Expect.isTrue(confuse(#methodFunName) is #typeName);
+ // In checked mode, verifies the type.
+ #fieldName = #methodFunName;
+ #localName = #methodFunName;
+ #fieldName = confuse(#methodFunName);
+ #localName = confuse(#methodFunName);""";
+
+// Tests that depend on the typedef "T" argument.
+//
+// These tests are executed when the surrounding class is instantiated with
+// its generic type set to `int`, `dynamic` or `bool`. In the latter case, the
+// class field `tIsBool` is set to true.
+
+// While the types themselves are not affected by the class` `T`, the methods
+// of the class may use `T`:
+//
+// For example:
+// class A<T> {
+// f(List<T> x) {}
+// }
+final TYPEDEF_T_TESTS_TEMPLATE = """
+ if (!tIsBool) {
+ Expect.isTrue(#staticFunName is #typeName<int>);
+ Expect.isFalse(#staticFunName is #typeName<bool>);
+ Expect.isTrue(confuse(#staticFunName) is #typeName<int>);
+ Expect.isFalse(confuse(#staticFunName) is #typeName<bool>);
+ Expect.equals(tIsDynamic, #methodFunName is #typeName<bool>);
+ Expect.equals(tIsDynamic, confuse(#methodFunName) is #typeName<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { #fieldName = (#staticFunName as dynamic); });
+ Expect.throws(() { #fieldName = confuse(#staticFunName); });
+ #typeCode #localName;
+ Expect.throws(() { #localName = (#staticFunName as dynamic); });
+ Expect.throws(() { #localName = confuse(#staticFunName); });
+ }
+ #typeCode #localName = #methodFunName;
+ // In checked mode, verifies the type.
+ #fieldName = #methodFunName;
+ #fieldName = confuse(#methodFunName);
+ }""";
+
+final TEST_METHOD_FOOTER = " }";
+
+String createTypeName(int id) => "F$id";
+String createStaticFunName(int id) => "f$id";
+String createMethodFunName(int id) => "m$id";
+String createFieldName(int id) => "x$id";
+String createLocalName(int id) => "l$id";
+String createTestName(int id) => "test${createTypeName(id)}";
+
+String createTypeCode(FunctionType type) {
+ StringBuffer typeBuffer = new StringBuffer();
+ type.writeType(typeBuffer);
+ return typeBuffer.toString();
+}
+String createStaticFunCode(FunctionType type, int id) {
+ StringBuffer staticFunBuffer = new StringBuffer();
+ type.writeFunction(staticFunBuffer, createStaticFunName(id));
+ return staticFunBuffer.toString();
+}
+
+String createMethodFunCode(FunctionType type, int id) {
+ StringBuffer methodFunBuffer = new StringBuffer();
+ type.writeFunction(methodFunBuffer, createMethodFunName(id), replaceT: false);
+ return methodFunBuffer.toString();
+}
+
+String createTestMethodFunCode(FunctionType type, String typeCode, int id) {
+ String fillTemplate(String template, int id) {
+ var result = template
+ .replaceAll("#typeName", createTypeName(id))
+ .replaceAll("#staticFunName", createStaticFunName(id))
+ .replaceAll("#methodFunName", createMethodFunName(id))
+ .replaceAll("#fieldName", createFieldName(id))
+ .replaceAll("#localName", createLocalName(id))
+ .replaceAll("#testName", createTestName(id))
+ .replaceAll("#typeCode", typeCode);
+ assert(!result.contains("#"));
+ return result;
+ }
+
+ String commonTests = fillTemplate(COMMON_TESTS_TEMPLATE, id);
+ String genericTTests = "";
+ if (type.usesT) {
+ genericTTests = fillTemplate(TYPEDEF_T_TESTS_TEMPLATE, id);
+ }
+ return """
+${fillTemplate(TEST_METHOD_HEADER, id)}
+$commonTests
+$genericTTests
+$TEST_METHOD_FOOTER
+""";
+}
+
+void generateTests({bool typedefsOnly}) {
+ StringBuffer typedefs = new StringBuffer();
+ StringBuffer typedefOnlyTests = new StringBuffer();
+ StringBuffer statics = new StringBuffer();
+
+ // Keep methods and classes smaller by distributing over several different
+ // classes.
+ List<Cls> classes = [];
+ for (int i = 0; i < 100; i++) {
+ classes.add(new Cls("C$i"));
+ }
+
+ var types = buildFunctionTypes();
+
+ int typeCounter = 0;
+ types.forEach((FunctionType type) {
+ Cls cls = classes[typeCounter % classes.length];
+
+ String typeName = createTypeName(typeCounter);
+ String staticFunName = createStaticFunName(typeCounter);
+ String methodFunName = createMethodFunName(typeCounter);
+ String fieldName = createFieldName(typeCounter);
+ String localName = createLocalName(typeCounter);
+ String testName = createTestName(typeCounter);
+
+ String typeCode = createTypeCode(type);
+ String staticFunCode = createStaticFunCode(type, typeCounter);
+ String methodFunCode = createMethodFunCode(type, typeCounter);
+ String testMethodCode =
+ createTestMethodFunCode(type, typeCode, typeCounter);
+
+
+ typedefs.writeln("typedef $typeName<T> = $typeCode;");
+ typedefOnlyTests.writeln(" Expect.isFalse(true is $typeName);");
+ statics.writeln(staticFunCode);
+ cls.fields.writeln(" $typeCode $fieldName;");
+ cls.methods.writeln(" $methodFunCode");
+ cls.testMethods.writeln("$testMethodCode");
+ cls.tests.writeln(" $testName();");
+
+ typeCounter++;
+ });
+
+ if (typedefsOnly) {
+ print("""
+$HEADER
+
+$typedefs
+
+void runTests() {
+$typedefOnlyTests
+}
+""");
+ return;
+ }
+
+ print(HEADER);
+ print(typedefs);
+ print(statics);
+ for (var cls in classes) {
+ var buffer = new StringBuffer();
+ cls.write(buffer);
+ print(buffer.toString());
+ }
+ print("void runTests() {");
+ for (var cls in classes) {
+ print(" new ${cls.name}().runTests();");
+ print(" new ${cls.name}<int>(tIsInt: true).runTests();");
+ print(" new ${cls.name}<bool>(tIsBool: true).runTests();");
+ }
+ print("}");
+}
+
+void printUsage() {
+ print("""
+This program can be run in two modes:
+1. Generating generalized function-type tests.
+2. Running the tests imported from "generated_function_syntax_tests.dart".
+
+It is assumed that the "generated_function_syntax_tests.dart" file is the output
+of a run of this program.
+
+To generate the tests run with either
+* `--generate-typedefs`, or
+* `--generate-all`.
+
+The first generates only tests that use function-type syntax in typedefs.
+The latter generates tests for the same syntax in other locations.
+
+Normally the tests don't need to be regenerated.
+If necessary, a typical workflow would look like follows:
+
+dart generalized_function_type_test.dart --generate-all > generated_function_syntax_tests.dart
+""");
+}
+
+void main(List<String> arguments) {
+ if (arguments.length > 0) {
+ if (arguments.length != 1) {
+ printUsage();
+ return;
+ }
+ if (arguments[0] == "--generate-typedefs") {
+ generateTests(typedefsOnly: true);
+ } else if (arguments[0] == "--generate-all") {
+ generateTests(typedefsOnly: false);
+ } else {
+ printUsage();
+ return;
+ }
+ } else {
+ runTests();
+ }
+}
\ No newline at end of file
diff --git a/tests/language/generated_function_syntax_tests.dart b/tests/language/generated_function_syntax_tests.dart
new file mode 100644
index 0000000..c6059c7
--- /dev/null
+++ b/tests/language/generated_function_syntax_tests.dart
@@ -0,0 +1,75014 @@
+// 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;
+
+final bool inCheckedMode =
+ (() { bool result = false; assert(result = true); return result; })();
+
+typedef F0<T> = int Function(int x);
+typedef F1<T> = int Function([int x]);
+typedef F2<T> = int Function(int x0, [int x]);
+typedef F3<T> = int Function(int y, [int x]);
+typedef F4<T> = int Function(int x0);
+typedef F5<T> = int Function([int x1]);
+typedef F6<T> = int Function(int x1, [int x2]);
+typedef F7<T> = int Function(int x, [int x2]);
+typedef F8<T> = int Function({int x});
+typedef F9<T> = int Function(int x0, {int x});
+typedef F10<T> = int Function(int y, {int x});
+typedef F11<T> = int Function(Function x);
+typedef F12<T> = int Function([Function x]);
+typedef F13<T> = int Function(int x0, [Function x]);
+typedef F14<T> = int Function(int y, [Function x]);
+typedef F15<T> = int Function(Function x0);
+typedef F16<T> = int Function([Function x1]);
+typedef F17<T> = int Function(int x1, [Function x2]);
+typedef F18<T> = int Function(int x, [Function x2]);
+typedef F19<T> = int Function({Function x});
+typedef F20<T> = int Function(int x0, {Function x});
+typedef F21<T> = int Function(int y, {Function x});
+typedef F22<T> = int Function(List<Function> x);
+typedef F23<T> = int Function([List<Function> x]);
+typedef F24<T> = int Function(int x0, [List<Function> x]);
+typedef F25<T> = int Function(int y, [List<Function> x]);
+typedef F26<T> = int Function(List<Function> x0);
+typedef F27<T> = int Function([List<Function> x1]);
+typedef F28<T> = int Function(int x1, [List<Function> x2]);
+typedef F29<T> = int Function(int x, [List<Function> x2]);
+typedef F30<T> = int Function({List<Function> x});
+typedef F31<T> = int Function(int x0, {List<Function> x});
+typedef F32<T> = int Function(int y, {List<Function> x});
+typedef F33<T> = int Function(core.List<core.int> x);
+typedef F34<T> = int Function([core.List<core.int> x]);
+typedef F35<T> = int Function(int x0, [core.List<core.int> x]);
+typedef F36<T> = int Function(int y, [core.List<core.int> x]);
+typedef F37<T> = int Function(core.List<core.int> x0);
+typedef F38<T> = int Function([core.List<core.int> x1]);
+typedef F39<T> = int Function(int x1, [core.List<core.int> x2]);
+typedef F40<T> = int Function(int x, [core.List<core.int> x2]);
+typedef F41<T> = int Function({core.List<core.int> x});
+typedef F42<T> = int Function(int x0, {core.List<core.int> x});
+typedef F43<T> = int Function(int y, {core.List<core.int> x});
+typedef F44<T> = int Function(List<T> x);
+typedef F45<T> = int Function([List<T> x]);
+typedef F46<T> = int Function(int x0, [List<T> x]);
+typedef F47<T> = int Function(int y, [List<T> x]);
+typedef F48<T> = int Function(List<T> x0);
+typedef F49<T> = int Function([List<T> x1]);
+typedef F50<T> = int Function(int x1, [List<T> x2]);
+typedef F51<T> = int Function(int x, [List<T> x2]);
+typedef F52<T> = int Function({List<T> x});
+typedef F53<T> = int Function(int x0, {List<T> x});
+typedef F54<T> = int Function(int y, {List<T> x});
+typedef F55<T> = int Function();
+typedef F56<T> = Function Function(int x);
+typedef F57<T> = Function Function([int x]);
+typedef F58<T> = Function Function(int x0, [int x]);
+typedef F59<T> = Function Function(int y, [int x]);
+typedef F60<T> = Function Function(int x0);
+typedef F61<T> = Function Function([int x1]);
+typedef F62<T> = Function Function(int x1, [int x2]);
+typedef F63<T> = Function Function(int x, [int x2]);
+typedef F64<T> = Function Function({int x});
+typedef F65<T> = Function Function(int x0, {int x});
+typedef F66<T> = Function Function(int y, {int x});
+typedef F67<T> = Function Function(Function x);
+typedef F68<T> = Function Function([Function x]);
+typedef F69<T> = Function Function(int x0, [Function x]);
+typedef F70<T> = Function Function(int y, [Function x]);
+typedef F71<T> = Function Function(Function x0);
+typedef F72<T> = Function Function([Function x1]);
+typedef F73<T> = Function Function(int x1, [Function x2]);
+typedef F74<T> = Function Function(int x, [Function x2]);
+typedef F75<T> = Function Function({Function x});
+typedef F76<T> = Function Function(int x0, {Function x});
+typedef F77<T> = Function Function(int y, {Function x});
+typedef F78<T> = Function Function(List<Function> x);
+typedef F79<T> = Function Function([List<Function> x]);
+typedef F80<T> = Function Function(int x0, [List<Function> x]);
+typedef F81<T> = Function Function(int y, [List<Function> x]);
+typedef F82<T> = Function Function(List<Function> x0);
+typedef F83<T> = Function Function([List<Function> x1]);
+typedef F84<T> = Function Function(int x1, [List<Function> x2]);
+typedef F85<T> = Function Function(int x, [List<Function> x2]);
+typedef F86<T> = Function Function({List<Function> x});
+typedef F87<T> = Function Function(int x0, {List<Function> x});
+typedef F88<T> = Function Function(int y, {List<Function> x});
+typedef F89<T> = Function Function(core.List<core.int> x);
+typedef F90<T> = Function Function([core.List<core.int> x]);
+typedef F91<T> = Function Function(int x0, [core.List<core.int> x]);
+typedef F92<T> = Function Function(int y, [core.List<core.int> x]);
+typedef F93<T> = Function Function(core.List<core.int> x0);
+typedef F94<T> = Function Function([core.List<core.int> x1]);
+typedef F95<T> = Function Function(int x1, [core.List<core.int> x2]);
+typedef F96<T> = Function Function(int x, [core.List<core.int> x2]);
+typedef F97<T> = Function Function({core.List<core.int> x});
+typedef F98<T> = Function Function(int x0, {core.List<core.int> x});
+typedef F99<T> = Function Function(int y, {core.List<core.int> x});
+typedef F100<T> = Function Function(List<T> x);
+typedef F101<T> = Function Function([List<T> x]);
+typedef F102<T> = Function Function(int x0, [List<T> x]);
+typedef F103<T> = Function Function(int y, [List<T> x]);
+typedef F104<T> = Function Function(List<T> x0);
+typedef F105<T> = Function Function([List<T> x1]);
+typedef F106<T> = Function Function(int x1, [List<T> x2]);
+typedef F107<T> = Function Function(int x, [List<T> x2]);
+typedef F108<T> = Function Function({List<T> x});
+typedef F109<T> = Function Function(int x0, {List<T> x});
+typedef F110<T> = Function Function(int y, {List<T> x});
+typedef F111<T> = Function Function();
+typedef F112<T> = List<Function> Function(int x);
+typedef F113<T> = List<Function> Function([int x]);
+typedef F114<T> = List<Function> Function(int x0, [int x]);
+typedef F115<T> = List<Function> Function(int y, [int x]);
+typedef F116<T> = List<Function> Function(int x0);
+typedef F117<T> = List<Function> Function([int x1]);
+typedef F118<T> = List<Function> Function(int x1, [int x2]);
+typedef F119<T> = List<Function> Function(int x, [int x2]);
+typedef F120<T> = List<Function> Function({int x});
+typedef F121<T> = List<Function> Function(int x0, {int x});
+typedef F122<T> = List<Function> Function(int y, {int x});
+typedef F123<T> = List<Function> Function(Function x);
+typedef F124<T> = List<Function> Function([Function x]);
+typedef F125<T> = List<Function> Function(int x0, [Function x]);
+typedef F126<T> = List<Function> Function(int y, [Function x]);
+typedef F127<T> = List<Function> Function(Function x0);
+typedef F128<T> = List<Function> Function([Function x1]);
+typedef F129<T> = List<Function> Function(int x1, [Function x2]);
+typedef F130<T> = List<Function> Function(int x, [Function x2]);
+typedef F131<T> = List<Function> Function({Function x});
+typedef F132<T> = List<Function> Function(int x0, {Function x});
+typedef F133<T> = List<Function> Function(int y, {Function x});
+typedef F134<T> = List<Function> Function(List<Function> x);
+typedef F135<T> = List<Function> Function([List<Function> x]);
+typedef F136<T> = List<Function> Function(int x0, [List<Function> x]);
+typedef F137<T> = List<Function> Function(int y, [List<Function> x]);
+typedef F138<T> = List<Function> Function(List<Function> x0);
+typedef F139<T> = List<Function> Function([List<Function> x1]);
+typedef F140<T> = List<Function> Function(int x1, [List<Function> x2]);
+typedef F141<T> = List<Function> Function(int x, [List<Function> x2]);
+typedef F142<T> = List<Function> Function({List<Function> x});
+typedef F143<T> = List<Function> Function(int x0, {List<Function> x});
+typedef F144<T> = List<Function> Function(int y, {List<Function> x});
+typedef F145<T> = List<Function> Function(core.List<core.int> x);
+typedef F146<T> = List<Function> Function([core.List<core.int> x]);
+typedef F147<T> = List<Function> Function(int x0, [core.List<core.int> x]);
+typedef F148<T> = List<Function> Function(int y, [core.List<core.int> x]);
+typedef F149<T> = List<Function> Function(core.List<core.int> x0);
+typedef F150<T> = List<Function> Function([core.List<core.int> x1]);
+typedef F151<T> = List<Function> Function(int x1, [core.List<core.int> x2]);
+typedef F152<T> = List<Function> Function(int x, [core.List<core.int> x2]);
+typedef F153<T> = List<Function> Function({core.List<core.int> x});
+typedef F154<T> = List<Function> Function(int x0, {core.List<core.int> x});
+typedef F155<T> = List<Function> Function(int y, {core.List<core.int> x});
+typedef F156<T> = List<Function> Function(List<T> x);
+typedef F157<T> = List<Function> Function([List<T> x]);
+typedef F158<T> = List<Function> Function(int x0, [List<T> x]);
+typedef F159<T> = List<Function> Function(int y, [List<T> x]);
+typedef F160<T> = List<Function> Function(List<T> x0);
+typedef F161<T> = List<Function> Function([List<T> x1]);
+typedef F162<T> = List<Function> Function(int x1, [List<T> x2]);
+typedef F163<T> = List<Function> Function(int x, [List<T> x2]);
+typedef F164<T> = List<Function> Function({List<T> x});
+typedef F165<T> = List<Function> Function(int x0, {List<T> x});
+typedef F166<T> = List<Function> Function(int y, {List<T> x});
+typedef F167<T> = List<Function> Function();
+typedef F168<T> = core.List<core.int> Function(int x);
+typedef F169<T> = core.List<core.int> Function([int x]);
+typedef F170<T> = core.List<core.int> Function(int x0, [int x]);
+typedef F171<T> = core.List<core.int> Function(int y, [int x]);
+typedef F172<T> = core.List<core.int> Function(int x0);
+typedef F173<T> = core.List<core.int> Function([int x1]);
+typedef F174<T> = core.List<core.int> Function(int x1, [int x2]);
+typedef F175<T> = core.List<core.int> Function(int x, [int x2]);
+typedef F176<T> = core.List<core.int> Function({int x});
+typedef F177<T> = core.List<core.int> Function(int x0, {int x});
+typedef F178<T> = core.List<core.int> Function(int y, {int x});
+typedef F179<T> = core.List<core.int> Function(Function x);
+typedef F180<T> = core.List<core.int> Function([Function x]);
+typedef F181<T> = core.List<core.int> Function(int x0, [Function x]);
+typedef F182<T> = core.List<core.int> Function(int y, [Function x]);
+typedef F183<T> = core.List<core.int> Function(Function x0);
+typedef F184<T> = core.List<core.int> Function([Function x1]);
+typedef F185<T> = core.List<core.int> Function(int x1, [Function x2]);
+typedef F186<T> = core.List<core.int> Function(int x, [Function x2]);
+typedef F187<T> = core.List<core.int> Function({Function x});
+typedef F188<T> = core.List<core.int> Function(int x0, {Function x});
+typedef F189<T> = core.List<core.int> Function(int y, {Function x});
+typedef F190<T> = core.List<core.int> Function(List<Function> x);
+typedef F191<T> = core.List<core.int> Function([List<Function> x]);
+typedef F192<T> = core.List<core.int> Function(int x0, [List<Function> x]);
+typedef F193<T> = core.List<core.int> Function(int y, [List<Function> x]);
+typedef F194<T> = core.List<core.int> Function(List<Function> x0);
+typedef F195<T> = core.List<core.int> Function([List<Function> x1]);
+typedef F196<T> = core.List<core.int> Function(int x1, [List<Function> x2]);
+typedef F197<T> = core.List<core.int> Function(int x, [List<Function> x2]);
+typedef F198<T> = core.List<core.int> Function({List<Function> x});
+typedef F199<T> = core.List<core.int> Function(int x0, {List<Function> x});
+typedef F200<T> = core.List<core.int> Function(int y, {List<Function> x});
+typedef F201<T> = core.List<core.int> Function(core.List<core.int> x);
+typedef F202<T> = core.List<core.int> Function([core.List<core.int> x]);
+typedef F203<T> = core.List<core.int> Function(int x0, [core.List<core.int> x]);
+typedef F204<T> = core.List<core.int> Function(int y, [core.List<core.int> x]);
+typedef F205<T> = core.List<core.int> Function(core.List<core.int> x0);
+typedef F206<T> = core.List<core.int> Function([core.List<core.int> x1]);
+typedef F207<T> = core.List<core.int> Function(int x1, [core.List<core.int> x2]);
+typedef F208<T> = core.List<core.int> Function(int x, [core.List<core.int> x2]);
+typedef F209<T> = core.List<core.int> Function({core.List<core.int> x});
+typedef F210<T> = core.List<core.int> Function(int x0, {core.List<core.int> x});
+typedef F211<T> = core.List<core.int> Function(int y, {core.List<core.int> x});
+typedef F212<T> = core.List<core.int> Function(List<T> x);
+typedef F213<T> = core.List<core.int> Function([List<T> x]);
+typedef F214<T> = core.List<core.int> Function(int x0, [List<T> x]);
+typedef F215<T> = core.List<core.int> Function(int y, [List<T> x]);
+typedef F216<T> = core.List<core.int> Function(List<T> x0);
+typedef F217<T> = core.List<core.int> Function([List<T> x1]);
+typedef F218<T> = core.List<core.int> Function(int x1, [List<T> x2]);
+typedef F219<T> = core.List<core.int> Function(int x, [List<T> x2]);
+typedef F220<T> = core.List<core.int> Function({List<T> x});
+typedef F221<T> = core.List<core.int> Function(int x0, {List<T> x});
+typedef F222<T> = core.List<core.int> Function(int y, {List<T> x});
+typedef F223<T> = core.List<core.int> Function();
+typedef F224<T> = List<T> Function(int x);
+typedef F225<T> = List<T> Function([int x]);
+typedef F226<T> = List<T> Function(int x0, [int x]);
+typedef F227<T> = List<T> Function(int y, [int x]);
+typedef F228<T> = List<T> Function(int x0);
+typedef F229<T> = List<T> Function([int x1]);
+typedef F230<T> = List<T> Function(int x1, [int x2]);
+typedef F231<T> = List<T> Function(int x, [int x2]);
+typedef F232<T> = List<T> Function({int x});
+typedef F233<T> = List<T> Function(int x0, {int x});
+typedef F234<T> = List<T> Function(int y, {int x});
+typedef F235<T> = List<T> Function(Function x);
+typedef F236<T> = List<T> Function([Function x]);
+typedef F237<T> = List<T> Function(int x0, [Function x]);
+typedef F238<T> = List<T> Function(int y, [Function x]);
+typedef F239<T> = List<T> Function(Function x0);
+typedef F240<T> = List<T> Function([Function x1]);
+typedef F241<T> = List<T> Function(int x1, [Function x2]);
+typedef F242<T> = List<T> Function(int x, [Function x2]);
+typedef F243<T> = List<T> Function({Function x});
+typedef F244<T> = List<T> Function(int x0, {Function x});
+typedef F245<T> = List<T> Function(int y, {Function x});
+typedef F246<T> = List<T> Function(List<Function> x);
+typedef F247<T> = List<T> Function([List<Function> x]);
+typedef F248<T> = List<T> Function(int x0, [List<Function> x]);
+typedef F249<T> = List<T> Function(int y, [List<Function> x]);
+typedef F250<T> = List<T> Function(List<Function> x0);
+typedef F251<T> = List<T> Function([List<Function> x1]);
+typedef F252<T> = List<T> Function(int x1, [List<Function> x2]);
+typedef F253<T> = List<T> Function(int x, [List<Function> x2]);
+typedef F254<T> = List<T> Function({List<Function> x});
+typedef F255<T> = List<T> Function(int x0, {List<Function> x});
+typedef F256<T> = List<T> Function(int y, {List<Function> x});
+typedef F257<T> = List<T> Function(core.List<core.int> x);
+typedef F258<T> = List<T> Function([core.List<core.int> x]);
+typedef F259<T> = List<T> Function(int x0, [core.List<core.int> x]);
+typedef F260<T> = List<T> Function(int y, [core.List<core.int> x]);
+typedef F261<T> = List<T> Function(core.List<core.int> x0);
+typedef F262<T> = List<T> Function([core.List<core.int> x1]);
+typedef F263<T> = List<T> Function(int x1, [core.List<core.int> x2]);
+typedef F264<T> = List<T> Function(int x, [core.List<core.int> x2]);
+typedef F265<T> = List<T> Function({core.List<core.int> x});
+typedef F266<T> = List<T> Function(int x0, {core.List<core.int> x});
+typedef F267<T> = List<T> Function(int y, {core.List<core.int> x});
+typedef F268<T> = List<T> Function(List<T> x);
+typedef F269<T> = List<T> Function([List<T> x]);
+typedef F270<T> = List<T> Function(int x0, [List<T> x]);
+typedef F271<T> = List<T> Function(int y, [List<T> x]);
+typedef F272<T> = List<T> Function(List<T> x0);
+typedef F273<T> = List<T> Function([List<T> x1]);
+typedef F274<T> = List<T> Function(int x1, [List<T> x2]);
+typedef F275<T> = List<T> Function(int x, [List<T> x2]);
+typedef F276<T> = List<T> Function({List<T> x});
+typedef F277<T> = List<T> Function(int x0, {List<T> x});
+typedef F278<T> = List<T> Function(int y, {List<T> x});
+typedef F279<T> = List<T> Function();
+typedef F280<T> = Function(int x);
+typedef F281<T> = Function([int x]);
+typedef F282<T> = Function(int x0, [int x]);
+typedef F283<T> = Function(int y, [int x]);
+typedef F284<T> = Function(int x0);
+typedef F285<T> = Function([int x1]);
+typedef F286<T> = Function(int x1, [int x2]);
+typedef F287<T> = Function(int x, [int x2]);
+typedef F288<T> = Function({int x});
+typedef F289<T> = Function(int x0, {int x});
+typedef F290<T> = Function(int y, {int x});
+typedef F291<T> = Function(Function x);
+typedef F292<T> = Function([Function x]);
+typedef F293<T> = Function(int x0, [Function x]);
+typedef F294<T> = Function(int y, [Function x]);
+typedef F295<T> = Function(Function x0);
+typedef F296<T> = Function([Function x1]);
+typedef F297<T> = Function(int x1, [Function x2]);
+typedef F298<T> = Function(int x, [Function x2]);
+typedef F299<T> = Function({Function x});
+typedef F300<T> = Function(int x0, {Function x});
+typedef F301<T> = Function(int y, {Function x});
+typedef F302<T> = Function(List<Function> x);
+typedef F303<T> = Function([List<Function> x]);
+typedef F304<T> = Function(int x0, [List<Function> x]);
+typedef F305<T> = Function(int y, [List<Function> x]);
+typedef F306<T> = Function(List<Function> x0);
+typedef F307<T> = Function([List<Function> x1]);
+typedef F308<T> = Function(int x1, [List<Function> x2]);
+typedef F309<T> = Function(int x, [List<Function> x2]);
+typedef F310<T> = Function({List<Function> x});
+typedef F311<T> = Function(int x0, {List<Function> x});
+typedef F312<T> = Function(int y, {List<Function> x});
+typedef F313<T> = Function(core.List<core.int> x);
+typedef F314<T> = Function([core.List<core.int> x]);
+typedef F315<T> = Function(int x0, [core.List<core.int> x]);
+typedef F316<T> = Function(int y, [core.List<core.int> x]);
+typedef F317<T> = Function(core.List<core.int> x0);
+typedef F318<T> = Function([core.List<core.int> x1]);
+typedef F319<T> = Function(int x1, [core.List<core.int> x2]);
+typedef F320<T> = Function(int x, [core.List<core.int> x2]);
+typedef F321<T> = Function({core.List<core.int> x});
+typedef F322<T> = Function(int x0, {core.List<core.int> x});
+typedef F323<T> = Function(int y, {core.List<core.int> x});
+typedef F324<T> = Function(List<T> x);
+typedef F325<T> = Function([List<T> x]);
+typedef F326<T> = Function(int x0, [List<T> x]);
+typedef F327<T> = Function(int y, [List<T> x]);
+typedef F328<T> = Function(List<T> x0);
+typedef F329<T> = Function([List<T> x1]);
+typedef F330<T> = Function(int x1, [List<T> x2]);
+typedef F331<T> = Function(int x, [List<T> x2]);
+typedef F332<T> = Function({List<T> x});
+typedef F333<T> = Function(int x0, {List<T> x});
+typedef F334<T> = Function(int y, {List<T> x});
+typedef F335<T> = Function();
+typedef F336<T> = int Function<A>(int x);
+typedef F337<T> = int Function<A>(Function x);
+typedef F338<T> = int Function<A>(List<Function> x);
+typedef F339<T> = int Function<A>(core.List<core.int> x);
+typedef F340<T> = int Function<A>(List<T> x);
+typedef F341<T> = int Function<A>();
+typedef F342<T> = int Function<A>(A x);
+typedef F343<T> = int Function<A>(List<A> x);
+typedef F344<T> = Function Function<A>(int x);
+typedef F345<T> = Function Function<A>(Function x);
+typedef F346<T> = Function Function<A>(List<Function> x);
+typedef F347<T> = Function Function<A>(core.List<core.int> x);
+typedef F348<T> = Function Function<A>(List<T> x);
+typedef F349<T> = Function Function<A>();
+typedef F350<T> = Function Function<A>(A x);
+typedef F351<T> = Function Function<A>(List<A> x);
+typedef F352<T> = List<Function> Function<A>(int x);
+typedef F353<T> = List<Function> Function<A>(Function x);
+typedef F354<T> = List<Function> Function<A>(List<Function> x);
+typedef F355<T> = List<Function> Function<A>(core.List<core.int> x);
+typedef F356<T> = List<Function> Function<A>(List<T> x);
+typedef F357<T> = List<Function> Function<A>();
+typedef F358<T> = List<Function> Function<A>(A x);
+typedef F359<T> = List<Function> Function<A>(List<A> x);
+typedef F360<T> = core.List<core.int> Function<A>(int x);
+typedef F361<T> = core.List<core.int> Function<A>(Function x);
+typedef F362<T> = core.List<core.int> Function<A>(List<Function> x);
+typedef F363<T> = core.List<core.int> Function<A>(core.List<core.int> x);
+typedef F364<T> = core.List<core.int> Function<A>(List<T> x);
+typedef F365<T> = core.List<core.int> Function<A>();
+typedef F366<T> = core.List<core.int> Function<A>(A x);
+typedef F367<T> = core.List<core.int> Function<A>(List<A> x);
+typedef F368<T> = List<T> Function<A>(int x);
+typedef F369<T> = List<T> Function<A>(Function x);
+typedef F370<T> = List<T> Function<A>(List<Function> x);
+typedef F371<T> = List<T> Function<A>(core.List<core.int> x);
+typedef F372<T> = List<T> Function<A>(List<T> x);
+typedef F373<T> = List<T> Function<A>();
+typedef F374<T> = List<T> Function<A>(A x);
+typedef F375<T> = List<T> Function<A>(List<A> x);
+typedef F376<T> = Function<A>(int x);
+typedef F377<T> = Function<A>(Function x);
+typedef F378<T> = Function<A>(List<Function> x);
+typedef F379<T> = Function<A>(core.List<core.int> x);
+typedef F380<T> = Function<A>(List<T> x);
+typedef F381<T> = Function<A>();
+typedef F382<T> = Function<A>(A x);
+typedef F383<T> = Function<A>(List<A> x);
+typedef F384<T> = A Function<A>(int x);
+typedef F385<T> = A Function<A>(Function x);
+typedef F386<T> = A Function<A>(List<Function> x);
+typedef F387<T> = A Function<A>(core.List<core.int> x);
+typedef F388<T> = A Function<A>(List<T> x);
+typedef F389<T> = A Function<A>();
+typedef F390<T> = A Function<A>(A x);
+typedef F391<T> = A Function<A>(List<A> x);
+typedef F392<T> = List<A> Function<A>(int x);
+typedef F393<T> = List<A> Function<A>(Function x);
+typedef F394<T> = List<A> Function<A>(List<Function> x);
+typedef F395<T> = List<A> Function<A>(core.List<core.int> x);
+typedef F396<T> = List<A> Function<A>(List<T> x);
+typedef F397<T> = List<A> Function<A>();
+typedef F398<T> = List<A> Function<A>(A x);
+typedef F399<T> = List<A> Function<A>(List<A> x);
+typedef F400<T> = int Function(int x) Function();
+typedef F401<T> = int Function(int x) Function(int x);
+typedef F402<T> = int Function(int x) Function<B extends core.int>();
+typedef F403<T> = int Function(int x) Function<B extends core.int>(int x);
+typedef F404<T> = int Function([int x]) Function();
+typedef F405<T> = int Function([int x]) Function(int x);
+typedef F406<T> = int Function([int x]) Function<B extends core.int>();
+typedef F407<T> = int Function([int x]) Function<B extends core.int>(int x);
+typedef F408<T> = int Function(int x0, [int x]) Function();
+typedef F409<T> = int Function(int x1, [int x]) Function(int x);
+typedef F410<T> = int Function(int x1, [int x]) Function<B extends core.int>();
+typedef F411<T> = int Function(int x1, [int x]) Function<B extends core.int>(int x);
+typedef F412<T> = int Function(int y, [int x]) Function();
+typedef F413<T> = int Function(int y, [int x]) Function(int x);
+typedef F414<T> = int Function(int y, [int x]) Function<B extends core.int>();
+typedef F415<T> = int Function(int y, [int x]) Function<B extends core.int>(int x);
+typedef F416<T> = int Function(int x0) Function();
+typedef F417<T> = int Function(int x1) Function(int x);
+typedef F418<T> = int Function(int x1) Function<B extends core.int>();
+typedef F419<T> = int Function(int x1) Function<B extends core.int>(int x);
+typedef F420<T> = int Function([int x1]) Function();
+typedef F421<T> = int Function([int x1]) Function(int x);
+typedef F422<T> = int Function([int x1]) Function<B extends core.int>();
+typedef F423<T> = int Function([int x1]) Function<B extends core.int>(int x);
+typedef F424<T> = int Function(int x1, [int x2]) Function();
+typedef F425<T> = int Function(int x2, [int x3]) Function(int x);
+typedef F426<T> = int Function(int x2, [int x3]) Function<B extends core.int>();
+typedef F427<T> = int Function(int x2, [int x3]) Function<B extends core.int>(int x);
+typedef F428<T> = int Function(int x, [int x2]) Function();
+typedef F429<T> = int Function(int x, [int x1]) Function(int x);
+typedef F430<T> = int Function(int x, [int x1]) Function<B extends core.int>();
+typedef F431<T> = int Function(int x, [int x1]) Function<B extends core.int>(int x);
+typedef F432<T> = int Function({int x}) Function();
+typedef F433<T> = int Function({int x}) Function(int x);
+typedef F434<T> = int Function({int x}) Function<B extends core.int>();
+typedef F435<T> = int Function({int x}) Function<B extends core.int>(int x);
+typedef F436<T> = int Function(int x0, {int x}) Function();
+typedef F437<T> = int Function(int x1, {int x}) Function(int x);
+typedef F438<T> = int Function(int x1, {int x}) Function<B extends core.int>();
+typedef F439<T> = int Function(int x1, {int x}) Function<B extends core.int>(int x);
+typedef F440<T> = int Function(int y, {int x}) Function();
+typedef F441<T> = int Function(int y, {int x}) Function(int x);
+typedef F442<T> = int Function(int y, {int x}) Function<B extends core.int>();
+typedef F443<T> = int Function(int y, {int x}) Function<B extends core.int>(int x);
+typedef F444<T> = int Function(Function x) Function();
+typedef F445<T> = int Function(Function x) Function(int x);
+typedef F446<T> = int Function(Function x) Function<B extends core.int>();
+typedef F447<T> = int Function(Function x) Function<B extends core.int>(int x);
+typedef F448<T> = int Function([Function x]) Function();
+typedef F449<T> = int Function([Function x]) Function(int x);
+typedef F450<T> = int Function([Function x]) Function<B extends core.int>();
+typedef F451<T> = int Function([Function x]) Function<B extends core.int>(int x);
+typedef F452<T> = int Function(int x0, [Function x]) Function();
+typedef F453<T> = int Function(int x1, [Function x]) Function(int x);
+typedef F454<T> = int Function(int x1, [Function x]) Function<B extends core.int>();
+typedef F455<T> = int Function(int x1, [Function x]) Function<B extends core.int>(int x);
+typedef F456<T> = int Function(int y, [Function x]) Function();
+typedef F457<T> = int Function(int y, [Function x]) Function(int x);
+typedef F458<T> = int Function(int y, [Function x]) Function<B extends core.int>();
+typedef F459<T> = int Function(int y, [Function x]) Function<B extends core.int>(int x);
+typedef F460<T> = int Function(Function x0) Function();
+typedef F461<T> = int Function(Function x1) Function(int x);
+typedef F462<T> = int Function(Function x1) Function<B extends core.int>();
+typedef F463<T> = int Function(Function x1) Function<B extends core.int>(int x);
+typedef F464<T> = int Function([Function x1]) Function();
+typedef F465<T> = int Function([Function x1]) Function(int x);
+typedef F466<T> = int Function([Function x1]) Function<B extends core.int>();
+typedef F467<T> = int Function([Function x1]) Function<B extends core.int>(int x);
+typedef F468<T> = int Function(int x1, [Function x2]) Function();
+typedef F469<T> = int Function(int x2, [Function x3]) Function(int x);
+typedef F470<T> = int Function(int x2, [Function x3]) Function<B extends core.int>();
+typedef F471<T> = int Function(int x2, [Function x3]) Function<B extends core.int>(int x);
+typedef F472<T> = int Function(int x, [Function x2]) Function();
+typedef F473<T> = int Function(int x, [Function x1]) Function(int x);
+typedef F474<T> = int Function(int x, [Function x1]) Function<B extends core.int>();
+typedef F475<T> = int Function(int x, [Function x1]) Function<B extends core.int>(int x);
+typedef F476<T> = int Function({Function x}) Function();
+typedef F477<T> = int Function({Function x}) Function(int x);
+typedef F478<T> = int Function({Function x}) Function<B extends core.int>();
+typedef F479<T> = int Function({Function x}) Function<B extends core.int>(int x);
+typedef F480<T> = int Function(int x0, {Function x}) Function();
+typedef F481<T> = int Function(int x1, {Function x}) Function(int x);
+typedef F482<T> = int Function(int x1, {Function x}) Function<B extends core.int>();
+typedef F483<T> = int Function(int x1, {Function x}) Function<B extends core.int>(int x);
+typedef F484<T> = int Function(int y, {Function x}) Function();
+typedef F485<T> = int Function(int y, {Function x}) Function(int x);
+typedef F486<T> = int Function(int y, {Function x}) Function<B extends core.int>();
+typedef F487<T> = int Function(int y, {Function x}) Function<B extends core.int>(int x);
+typedef F488<T> = int Function(List<Function> x) Function();
+typedef F489<T> = int Function(List<Function> x) Function(int x);
+typedef F490<T> = int Function(List<Function> x) Function<B extends core.int>();
+typedef F491<T> = int Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F492<T> = int Function([List<Function> x]) Function();
+typedef F493<T> = int Function([List<Function> x]) Function(int x);
+typedef F494<T> = int Function([List<Function> x]) Function<B extends core.int>();
+typedef F495<T> = int Function([List<Function> x]) Function<B extends core.int>(int x);
+typedef F496<T> = int Function(int x0, [List<Function> x]) Function();
+typedef F497<T> = int Function(int x1, [List<Function> x]) Function(int x);
+typedef F498<T> = int Function(int x1, [List<Function> x]) Function<B extends core.int>();
+typedef F499<T> = int Function(int x1, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F500<T> = int Function(int y, [List<Function> x]) Function();
+typedef F501<T> = int Function(int y, [List<Function> x]) Function(int x);
+typedef F502<T> = int Function(int y, [List<Function> x]) Function<B extends core.int>();
+typedef F503<T> = int Function(int y, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F504<T> = int Function(List<Function> x0) Function();
+typedef F505<T> = int Function(List<Function> x1) Function(int x);
+typedef F506<T> = int Function(List<Function> x1) Function<B extends core.int>();
+typedef F507<T> = int Function(List<Function> x1) Function<B extends core.int>(int x);
+typedef F508<T> = int Function([List<Function> x1]) Function();
+typedef F509<T> = int Function([List<Function> x1]) Function(int x);
+typedef F510<T> = int Function([List<Function> x1]) Function<B extends core.int>();
+typedef F511<T> = int Function([List<Function> x1]) Function<B extends core.int>(int x);
+typedef F512<T> = int Function(int x1, [List<Function> x2]) Function();
+typedef F513<T> = int Function(int x2, [List<Function> x3]) Function(int x);
+typedef F514<T> = int Function(int x2, [List<Function> x3]) Function<B extends core.int>();
+typedef F515<T> = int Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x);
+typedef F516<T> = int Function(int x, [List<Function> x2]) Function();
+typedef F517<T> = int Function(int x, [List<Function> x1]) Function(int x);
+typedef F518<T> = int Function(int x, [List<Function> x1]) Function<B extends core.int>();
+typedef F519<T> = int Function(int x, [List<Function> x1]) Function<B extends core.int>(int x);
+typedef F520<T> = int Function({List<Function> x}) Function();
+typedef F521<T> = int Function({List<Function> x}) Function(int x);
+typedef F522<T> = int Function({List<Function> x}) Function<B extends core.int>();
+typedef F523<T> = int Function({List<Function> x}) Function<B extends core.int>(int x);
+typedef F524<T> = int Function(int x0, {List<Function> x}) Function();
+typedef F525<T> = int Function(int x1, {List<Function> x}) Function(int x);
+typedef F526<T> = int Function(int x1, {List<Function> x}) Function<B extends core.int>();
+typedef F527<T> = int Function(int x1, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F528<T> = int Function(int y, {List<Function> x}) Function();
+typedef F529<T> = int Function(int y, {List<Function> x}) Function(int x);
+typedef F530<T> = int Function(int y, {List<Function> x}) Function<B extends core.int>();
+typedef F531<T> = int Function(int y, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F532<T> = int Function(core.List<core.int> x) Function();
+typedef F533<T> = int Function(core.List<core.int> x) Function(int x);
+typedef F534<T> = int Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F535<T> = int Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F536<T> = int Function([core.List<core.int> x]) Function();
+typedef F537<T> = int Function([core.List<core.int> x]) Function(int x);
+typedef F538<T> = int Function([core.List<core.int> x]) Function<B extends core.int>();
+typedef F539<T> = int Function([core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F540<T> = int Function(int x0, [core.List<core.int> x]) Function();
+typedef F541<T> = int Function(int x1, [core.List<core.int> x]) Function(int x);
+typedef F542<T> = int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F543<T> = int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F544<T> = int Function(int y, [core.List<core.int> x]) Function();
+typedef F545<T> = int Function(int y, [core.List<core.int> x]) Function(int x);
+typedef F546<T> = int Function(int y, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F547<T> = int Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F548<T> = int Function(core.List<core.int> x0) Function();
+typedef F549<T> = int Function(core.List<core.int> x1) Function(int x);
+typedef F550<T> = int Function(core.List<core.int> x1) Function<B extends core.int>();
+typedef F551<T> = int Function(core.List<core.int> x1) Function<B extends core.int>(int x);
+typedef F552<T> = int Function([core.List<core.int> x1]) Function();
+typedef F553<T> = int Function([core.List<core.int> x1]) Function(int x);
+typedef F554<T> = int Function([core.List<core.int> x1]) Function<B extends core.int>();
+typedef F555<T> = int Function([core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F556<T> = int Function(int x1, [core.List<core.int> x2]) Function();
+typedef F557<T> = int Function(int x2, [core.List<core.int> x3]) Function(int x);
+typedef F558<T> = int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>();
+typedef F559<T> = int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x);
+typedef F560<T> = int Function(int x, [core.List<core.int> x2]) Function();
+typedef F561<T> = int Function(int x, [core.List<core.int> x1]) Function(int x);
+typedef F562<T> = int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>();
+typedef F563<T> = int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F564<T> = int Function({core.List<core.int> x}) Function();
+typedef F565<T> = int Function({core.List<core.int> x}) Function(int x);
+typedef F566<T> = int Function({core.List<core.int> x}) Function<B extends core.int>();
+typedef F567<T> = int Function({core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F568<T> = int Function(int x0, {core.List<core.int> x}) Function();
+typedef F569<T> = int Function(int x1, {core.List<core.int> x}) Function(int x);
+typedef F570<T> = int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F571<T> = int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F572<T> = int Function(int y, {core.List<core.int> x}) Function();
+typedef F573<T> = int Function(int y, {core.List<core.int> x}) Function(int x);
+typedef F574<T> = int Function(int y, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F575<T> = int Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F576<T> = int Function(List<T> x) Function();
+typedef F577<T> = int Function(List<T> x) Function(int x);
+typedef F578<T> = int Function(List<T> x) Function<B extends core.int>();
+typedef F579<T> = int Function(List<T> x) Function<B extends core.int>(int x);
+typedef F580<T> = int Function([List<T> x]) Function();
+typedef F581<T> = int Function([List<T> x]) Function(int x);
+typedef F582<T> = int Function([List<T> x]) Function<B extends core.int>();
+typedef F583<T> = int Function([List<T> x]) Function<B extends core.int>(int x);
+typedef F584<T> = int Function(int x0, [List<T> x]) Function();
+typedef F585<T> = int Function(int x1, [List<T> x]) Function(int x);
+typedef F586<T> = int Function(int x1, [List<T> x]) Function<B extends core.int>();
+typedef F587<T> = int Function(int x1, [List<T> x]) Function<B extends core.int>(int x);
+typedef F588<T> = int Function(int y, [List<T> x]) Function();
+typedef F589<T> = int Function(int y, [List<T> x]) Function(int x);
+typedef F590<T> = int Function(int y, [List<T> x]) Function<B extends core.int>();
+typedef F591<T> = int Function(int y, [List<T> x]) Function<B extends core.int>(int x);
+typedef F592<T> = int Function(List<T> x0) Function();
+typedef F593<T> = int Function(List<T> x1) Function(int x);
+typedef F594<T> = int Function(List<T> x1) Function<B extends core.int>();
+typedef F595<T> = int Function(List<T> x1) Function<B extends core.int>(int x);
+typedef F596<T> = int Function([List<T> x1]) Function();
+typedef F597<T> = int Function([List<T> x1]) Function(int x);
+typedef F598<T> = int Function([List<T> x1]) Function<B extends core.int>();
+typedef F599<T> = int Function([List<T> x1]) Function<B extends core.int>(int x);
+typedef F600<T> = int Function(int x1, [List<T> x2]) Function();
+typedef F601<T> = int Function(int x2, [List<T> x3]) Function(int x);
+typedef F602<T> = int Function(int x2, [List<T> x3]) Function<B extends core.int>();
+typedef F603<T> = int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x);
+typedef F604<T> = int Function(int x, [List<T> x2]) Function();
+typedef F605<T> = int Function(int x, [List<T> x1]) Function(int x);
+typedef F606<T> = int Function(int x, [List<T> x1]) Function<B extends core.int>();
+typedef F607<T> = int Function(int x, [List<T> x1]) Function<B extends core.int>(int x);
+typedef F608<T> = int Function({List<T> x}) Function();
+typedef F609<T> = int Function({List<T> x}) Function(int x);
+typedef F610<T> = int Function({List<T> x}) Function<B extends core.int>();
+typedef F611<T> = int Function({List<T> x}) Function<B extends core.int>(int x);
+typedef F612<T> = int Function(int x0, {List<T> x}) Function();
+typedef F613<T> = int Function(int x1, {List<T> x}) Function(int x);
+typedef F614<T> = int Function(int x1, {List<T> x}) Function<B extends core.int>();
+typedef F615<T> = int Function(int x1, {List<T> x}) Function<B extends core.int>(int x);
+typedef F616<T> = int Function(int y, {List<T> x}) Function();
+typedef F617<T> = int Function(int y, {List<T> x}) Function(int x);
+typedef F618<T> = int Function(int y, {List<T> x}) Function<B extends core.int>();
+typedef F619<T> = int Function(int y, {List<T> x}) Function<B extends core.int>(int x);
+typedef F620<T> = int Function() Function();
+typedef F621<T> = int Function() Function(int x);
+typedef F622<T> = int Function() Function<B extends core.int>();
+typedef F623<T> = int Function() Function<B extends core.int>(int x);
+typedef F624<T> = Function Function(int x) Function();
+typedef F625<T> = Function Function(int x) Function(int x);
+typedef F626<T> = Function Function(int x) Function<B extends core.int>();
+typedef F627<T> = Function Function(int x) Function<B extends core.int>(int x);
+typedef F628<T> = Function Function([int x]) Function();
+typedef F629<T> = Function Function([int x]) Function(int x);
+typedef F630<T> = Function Function([int x]) Function<B extends core.int>();
+typedef F631<T> = Function Function([int x]) Function<B extends core.int>(int x);
+typedef F632<T> = Function Function(int x0, [int x]) Function();
+typedef F633<T> = Function Function(int x1, [int x]) Function(int x);
+typedef F634<T> = Function Function(int x1, [int x]) Function<B extends core.int>();
+typedef F635<T> = Function Function(int x1, [int x]) Function<B extends core.int>(int x);
+typedef F636<T> = Function Function(int y, [int x]) Function();
+typedef F637<T> = Function Function(int y, [int x]) Function(int x);
+typedef F638<T> = Function Function(int y, [int x]) Function<B extends core.int>();
+typedef F639<T> = Function Function(int y, [int x]) Function<B extends core.int>(int x);
+typedef F640<T> = Function Function(int x0) Function();
+typedef F641<T> = Function Function(int x1) Function(int x);
+typedef F642<T> = Function Function(int x1) Function<B extends core.int>();
+typedef F643<T> = Function Function(int x1) Function<B extends core.int>(int x);
+typedef F644<T> = Function Function([int x1]) Function();
+typedef F645<T> = Function Function([int x1]) Function(int x);
+typedef F646<T> = Function Function([int x1]) Function<B extends core.int>();
+typedef F647<T> = Function Function([int x1]) Function<B extends core.int>(int x);
+typedef F648<T> = Function Function(int x1, [int x2]) Function();
+typedef F649<T> = Function Function(int x2, [int x3]) Function(int x);
+typedef F650<T> = Function Function(int x2, [int x3]) Function<B extends core.int>();
+typedef F651<T> = Function Function(int x2, [int x3]) Function<B extends core.int>(int x);
+typedef F652<T> = Function Function(int x, [int x2]) Function();
+typedef F653<T> = Function Function(int x, [int x1]) Function(int x);
+typedef F654<T> = Function Function(int x, [int x1]) Function<B extends core.int>();
+typedef F655<T> = Function Function(int x, [int x1]) Function<B extends core.int>(int x);
+typedef F656<T> = Function Function({int x}) Function();
+typedef F657<T> = Function Function({int x}) Function(int x);
+typedef F658<T> = Function Function({int x}) Function<B extends core.int>();
+typedef F659<T> = Function Function({int x}) Function<B extends core.int>(int x);
+typedef F660<T> = Function Function(int x0, {int x}) Function();
+typedef F661<T> = Function Function(int x1, {int x}) Function(int x);
+typedef F662<T> = Function Function(int x1, {int x}) Function<B extends core.int>();
+typedef F663<T> = Function Function(int x1, {int x}) Function<B extends core.int>(int x);
+typedef F664<T> = Function Function(int y, {int x}) Function();
+typedef F665<T> = Function Function(int y, {int x}) Function(int x);
+typedef F666<T> = Function Function(int y, {int x}) Function<B extends core.int>();
+typedef F667<T> = Function Function(int y, {int x}) Function<B extends core.int>(int x);
+typedef F668<T> = Function Function(Function x) Function();
+typedef F669<T> = Function Function(Function x) Function(int x);
+typedef F670<T> = Function Function(Function x) Function<B extends core.int>();
+typedef F671<T> = Function Function(Function x) Function<B extends core.int>(int x);
+typedef F672<T> = Function Function([Function x]) Function();
+typedef F673<T> = Function Function([Function x]) Function(int x);
+typedef F674<T> = Function Function([Function x]) Function<B extends core.int>();
+typedef F675<T> = Function Function([Function x]) Function<B extends core.int>(int x);
+typedef F676<T> = Function Function(int x0, [Function x]) Function();
+typedef F677<T> = Function Function(int x1, [Function x]) Function(int x);
+typedef F678<T> = Function Function(int x1, [Function x]) Function<B extends core.int>();
+typedef F679<T> = Function Function(int x1, [Function x]) Function<B extends core.int>(int x);
+typedef F680<T> = Function Function(int y, [Function x]) Function();
+typedef F681<T> = Function Function(int y, [Function x]) Function(int x);
+typedef F682<T> = Function Function(int y, [Function x]) Function<B extends core.int>();
+typedef F683<T> = Function Function(int y, [Function x]) Function<B extends core.int>(int x);
+typedef F684<T> = Function Function(Function x0) Function();
+typedef F685<T> = Function Function(Function x1) Function(int x);
+typedef F686<T> = Function Function(Function x1) Function<B extends core.int>();
+typedef F687<T> = Function Function(Function x1) Function<B extends core.int>(int x);
+typedef F688<T> = Function Function([Function x1]) Function();
+typedef F689<T> = Function Function([Function x1]) Function(int x);
+typedef F690<T> = Function Function([Function x1]) Function<B extends core.int>();
+typedef F691<T> = Function Function([Function x1]) Function<B extends core.int>(int x);
+typedef F692<T> = Function Function(int x1, [Function x2]) Function();
+typedef F693<T> = Function Function(int x2, [Function x3]) Function(int x);
+typedef F694<T> = Function Function(int x2, [Function x3]) Function<B extends core.int>();
+typedef F695<T> = Function Function(int x2, [Function x3]) Function<B extends core.int>(int x);
+typedef F696<T> = Function Function(int x, [Function x2]) Function();
+typedef F697<T> = Function Function(int x, [Function x1]) Function(int x);
+typedef F698<T> = Function Function(int x, [Function x1]) Function<B extends core.int>();
+typedef F699<T> = Function Function(int x, [Function x1]) Function<B extends core.int>(int x);
+typedef F700<T> = Function Function({Function x}) Function();
+typedef F701<T> = Function Function({Function x}) Function(int x);
+typedef F702<T> = Function Function({Function x}) Function<B extends core.int>();
+typedef F703<T> = Function Function({Function x}) Function<B extends core.int>(int x);
+typedef F704<T> = Function Function(int x0, {Function x}) Function();
+typedef F705<T> = Function Function(int x1, {Function x}) Function(int x);
+typedef F706<T> = Function Function(int x1, {Function x}) Function<B extends core.int>();
+typedef F707<T> = Function Function(int x1, {Function x}) Function<B extends core.int>(int x);
+typedef F708<T> = Function Function(int y, {Function x}) Function();
+typedef F709<T> = Function Function(int y, {Function x}) Function(int x);
+typedef F710<T> = Function Function(int y, {Function x}) Function<B extends core.int>();
+typedef F711<T> = Function Function(int y, {Function x}) Function<B extends core.int>(int x);
+typedef F712<T> = Function Function(List<Function> x) Function();
+typedef F713<T> = Function Function(List<Function> x) Function(int x);
+typedef F714<T> = Function Function(List<Function> x) Function<B extends core.int>();
+typedef F715<T> = Function Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F716<T> = Function Function([List<Function> x]) Function();
+typedef F717<T> = Function Function([List<Function> x]) Function(int x);
+typedef F718<T> = Function Function([List<Function> x]) Function<B extends core.int>();
+typedef F719<T> = Function Function([List<Function> x]) Function<B extends core.int>(int x);
+typedef F720<T> = Function Function(int x0, [List<Function> x]) Function();
+typedef F721<T> = Function Function(int x1, [List<Function> x]) Function(int x);
+typedef F722<T> = Function Function(int x1, [List<Function> x]) Function<B extends core.int>();
+typedef F723<T> = Function Function(int x1, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F724<T> = Function Function(int y, [List<Function> x]) Function();
+typedef F725<T> = Function Function(int y, [List<Function> x]) Function(int x);
+typedef F726<T> = Function Function(int y, [List<Function> x]) Function<B extends core.int>();
+typedef F727<T> = Function Function(int y, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F728<T> = Function Function(List<Function> x0) Function();
+typedef F729<T> = Function Function(List<Function> x1) Function(int x);
+typedef F730<T> = Function Function(List<Function> x1) Function<B extends core.int>();
+typedef F731<T> = Function Function(List<Function> x1) Function<B extends core.int>(int x);
+typedef F732<T> = Function Function([List<Function> x1]) Function();
+typedef F733<T> = Function Function([List<Function> x1]) Function(int x);
+typedef F734<T> = Function Function([List<Function> x1]) Function<B extends core.int>();
+typedef F735<T> = Function Function([List<Function> x1]) Function<B extends core.int>(int x);
+typedef F736<T> = Function Function(int x1, [List<Function> x2]) Function();
+typedef F737<T> = Function Function(int x2, [List<Function> x3]) Function(int x);
+typedef F738<T> = Function Function(int x2, [List<Function> x3]) Function<B extends core.int>();
+typedef F739<T> = Function Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x);
+typedef F740<T> = Function Function(int x, [List<Function> x2]) Function();
+typedef F741<T> = Function Function(int x, [List<Function> x1]) Function(int x);
+typedef F742<T> = Function Function(int x, [List<Function> x1]) Function<B extends core.int>();
+typedef F743<T> = Function Function(int x, [List<Function> x1]) Function<B extends core.int>(int x);
+typedef F744<T> = Function Function({List<Function> x}) Function();
+typedef F745<T> = Function Function({List<Function> x}) Function(int x);
+typedef F746<T> = Function Function({List<Function> x}) Function<B extends core.int>();
+typedef F747<T> = Function Function({List<Function> x}) Function<B extends core.int>(int x);
+typedef F748<T> = Function Function(int x0, {List<Function> x}) Function();
+typedef F749<T> = Function Function(int x1, {List<Function> x}) Function(int x);
+typedef F750<T> = Function Function(int x1, {List<Function> x}) Function<B extends core.int>();
+typedef F751<T> = Function Function(int x1, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F752<T> = Function Function(int y, {List<Function> x}) Function();
+typedef F753<T> = Function Function(int y, {List<Function> x}) Function(int x);
+typedef F754<T> = Function Function(int y, {List<Function> x}) Function<B extends core.int>();
+typedef F755<T> = Function Function(int y, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F756<T> = Function Function(core.List<core.int> x) Function();
+typedef F757<T> = Function Function(core.List<core.int> x) Function(int x);
+typedef F758<T> = Function Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F759<T> = Function Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F760<T> = Function Function([core.List<core.int> x]) Function();
+typedef F761<T> = Function Function([core.List<core.int> x]) Function(int x);
+typedef F762<T> = Function Function([core.List<core.int> x]) Function<B extends core.int>();
+typedef F763<T> = Function Function([core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F764<T> = Function Function(int x0, [core.List<core.int> x]) Function();
+typedef F765<T> = Function Function(int x1, [core.List<core.int> x]) Function(int x);
+typedef F766<T> = Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F767<T> = Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F768<T> = Function Function(int y, [core.List<core.int> x]) Function();
+typedef F769<T> = Function Function(int y, [core.List<core.int> x]) Function(int x);
+typedef F770<T> = Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F771<T> = Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F772<T> = Function Function(core.List<core.int> x0) Function();
+typedef F773<T> = Function Function(core.List<core.int> x1) Function(int x);
+typedef F774<T> = Function Function(core.List<core.int> x1) Function<B extends core.int>();
+typedef F775<T> = Function Function(core.List<core.int> x1) Function<B extends core.int>(int x);
+typedef F776<T> = Function Function([core.List<core.int> x1]) Function();
+typedef F777<T> = Function Function([core.List<core.int> x1]) Function(int x);
+typedef F778<T> = Function Function([core.List<core.int> x1]) Function<B extends core.int>();
+typedef F779<T> = Function Function([core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F780<T> = Function Function(int x1, [core.List<core.int> x2]) Function();
+typedef F781<T> = Function Function(int x2, [core.List<core.int> x3]) Function(int x);
+typedef F782<T> = Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>();
+typedef F783<T> = Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x);
+typedef F784<T> = Function Function(int x, [core.List<core.int> x2]) Function();
+typedef F785<T> = Function Function(int x, [core.List<core.int> x1]) Function(int x);
+typedef F786<T> = Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>();
+typedef F787<T> = Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F788<T> = Function Function({core.List<core.int> x}) Function();
+typedef F789<T> = Function Function({core.List<core.int> x}) Function(int x);
+typedef F790<T> = Function Function({core.List<core.int> x}) Function<B extends core.int>();
+typedef F791<T> = Function Function({core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F792<T> = Function Function(int x0, {core.List<core.int> x}) Function();
+typedef F793<T> = Function Function(int x1, {core.List<core.int> x}) Function(int x);
+typedef F794<T> = Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F795<T> = Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F796<T> = Function Function(int y, {core.List<core.int> x}) Function();
+typedef F797<T> = Function Function(int y, {core.List<core.int> x}) Function(int x);
+typedef F798<T> = Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F799<T> = Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F800<T> = Function Function(List<T> x) Function();
+typedef F801<T> = Function Function(List<T> x) Function(int x);
+typedef F802<T> = Function Function(List<T> x) Function<B extends core.int>();
+typedef F803<T> = Function Function(List<T> x) Function<B extends core.int>(int x);
+typedef F804<T> = Function Function([List<T> x]) Function();
+typedef F805<T> = Function Function([List<T> x]) Function(int x);
+typedef F806<T> = Function Function([List<T> x]) Function<B extends core.int>();
+typedef F807<T> = Function Function([List<T> x]) Function<B extends core.int>(int x);
+typedef F808<T> = Function Function(int x0, [List<T> x]) Function();
+typedef F809<T> = Function Function(int x1, [List<T> x]) Function(int x);
+typedef F810<T> = Function Function(int x1, [List<T> x]) Function<B extends core.int>();
+typedef F811<T> = Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x);
+typedef F812<T> = Function Function(int y, [List<T> x]) Function();
+typedef F813<T> = Function Function(int y, [List<T> x]) Function(int x);
+typedef F814<T> = Function Function(int y, [List<T> x]) Function<B extends core.int>();
+typedef F815<T> = Function Function(int y, [List<T> x]) Function<B extends core.int>(int x);
+typedef F816<T> = Function Function(List<T> x0) Function();
+typedef F817<T> = Function Function(List<T> x1) Function(int x);
+typedef F818<T> = Function Function(List<T> x1) Function<B extends core.int>();
+typedef F819<T> = Function Function(List<T> x1) Function<B extends core.int>(int x);
+typedef F820<T> = Function Function([List<T> x1]) Function();
+typedef F821<T> = Function Function([List<T> x1]) Function(int x);
+typedef F822<T> = Function Function([List<T> x1]) Function<B extends core.int>();
+typedef F823<T> = Function Function([List<T> x1]) Function<B extends core.int>(int x);
+typedef F824<T> = Function Function(int x1, [List<T> x2]) Function();
+typedef F825<T> = Function Function(int x2, [List<T> x3]) Function(int x);
+typedef F826<T> = Function Function(int x2, [List<T> x3]) Function<B extends core.int>();
+typedef F827<T> = Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x);
+typedef F828<T> = Function Function(int x, [List<T> x2]) Function();
+typedef F829<T> = Function Function(int x, [List<T> x1]) Function(int x);
+typedef F830<T> = Function Function(int x, [List<T> x1]) Function<B extends core.int>();
+typedef F831<T> = Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x);
+typedef F832<T> = Function Function({List<T> x}) Function();
+typedef F833<T> = Function Function({List<T> x}) Function(int x);
+typedef F834<T> = Function Function({List<T> x}) Function<B extends core.int>();
+typedef F835<T> = Function Function({List<T> x}) Function<B extends core.int>(int x);
+typedef F836<T> = Function Function(int x0, {List<T> x}) Function();
+typedef F837<T> = Function Function(int x1, {List<T> x}) Function(int x);
+typedef F838<T> = Function Function(int x1, {List<T> x}) Function<B extends core.int>();
+typedef F839<T> = Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x);
+typedef F840<T> = Function Function(int y, {List<T> x}) Function();
+typedef F841<T> = Function Function(int y, {List<T> x}) Function(int x);
+typedef F842<T> = Function Function(int y, {List<T> x}) Function<B extends core.int>();
+typedef F843<T> = Function Function(int y, {List<T> x}) Function<B extends core.int>(int x);
+typedef F844<T> = Function Function() Function();
+typedef F845<T> = Function Function() Function(int x);
+typedef F846<T> = Function Function() Function<B extends core.int>();
+typedef F847<T> = Function Function() Function<B extends core.int>(int x);
+typedef F848<T> = List<Function> Function(int x) Function();
+typedef F849<T> = List<Function> Function(int x) Function(int x);
+typedef F850<T> = List<Function> Function(int x) Function<B extends core.int>();
+typedef F851<T> = List<Function> Function(int x) Function<B extends core.int>(int x);
+typedef F852<T> = List<Function> Function([int x]) Function();
+typedef F853<T> = List<Function> Function([int x]) Function(int x);
+typedef F854<T> = List<Function> Function([int x]) Function<B extends core.int>();
+typedef F855<T> = List<Function> Function([int x]) Function<B extends core.int>(int x);
+typedef F856<T> = List<Function> Function(int x0, [int x]) Function();
+typedef F857<T> = List<Function> Function(int x1, [int x]) Function(int x);
+typedef F858<T> = List<Function> Function(int x1, [int x]) Function<B extends core.int>();
+typedef F859<T> = List<Function> Function(int x1, [int x]) Function<B extends core.int>(int x);
+typedef F860<T> = List<Function> Function(int y, [int x]) Function();
+typedef F861<T> = List<Function> Function(int y, [int x]) Function(int x);
+typedef F862<T> = List<Function> Function(int y, [int x]) Function<B extends core.int>();
+typedef F863<T> = List<Function> Function(int y, [int x]) Function<B extends core.int>(int x);
+typedef F864<T> = List<Function> Function(int x0) Function();
+typedef F865<T> = List<Function> Function(int x1) Function(int x);
+typedef F866<T> = List<Function> Function(int x1) Function<B extends core.int>();
+typedef F867<T> = List<Function> Function(int x1) Function<B extends core.int>(int x);
+typedef F868<T> = List<Function> Function([int x1]) Function();
+typedef F869<T> = List<Function> Function([int x1]) Function(int x);
+typedef F870<T> = List<Function> Function([int x1]) Function<B extends core.int>();
+typedef F871<T> = List<Function> Function([int x1]) Function<B extends core.int>(int x);
+typedef F872<T> = List<Function> Function(int x1, [int x2]) Function();
+typedef F873<T> = List<Function> Function(int x2, [int x3]) Function(int x);
+typedef F874<T> = List<Function> Function(int x2, [int x3]) Function<B extends core.int>();
+typedef F875<T> = List<Function> Function(int x2, [int x3]) Function<B extends core.int>(int x);
+typedef F876<T> = List<Function> Function(int x, [int x2]) Function();
+typedef F877<T> = List<Function> Function(int x, [int x1]) Function(int x);
+typedef F878<T> = List<Function> Function(int x, [int x1]) Function<B extends core.int>();
+typedef F879<T> = List<Function> Function(int x, [int x1]) Function<B extends core.int>(int x);
+typedef F880<T> = List<Function> Function({int x}) Function();
+typedef F881<T> = List<Function> Function({int x}) Function(int x);
+typedef F882<T> = List<Function> Function({int x}) Function<B extends core.int>();
+typedef F883<T> = List<Function> Function({int x}) Function<B extends core.int>(int x);
+typedef F884<T> = List<Function> Function(int x0, {int x}) Function();
+typedef F885<T> = List<Function> Function(int x1, {int x}) Function(int x);
+typedef F886<T> = List<Function> Function(int x1, {int x}) Function<B extends core.int>();
+typedef F887<T> = List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x);
+typedef F888<T> = List<Function> Function(int y, {int x}) Function();
+typedef F889<T> = List<Function> Function(int y, {int x}) Function(int x);
+typedef F890<T> = List<Function> Function(int y, {int x}) Function<B extends core.int>();
+typedef F891<T> = List<Function> Function(int y, {int x}) Function<B extends core.int>(int x);
+typedef F892<T> = List<Function> Function(Function x) Function();
+typedef F893<T> = List<Function> Function(Function x) Function(int x);
+typedef F894<T> = List<Function> Function(Function x) Function<B extends core.int>();
+typedef F895<T> = List<Function> Function(Function x) Function<B extends core.int>(int x);
+typedef F896<T> = List<Function> Function([Function x]) Function();
+typedef F897<T> = List<Function> Function([Function x]) Function(int x);
+typedef F898<T> = List<Function> Function([Function x]) Function<B extends core.int>();
+typedef F899<T> = List<Function> Function([Function x]) Function<B extends core.int>(int x);
+typedef F900<T> = List<Function> Function(int x0, [Function x]) Function();
+typedef F901<T> = List<Function> Function(int x1, [Function x]) Function(int x);
+typedef F902<T> = List<Function> Function(int x1, [Function x]) Function<B extends core.int>();
+typedef F903<T> = List<Function> Function(int x1, [Function x]) Function<B extends core.int>(int x);
+typedef F904<T> = List<Function> Function(int y, [Function x]) Function();
+typedef F905<T> = List<Function> Function(int y, [Function x]) Function(int x);
+typedef F906<T> = List<Function> Function(int y, [Function x]) Function<B extends core.int>();
+typedef F907<T> = List<Function> Function(int y, [Function x]) Function<B extends core.int>(int x);
+typedef F908<T> = List<Function> Function(Function x0) Function();
+typedef F909<T> = List<Function> Function(Function x1) Function(int x);
+typedef F910<T> = List<Function> Function(Function x1) Function<B extends core.int>();
+typedef F911<T> = List<Function> Function(Function x1) Function<B extends core.int>(int x);
+typedef F912<T> = List<Function> Function([Function x1]) Function();
+typedef F913<T> = List<Function> Function([Function x1]) Function(int x);
+typedef F914<T> = List<Function> Function([Function x1]) Function<B extends core.int>();
+typedef F915<T> = List<Function> Function([Function x1]) Function<B extends core.int>(int x);
+typedef F916<T> = List<Function> Function(int x1, [Function x2]) Function();
+typedef F917<T> = List<Function> Function(int x2, [Function x3]) Function(int x);
+typedef F918<T> = List<Function> Function(int x2, [Function x3]) Function<B extends core.int>();
+typedef F919<T> = List<Function> Function(int x2, [Function x3]) Function<B extends core.int>(int x);
+typedef F920<T> = List<Function> Function(int x, [Function x2]) Function();
+typedef F921<T> = List<Function> Function(int x, [Function x1]) Function(int x);
+typedef F922<T> = List<Function> Function(int x, [Function x1]) Function<B extends core.int>();
+typedef F923<T> = List<Function> Function(int x, [Function x1]) Function<B extends core.int>(int x);
+typedef F924<T> = List<Function> Function({Function x}) Function();
+typedef F925<T> = List<Function> Function({Function x}) Function(int x);
+typedef F926<T> = List<Function> Function({Function x}) Function<B extends core.int>();
+typedef F927<T> = List<Function> Function({Function x}) Function<B extends core.int>(int x);
+typedef F928<T> = List<Function> Function(int x0, {Function x}) Function();
+typedef F929<T> = List<Function> Function(int x1, {Function x}) Function(int x);
+typedef F930<T> = List<Function> Function(int x1, {Function x}) Function<B extends core.int>();
+typedef F931<T> = List<Function> Function(int x1, {Function x}) Function<B extends core.int>(int x);
+typedef F932<T> = List<Function> Function(int y, {Function x}) Function();
+typedef F933<T> = List<Function> Function(int y, {Function x}) Function(int x);
+typedef F934<T> = List<Function> Function(int y, {Function x}) Function<B extends core.int>();
+typedef F935<T> = List<Function> Function(int y, {Function x}) Function<B extends core.int>(int x);
+typedef F936<T> = List<Function> Function(List<Function> x) Function();
+typedef F937<T> = List<Function> Function(List<Function> x) Function(int x);
+typedef F938<T> = List<Function> Function(List<Function> x) Function<B extends core.int>();
+typedef F939<T> = List<Function> Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F940<T> = List<Function> Function([List<Function> x]) Function();
+typedef F941<T> = List<Function> Function([List<Function> x]) Function(int x);
+typedef F942<T> = List<Function> Function([List<Function> x]) Function<B extends core.int>();
+typedef F943<T> = List<Function> Function([List<Function> x]) Function<B extends core.int>(int x);
+typedef F944<T> = List<Function> Function(int x0, [List<Function> x]) Function();
+typedef F945<T> = List<Function> Function(int x1, [List<Function> x]) Function(int x);
+typedef F946<T> = List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>();
+typedef F947<T> = List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F948<T> = List<Function> Function(int y, [List<Function> x]) Function();
+typedef F949<T> = List<Function> Function(int y, [List<Function> x]) Function(int x);
+typedef F950<T> = List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>();
+typedef F951<T> = List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F952<T> = List<Function> Function(List<Function> x0) Function();
+typedef F953<T> = List<Function> Function(List<Function> x1) Function(int x);
+typedef F954<T> = List<Function> Function(List<Function> x1) Function<B extends core.int>();
+typedef F955<T> = List<Function> Function(List<Function> x1) Function<B extends core.int>(int x);
+typedef F956<T> = List<Function> Function([List<Function> x1]) Function();
+typedef F957<T> = List<Function> Function([List<Function> x1]) Function(int x);
+typedef F958<T> = List<Function> Function([List<Function> x1]) Function<B extends core.int>();
+typedef F959<T> = List<Function> Function([List<Function> x1]) Function<B extends core.int>(int x);
+typedef F960<T> = List<Function> Function(int x1, [List<Function> x2]) Function();
+typedef F961<T> = List<Function> Function(int x2, [List<Function> x3]) Function(int x);
+typedef F962<T> = List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>();
+typedef F963<T> = List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x);
+typedef F964<T> = List<Function> Function(int x, [List<Function> x2]) Function();
+typedef F965<T> = List<Function> Function(int x, [List<Function> x1]) Function(int x);
+typedef F966<T> = List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>();
+typedef F967<T> = List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x);
+typedef F968<T> = List<Function> Function({List<Function> x}) Function();
+typedef F969<T> = List<Function> Function({List<Function> x}) Function(int x);
+typedef F970<T> = List<Function> Function({List<Function> x}) Function<B extends core.int>();
+typedef F971<T> = List<Function> Function({List<Function> x}) Function<B extends core.int>(int x);
+typedef F972<T> = List<Function> Function(int x0, {List<Function> x}) Function();
+typedef F973<T> = List<Function> Function(int x1, {List<Function> x}) Function(int x);
+typedef F974<T> = List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>();
+typedef F975<T> = List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F976<T> = List<Function> Function(int y, {List<Function> x}) Function();
+typedef F977<T> = List<Function> Function(int y, {List<Function> x}) Function(int x);
+typedef F978<T> = List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>();
+typedef F979<T> = List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F980<T> = List<Function> Function(core.List<core.int> x) Function();
+typedef F981<T> = List<Function> Function(core.List<core.int> x) Function(int x);
+typedef F982<T> = List<Function> Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F983<T> = List<Function> Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F984<T> = List<Function> Function([core.List<core.int> x]) Function();
+typedef F985<T> = List<Function> Function([core.List<core.int> x]) Function(int x);
+typedef F986<T> = List<Function> Function([core.List<core.int> x]) Function<B extends core.int>();
+typedef F987<T> = List<Function> Function([core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F988<T> = List<Function> Function(int x0, [core.List<core.int> x]) Function();
+typedef F989<T> = List<Function> Function(int x1, [core.List<core.int> x]) Function(int x);
+typedef F990<T> = List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F991<T> = List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F992<T> = List<Function> Function(int y, [core.List<core.int> x]) Function();
+typedef F993<T> = List<Function> Function(int y, [core.List<core.int> x]) Function(int x);
+typedef F994<T> = List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F995<T> = List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F996<T> = List<Function> Function(core.List<core.int> x0) Function();
+typedef F997<T> = List<Function> Function(core.List<core.int> x1) Function(int x);
+typedef F998<T> = List<Function> Function(core.List<core.int> x1) Function<B extends core.int>();
+typedef F999<T> = List<Function> Function(core.List<core.int> x1) Function<B extends core.int>(int x);
+typedef F1000<T> = List<Function> Function([core.List<core.int> x1]) Function();
+typedef F1001<T> = List<Function> Function([core.List<core.int> x1]) Function(int x);
+typedef F1002<T> = List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1003<T> = List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1004<T> = List<Function> Function(int x1, [core.List<core.int> x2]) Function();
+typedef F1005<T> = List<Function> Function(int x2, [core.List<core.int> x3]) Function(int x);
+typedef F1006<T> = List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>();
+typedef F1007<T> = List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x);
+typedef F1008<T> = List<Function> Function(int x, [core.List<core.int> x2]) Function();
+typedef F1009<T> = List<Function> Function(int x, [core.List<core.int> x1]) Function(int x);
+typedef F1010<T> = List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1011<T> = List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1012<T> = List<Function> Function({core.List<core.int> x}) Function();
+typedef F1013<T> = List<Function> Function({core.List<core.int> x}) Function(int x);
+typedef F1014<T> = List<Function> Function({core.List<core.int> x}) Function<B extends core.int>();
+typedef F1015<T> = List<Function> Function({core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1016<T> = List<Function> Function(int x0, {core.List<core.int> x}) Function();
+typedef F1017<T> = List<Function> Function(int x1, {core.List<core.int> x}) Function(int x);
+typedef F1018<T> = List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1019<T> = List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1020<T> = List<Function> Function(int y, {core.List<core.int> x}) Function();
+typedef F1021<T> = List<Function> Function(int y, {core.List<core.int> x}) Function(int x);
+typedef F1022<T> = List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1023<T> = List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1024<T> = List<Function> Function(List<T> x) Function();
+typedef F1025<T> = List<Function> Function(List<T> x) Function(int x);
+typedef F1026<T> = List<Function> Function(List<T> x) Function<B extends core.int>();
+typedef F1027<T> = List<Function> Function(List<T> x) Function<B extends core.int>(int x);
+typedef F1028<T> = List<Function> Function([List<T> x]) Function();
+typedef F1029<T> = List<Function> Function([List<T> x]) Function(int x);
+typedef F1030<T> = List<Function> Function([List<T> x]) Function<B extends core.int>();
+typedef F1031<T> = List<Function> Function([List<T> x]) Function<B extends core.int>(int x);
+typedef F1032<T> = List<Function> Function(int x0, [List<T> x]) Function();
+typedef F1033<T> = List<Function> Function(int x1, [List<T> x]) Function(int x);
+typedef F1034<T> = List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>();
+typedef F1035<T> = List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1036<T> = List<Function> Function(int y, [List<T> x]) Function();
+typedef F1037<T> = List<Function> Function(int y, [List<T> x]) Function(int x);
+typedef F1038<T> = List<Function> Function(int y, [List<T> x]) Function<B extends core.int>();
+typedef F1039<T> = List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1040<T> = List<Function> Function(List<T> x0) Function();
+typedef F1041<T> = List<Function> Function(List<T> x1) Function(int x);
+typedef F1042<T> = List<Function> Function(List<T> x1) Function<B extends core.int>();
+typedef F1043<T> = List<Function> Function(List<T> x1) Function<B extends core.int>(int x);
+typedef F1044<T> = List<Function> Function([List<T> x1]) Function();
+typedef F1045<T> = List<Function> Function([List<T> x1]) Function(int x);
+typedef F1046<T> = List<Function> Function([List<T> x1]) Function<B extends core.int>();
+typedef F1047<T> = List<Function> Function([List<T> x1]) Function<B extends core.int>(int x);
+typedef F1048<T> = List<Function> Function(int x1, [List<T> x2]) Function();
+typedef F1049<T> = List<Function> Function(int x2, [List<T> x3]) Function(int x);
+typedef F1050<T> = List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>();
+typedef F1051<T> = List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x);
+typedef F1052<T> = List<Function> Function(int x, [List<T> x2]) Function();
+typedef F1053<T> = List<Function> Function(int x, [List<T> x1]) Function(int x);
+typedef F1054<T> = List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>();
+typedef F1055<T> = List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x);
+typedef F1056<T> = List<Function> Function({List<T> x}) Function();
+typedef F1057<T> = List<Function> Function({List<T> x}) Function(int x);
+typedef F1058<T> = List<Function> Function({List<T> x}) Function<B extends core.int>();
+typedef F1059<T> = List<Function> Function({List<T> x}) Function<B extends core.int>(int x);
+typedef F1060<T> = List<Function> Function(int x0, {List<T> x}) Function();
+typedef F1061<T> = List<Function> Function(int x1, {List<T> x}) Function(int x);
+typedef F1062<T> = List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>();
+typedef F1063<T> = List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1064<T> = List<Function> Function(int y, {List<T> x}) Function();
+typedef F1065<T> = List<Function> Function(int y, {List<T> x}) Function(int x);
+typedef F1066<T> = List<Function> Function(int y, {List<T> x}) Function<B extends core.int>();
+typedef F1067<T> = List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1068<T> = List<Function> Function() Function();
+typedef F1069<T> = List<Function> Function() Function(int x);
+typedef F1070<T> = List<Function> Function() Function<B extends core.int>();
+typedef F1071<T> = List<Function> Function() Function<B extends core.int>(int x);
+typedef F1072<T> = core.List<core.int> Function(int x) Function();
+typedef F1073<T> = core.List<core.int> Function(int x) Function(int x);
+typedef F1074<T> = core.List<core.int> Function(int x) Function<B extends core.int>();
+typedef F1075<T> = core.List<core.int> Function(int x) Function<B extends core.int>(int x);
+typedef F1076<T> = core.List<core.int> Function([int x]) Function();
+typedef F1077<T> = core.List<core.int> Function([int x]) Function(int x);
+typedef F1078<T> = core.List<core.int> Function([int x]) Function<B extends core.int>();
+typedef F1079<T> = core.List<core.int> Function([int x]) Function<B extends core.int>(int x);
+typedef F1080<T> = core.List<core.int> Function(int x0, [int x]) Function();
+typedef F1081<T> = core.List<core.int> Function(int x1, [int x]) Function(int x);
+typedef F1082<T> = core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>();
+typedef F1083<T> = core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>(int x);
+typedef F1084<T> = core.List<core.int> Function(int y, [int x]) Function();
+typedef F1085<T> = core.List<core.int> Function(int y, [int x]) Function(int x);
+typedef F1086<T> = core.List<core.int> Function(int y, [int x]) Function<B extends core.int>();
+typedef F1087<T> = core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(int x);
+typedef F1088<T> = core.List<core.int> Function(int x0) Function();
+typedef F1089<T> = core.List<core.int> Function(int x1) Function(int x);
+typedef F1090<T> = core.List<core.int> Function(int x1) Function<B extends core.int>();
+typedef F1091<T> = core.List<core.int> Function(int x1) Function<B extends core.int>(int x);
+typedef F1092<T> = core.List<core.int> Function([int x1]) Function();
+typedef F1093<T> = core.List<core.int> Function([int x1]) Function(int x);
+typedef F1094<T> = core.List<core.int> Function([int x1]) Function<B extends core.int>();
+typedef F1095<T> = core.List<core.int> Function([int x1]) Function<B extends core.int>(int x);
+typedef F1096<T> = core.List<core.int> Function(int x1, [int x2]) Function();
+typedef F1097<T> = core.List<core.int> Function(int x2, [int x3]) Function(int x);
+typedef F1098<T> = core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>();
+typedef F1099<T> = core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>(int x);
+typedef F1100<T> = core.List<core.int> Function(int x, [int x2]) Function();
+typedef F1101<T> = core.List<core.int> Function(int x, [int x1]) Function(int x);
+typedef F1102<T> = core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>();
+typedef F1103<T> = core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>(int x);
+typedef F1104<T> = core.List<core.int> Function({int x}) Function();
+typedef F1105<T> = core.List<core.int> Function({int x}) Function(int x);
+typedef F1106<T> = core.List<core.int> Function({int x}) Function<B extends core.int>();
+typedef F1107<T> = core.List<core.int> Function({int x}) Function<B extends core.int>(int x);
+typedef F1108<T> = core.List<core.int> Function(int x0, {int x}) Function();
+typedef F1109<T> = core.List<core.int> Function(int x1, {int x}) Function(int x);
+typedef F1110<T> = core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>();
+typedef F1111<T> = core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>(int x);
+typedef F1112<T> = core.List<core.int> Function(int y, {int x}) Function();
+typedef F1113<T> = core.List<core.int> Function(int y, {int x}) Function(int x);
+typedef F1114<T> = core.List<core.int> Function(int y, {int x}) Function<B extends core.int>();
+typedef F1115<T> = core.List<core.int> Function(int y, {int x}) Function<B extends core.int>(int x);
+typedef F1116<T> = core.List<core.int> Function(Function x) Function();
+typedef F1117<T> = core.List<core.int> Function(Function x) Function(int x);
+typedef F1118<T> = core.List<core.int> Function(Function x) Function<B extends core.int>();
+typedef F1119<T> = core.List<core.int> Function(Function x) Function<B extends core.int>(int x);
+typedef F1120<T> = core.List<core.int> Function([Function x]) Function();
+typedef F1121<T> = core.List<core.int> Function([Function x]) Function(int x);
+typedef F1122<T> = core.List<core.int> Function([Function x]) Function<B extends core.int>();
+typedef F1123<T> = core.List<core.int> Function([Function x]) Function<B extends core.int>(int x);
+typedef F1124<T> = core.List<core.int> Function(int x0, [Function x]) Function();
+typedef F1125<T> = core.List<core.int> Function(int x1, [Function x]) Function(int x);
+typedef F1126<T> = core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>();
+typedef F1127<T> = core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>(int x);
+typedef F1128<T> = core.List<core.int> Function(int y, [Function x]) Function();
+typedef F1129<T> = core.List<core.int> Function(int y, [Function x]) Function(int x);
+typedef F1130<T> = core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>();
+typedef F1131<T> = core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>(int x);
+typedef F1132<T> = core.List<core.int> Function(Function x0) Function();
+typedef F1133<T> = core.List<core.int> Function(Function x1) Function(int x);
+typedef F1134<T> = core.List<core.int> Function(Function x1) Function<B extends core.int>();
+typedef F1135<T> = core.List<core.int> Function(Function x1) Function<B extends core.int>(int x);
+typedef F1136<T> = core.List<core.int> Function([Function x1]) Function();
+typedef F1137<T> = core.List<core.int> Function([Function x1]) Function(int x);
+typedef F1138<T> = core.List<core.int> Function([Function x1]) Function<B extends core.int>();
+typedef F1139<T> = core.List<core.int> Function([Function x1]) Function<B extends core.int>(int x);
+typedef F1140<T> = core.List<core.int> Function(int x1, [Function x2]) Function();
+typedef F1141<T> = core.List<core.int> Function(int x2, [Function x3]) Function(int x);
+typedef F1142<T> = core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>();
+typedef F1143<T> = core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>(int x);
+typedef F1144<T> = core.List<core.int> Function(int x, [Function x2]) Function();
+typedef F1145<T> = core.List<core.int> Function(int x, [Function x1]) Function(int x);
+typedef F1146<T> = core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>();
+typedef F1147<T> = core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>(int x);
+typedef F1148<T> = core.List<core.int> Function({Function x}) Function();
+typedef F1149<T> = core.List<core.int> Function({Function x}) Function(int x);
+typedef F1150<T> = core.List<core.int> Function({Function x}) Function<B extends core.int>();
+typedef F1151<T> = core.List<core.int> Function({Function x}) Function<B extends core.int>(int x);
+typedef F1152<T> = core.List<core.int> Function(int x0, {Function x}) Function();
+typedef F1153<T> = core.List<core.int> Function(int x1, {Function x}) Function(int x);
+typedef F1154<T> = core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>();
+typedef F1155<T> = core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>(int x);
+typedef F1156<T> = core.List<core.int> Function(int y, {Function x}) Function();
+typedef F1157<T> = core.List<core.int> Function(int y, {Function x}) Function(int x);
+typedef F1158<T> = core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>();
+typedef F1159<T> = core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>(int x);
+typedef F1160<T> = core.List<core.int> Function(List<Function> x) Function();
+typedef F1161<T> = core.List<core.int> Function(List<Function> x) Function(int x);
+typedef F1162<T> = core.List<core.int> Function(List<Function> x) Function<B extends core.int>();
+typedef F1163<T> = core.List<core.int> Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F1164<T> = core.List<core.int> Function([List<Function> x]) Function();
+typedef F1165<T> = core.List<core.int> Function([List<Function> x]) Function(int x);
+typedef F1166<T> = core.List<core.int> Function([List<Function> x]) Function<B extends core.int>();
+typedef F1167<T> = core.List<core.int> Function([List<Function> x]) Function<B extends core.int>(int x);
+typedef F1168<T> = core.List<core.int> Function(int x0, [List<Function> x]) Function();
+typedef F1169<T> = core.List<core.int> Function(int x1, [List<Function> x]) Function(int x);
+typedef F1170<T> = core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>();
+typedef F1171<T> = core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F1172<T> = core.List<core.int> Function(int y, [List<Function> x]) Function();
+typedef F1173<T> = core.List<core.int> Function(int y, [List<Function> x]) Function(int x);
+typedef F1174<T> = core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>();
+typedef F1175<T> = core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F1176<T> = core.List<core.int> Function(List<Function> x0) Function();
+typedef F1177<T> = core.List<core.int> Function(List<Function> x1) Function(int x);
+typedef F1178<T> = core.List<core.int> Function(List<Function> x1) Function<B extends core.int>();
+typedef F1179<T> = core.List<core.int> Function(List<Function> x1) Function<B extends core.int>(int x);
+typedef F1180<T> = core.List<core.int> Function([List<Function> x1]) Function();
+typedef F1181<T> = core.List<core.int> Function([List<Function> x1]) Function(int x);
+typedef F1182<T> = core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>();
+typedef F1183<T> = core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>(int x);
+typedef F1184<T> = core.List<core.int> Function(int x1, [List<Function> x2]) Function();
+typedef F1185<T> = core.List<core.int> Function(int x2, [List<Function> x3]) Function(int x);
+typedef F1186<T> = core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>();
+typedef F1187<T> = core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x);
+typedef F1188<T> = core.List<core.int> Function(int x, [List<Function> x2]) Function();
+typedef F1189<T> = core.List<core.int> Function(int x, [List<Function> x1]) Function(int x);
+typedef F1190<T> = core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>();
+typedef F1191<T> = core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x);
+typedef F1192<T> = core.List<core.int> Function({List<Function> x}) Function();
+typedef F1193<T> = core.List<core.int> Function({List<Function> x}) Function(int x);
+typedef F1194<T> = core.List<core.int> Function({List<Function> x}) Function<B extends core.int>();
+typedef F1195<T> = core.List<core.int> Function({List<Function> x}) Function<B extends core.int>(int x);
+typedef F1196<T> = core.List<core.int> Function(int x0, {List<Function> x}) Function();
+typedef F1197<T> = core.List<core.int> Function(int x1, {List<Function> x}) Function(int x);
+typedef F1198<T> = core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>();
+typedef F1199<T> = core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F1200<T> = core.List<core.int> Function(int y, {List<Function> x}) Function();
+typedef F1201<T> = core.List<core.int> Function(int y, {List<Function> x}) Function(int x);
+typedef F1202<T> = core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>();
+typedef F1203<T> = core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F1204<T> = core.List<core.int> Function(core.List<core.int> x) Function();
+typedef F1205<T> = core.List<core.int> Function(core.List<core.int> x) Function(int x);
+typedef F1206<T> = core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F1207<T> = core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1208<T> = core.List<core.int> Function([core.List<core.int> x]) Function();
+typedef F1209<T> = core.List<core.int> Function([core.List<core.int> x]) Function(int x);
+typedef F1210<T> = core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>();
+typedef F1211<T> = core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1212<T> = core.List<core.int> Function(int x0, [core.List<core.int> x]) Function();
+typedef F1213<T> = core.List<core.int> Function(int x1, [core.List<core.int> x]) Function(int x);
+typedef F1214<T> = core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F1215<T> = core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1216<T> = core.List<core.int> Function(int y, [core.List<core.int> x]) Function();
+typedef F1217<T> = core.List<core.int> Function(int y, [core.List<core.int> x]) Function(int x);
+typedef F1218<T> = core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F1219<T> = core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1220<T> = core.List<core.int> Function(core.List<core.int> x0) Function();
+typedef F1221<T> = core.List<core.int> Function(core.List<core.int> x1) Function(int x);
+typedef F1222<T> = core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>();
+typedef F1223<T> = core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>(int x);
+typedef F1224<T> = core.List<core.int> Function([core.List<core.int> x1]) Function();
+typedef F1225<T> = core.List<core.int> Function([core.List<core.int> x1]) Function(int x);
+typedef F1226<T> = core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1227<T> = core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1228<T> = core.List<core.int> Function(int x1, [core.List<core.int> x2]) Function();
+typedef F1229<T> = core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function(int x);
+typedef F1230<T> = core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>();
+typedef F1231<T> = core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x);
+typedef F1232<T> = core.List<core.int> Function(int x, [core.List<core.int> x2]) Function();
+typedef F1233<T> = core.List<core.int> Function(int x, [core.List<core.int> x1]) Function(int x);
+typedef F1234<T> = core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1235<T> = core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1236<T> = core.List<core.int> Function({core.List<core.int> x}) Function();
+typedef F1237<T> = core.List<core.int> Function({core.List<core.int> x}) Function(int x);
+typedef F1238<T> = core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>();
+typedef F1239<T> = core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1240<T> = core.List<core.int> Function(int x0, {core.List<core.int> x}) Function();
+typedef F1241<T> = core.List<core.int> Function(int x1, {core.List<core.int> x}) Function(int x);
+typedef F1242<T> = core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1243<T> = core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1244<T> = core.List<core.int> Function(int y, {core.List<core.int> x}) Function();
+typedef F1245<T> = core.List<core.int> Function(int y, {core.List<core.int> x}) Function(int x);
+typedef F1246<T> = core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1247<T> = core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1248<T> = core.List<core.int> Function(List<T> x) Function();
+typedef F1249<T> = core.List<core.int> Function(List<T> x) Function(int x);
+typedef F1250<T> = core.List<core.int> Function(List<T> x) Function<B extends core.int>();
+typedef F1251<T> = core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x);
+typedef F1252<T> = core.List<core.int> Function([List<T> x]) Function();
+typedef F1253<T> = core.List<core.int> Function([List<T> x]) Function(int x);
+typedef F1254<T> = core.List<core.int> Function([List<T> x]) Function<B extends core.int>();
+typedef F1255<T> = core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x);
+typedef F1256<T> = core.List<core.int> Function(int x0, [List<T> x]) Function();
+typedef F1257<T> = core.List<core.int> Function(int x1, [List<T> x]) Function(int x);
+typedef F1258<T> = core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>();
+typedef F1259<T> = core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1260<T> = core.List<core.int> Function(int y, [List<T> x]) Function();
+typedef F1261<T> = core.List<core.int> Function(int y, [List<T> x]) Function(int x);
+typedef F1262<T> = core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>();
+typedef F1263<T> = core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1264<T> = core.List<core.int> Function(List<T> x0) Function();
+typedef F1265<T> = core.List<core.int> Function(List<T> x1) Function(int x);
+typedef F1266<T> = core.List<core.int> Function(List<T> x1) Function<B extends core.int>();
+typedef F1267<T> = core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x);
+typedef F1268<T> = core.List<core.int> Function([List<T> x1]) Function();
+typedef F1269<T> = core.List<core.int> Function([List<T> x1]) Function(int x);
+typedef F1270<T> = core.List<core.int> Function([List<T> x1]) Function<B extends core.int>();
+typedef F1271<T> = core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x);
+typedef F1272<T> = core.List<core.int> Function(int x1, [List<T> x2]) Function();
+typedef F1273<T> = core.List<core.int> Function(int x2, [List<T> x3]) Function(int x);
+typedef F1274<T> = core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>();
+typedef F1275<T> = core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x);
+typedef F1276<T> = core.List<core.int> Function(int x, [List<T> x2]) Function();
+typedef F1277<T> = core.List<core.int> Function(int x, [List<T> x1]) Function(int x);
+typedef F1278<T> = core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>();
+typedef F1279<T> = core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x);
+typedef F1280<T> = core.List<core.int> Function({List<T> x}) Function();
+typedef F1281<T> = core.List<core.int> Function({List<T> x}) Function(int x);
+typedef F1282<T> = core.List<core.int> Function({List<T> x}) Function<B extends core.int>();
+typedef F1283<T> = core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x);
+typedef F1284<T> = core.List<core.int> Function(int x0, {List<T> x}) Function();
+typedef F1285<T> = core.List<core.int> Function(int x1, {List<T> x}) Function(int x);
+typedef F1286<T> = core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>();
+typedef F1287<T> = core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1288<T> = core.List<core.int> Function(int y, {List<T> x}) Function();
+typedef F1289<T> = core.List<core.int> Function(int y, {List<T> x}) Function(int x);
+typedef F1290<T> = core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>();
+typedef F1291<T> = core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1292<T> = core.List<core.int> Function() Function();
+typedef F1293<T> = core.List<core.int> Function() Function(int x);
+typedef F1294<T> = core.List<core.int> Function() Function<B extends core.int>();
+typedef F1295<T> = core.List<core.int> Function() Function<B extends core.int>(int x);
+typedef F1296<T> = List<T> Function(int x) Function();
+typedef F1297<T> = List<T> Function(int x) Function(int x);
+typedef F1298<T> = List<T> Function(int x) Function<B extends core.int>();
+typedef F1299<T> = List<T> Function(int x) Function<B extends core.int>(int x);
+typedef F1300<T> = List<T> Function([int x]) Function();
+typedef F1301<T> = List<T> Function([int x]) Function(int x);
+typedef F1302<T> = List<T> Function([int x]) Function<B extends core.int>();
+typedef F1303<T> = List<T> Function([int x]) Function<B extends core.int>(int x);
+typedef F1304<T> = List<T> Function(int x0, [int x]) Function();
+typedef F1305<T> = List<T> Function(int x1, [int x]) Function(int x);
+typedef F1306<T> = List<T> Function(int x1, [int x]) Function<B extends core.int>();
+typedef F1307<T> = List<T> Function(int x1, [int x]) Function<B extends core.int>(int x);
+typedef F1308<T> = List<T> Function(int y, [int x]) Function();
+typedef F1309<T> = List<T> Function(int y, [int x]) Function(int x);
+typedef F1310<T> = List<T> Function(int y, [int x]) Function<B extends core.int>();
+typedef F1311<T> = List<T> Function(int y, [int x]) Function<B extends core.int>(int x);
+typedef F1312<T> = List<T> Function(int x0) Function();
+typedef F1313<T> = List<T> Function(int x1) Function(int x);
+typedef F1314<T> = List<T> Function(int x1) Function<B extends core.int>();
+typedef F1315<T> = List<T> Function(int x1) Function<B extends core.int>(int x);
+typedef F1316<T> = List<T> Function([int x1]) Function();
+typedef F1317<T> = List<T> Function([int x1]) Function(int x);
+typedef F1318<T> = List<T> Function([int x1]) Function<B extends core.int>();
+typedef F1319<T> = List<T> Function([int x1]) Function<B extends core.int>(int x);
+typedef F1320<T> = List<T> Function(int x1, [int x2]) Function();
+typedef F1321<T> = List<T> Function(int x2, [int x3]) Function(int x);
+typedef F1322<T> = List<T> Function(int x2, [int x3]) Function<B extends core.int>();
+typedef F1323<T> = List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x);
+typedef F1324<T> = List<T> Function(int x, [int x2]) Function();
+typedef F1325<T> = List<T> Function(int x, [int x1]) Function(int x);
+typedef F1326<T> = List<T> Function(int x, [int x1]) Function<B extends core.int>();
+typedef F1327<T> = List<T> Function(int x, [int x1]) Function<B extends core.int>(int x);
+typedef F1328<T> = List<T> Function({int x}) Function();
+typedef F1329<T> = List<T> Function({int x}) Function(int x);
+typedef F1330<T> = List<T> Function({int x}) Function<B extends core.int>();
+typedef F1331<T> = List<T> Function({int x}) Function<B extends core.int>(int x);
+typedef F1332<T> = List<T> Function(int x0, {int x}) Function();
+typedef F1333<T> = List<T> Function(int x1, {int x}) Function(int x);
+typedef F1334<T> = List<T> Function(int x1, {int x}) Function<B extends core.int>();
+typedef F1335<T> = List<T> Function(int x1, {int x}) Function<B extends core.int>(int x);
+typedef F1336<T> = List<T> Function(int y, {int x}) Function();
+typedef F1337<T> = List<T> Function(int y, {int x}) Function(int x);
+typedef F1338<T> = List<T> Function(int y, {int x}) Function<B extends core.int>();
+typedef F1339<T> = List<T> Function(int y, {int x}) Function<B extends core.int>(int x);
+typedef F1340<T> = List<T> Function(Function x) Function();
+typedef F1341<T> = List<T> Function(Function x) Function(int x);
+typedef F1342<T> = List<T> Function(Function x) Function<B extends core.int>();
+typedef F1343<T> = List<T> Function(Function x) Function<B extends core.int>(int x);
+typedef F1344<T> = List<T> Function([Function x]) Function();
+typedef F1345<T> = List<T> Function([Function x]) Function(int x);
+typedef F1346<T> = List<T> Function([Function x]) Function<B extends core.int>();
+typedef F1347<T> = List<T> Function([Function x]) Function<B extends core.int>(int x);
+typedef F1348<T> = List<T> Function(int x0, [Function x]) Function();
+typedef F1349<T> = List<T> Function(int x1, [Function x]) Function(int x);
+typedef F1350<T> = List<T> Function(int x1, [Function x]) Function<B extends core.int>();
+typedef F1351<T> = List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x);
+typedef F1352<T> = List<T> Function(int y, [Function x]) Function();
+typedef F1353<T> = List<T> Function(int y, [Function x]) Function(int x);
+typedef F1354<T> = List<T> Function(int y, [Function x]) Function<B extends core.int>();
+typedef F1355<T> = List<T> Function(int y, [Function x]) Function<B extends core.int>(int x);
+typedef F1356<T> = List<T> Function(Function x0) Function();
+typedef F1357<T> = List<T> Function(Function x1) Function(int x);
+typedef F1358<T> = List<T> Function(Function x1) Function<B extends core.int>();
+typedef F1359<T> = List<T> Function(Function x1) Function<B extends core.int>(int x);
+typedef F1360<T> = List<T> Function([Function x1]) Function();
+typedef F1361<T> = List<T> Function([Function x1]) Function(int x);
+typedef F1362<T> = List<T> Function([Function x1]) Function<B extends core.int>();
+typedef F1363<T> = List<T> Function([Function x1]) Function<B extends core.int>(int x);
+typedef F1364<T> = List<T> Function(int x1, [Function x2]) Function();
+typedef F1365<T> = List<T> Function(int x2, [Function x3]) Function(int x);
+typedef F1366<T> = List<T> Function(int x2, [Function x3]) Function<B extends core.int>();
+typedef F1367<T> = List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x);
+typedef F1368<T> = List<T> Function(int x, [Function x2]) Function();
+typedef F1369<T> = List<T> Function(int x, [Function x1]) Function(int x);
+typedef F1370<T> = List<T> Function(int x, [Function x1]) Function<B extends core.int>();
+typedef F1371<T> = List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x);
+typedef F1372<T> = List<T> Function({Function x}) Function();
+typedef F1373<T> = List<T> Function({Function x}) Function(int x);
+typedef F1374<T> = List<T> Function({Function x}) Function<B extends core.int>();
+typedef F1375<T> = List<T> Function({Function x}) Function<B extends core.int>(int x);
+typedef F1376<T> = List<T> Function(int x0, {Function x}) Function();
+typedef F1377<T> = List<T> Function(int x1, {Function x}) Function(int x);
+typedef F1378<T> = List<T> Function(int x1, {Function x}) Function<B extends core.int>();
+typedef F1379<T> = List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x);
+typedef F1380<T> = List<T> Function(int y, {Function x}) Function();
+typedef F1381<T> = List<T> Function(int y, {Function x}) Function(int x);
+typedef F1382<T> = List<T> Function(int y, {Function x}) Function<B extends core.int>();
+typedef F1383<T> = List<T> Function(int y, {Function x}) Function<B extends core.int>(int x);
+typedef F1384<T> = List<T> Function(List<Function> x) Function();
+typedef F1385<T> = List<T> Function(List<Function> x) Function(int x);
+typedef F1386<T> = List<T> Function(List<Function> x) Function<B extends core.int>();
+typedef F1387<T> = List<T> Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F1388<T> = List<T> Function([List<Function> x]) Function();
+typedef F1389<T> = List<T> Function([List<Function> x]) Function(int x);
+typedef F1390<T> = List<T> Function([List<Function> x]) Function<B extends core.int>();
+typedef F1391<T> = List<T> Function([List<Function> x]) Function<B extends core.int>(int x);
+typedef F1392<T> = List<T> Function(int x0, [List<Function> x]) Function();
+typedef F1393<T> = List<T> Function(int x1, [List<Function> x]) Function(int x);
+typedef F1394<T> = List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>();
+typedef F1395<T> = List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F1396<T> = List<T> Function(int y, [List<Function> x]) Function();
+typedef F1397<T> = List<T> Function(int y, [List<Function> x]) Function(int x);
+typedef F1398<T> = List<T> Function(int y, [List<Function> x]) Function<B extends core.int>();
+typedef F1399<T> = List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F1400<T> = List<T> Function(List<Function> x0) Function();
+typedef F1401<T> = List<T> Function(List<Function> x1) Function(int x);
+typedef F1402<T> = List<T> Function(List<Function> x1) Function<B extends core.int>();
+typedef F1403<T> = List<T> Function(List<Function> x1) Function<B extends core.int>(int x);
+typedef F1404<T> = List<T> Function([List<Function> x1]) Function();
+typedef F1405<T> = List<T> Function([List<Function> x1]) Function(int x);
+typedef F1406<T> = List<T> Function([List<Function> x1]) Function<B extends core.int>();
+typedef F1407<T> = List<T> Function([List<Function> x1]) Function<B extends core.int>(int x);
+typedef F1408<T> = List<T> Function(int x1, [List<Function> x2]) Function();
+typedef F1409<T> = List<T> Function(int x2, [List<Function> x3]) Function(int x);
+typedef F1410<T> = List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>();
+typedef F1411<T> = List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x);
+typedef F1412<T> = List<T> Function(int x, [List<Function> x2]) Function();
+typedef F1413<T> = List<T> Function(int x, [List<Function> x1]) Function(int x);
+typedef F1414<T> = List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>();
+typedef F1415<T> = List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x);
+typedef F1416<T> = List<T> Function({List<Function> x}) Function();
+typedef F1417<T> = List<T> Function({List<Function> x}) Function(int x);
+typedef F1418<T> = List<T> Function({List<Function> x}) Function<B extends core.int>();
+typedef F1419<T> = List<T> Function({List<Function> x}) Function<B extends core.int>(int x);
+typedef F1420<T> = List<T> Function(int x0, {List<Function> x}) Function();
+typedef F1421<T> = List<T> Function(int x1, {List<Function> x}) Function(int x);
+typedef F1422<T> = List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>();
+typedef F1423<T> = List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F1424<T> = List<T> Function(int y, {List<Function> x}) Function();
+typedef F1425<T> = List<T> Function(int y, {List<Function> x}) Function(int x);
+typedef F1426<T> = List<T> Function(int y, {List<Function> x}) Function<B extends core.int>();
+typedef F1427<T> = List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F1428<T> = List<T> Function(core.List<core.int> x) Function();
+typedef F1429<T> = List<T> Function(core.List<core.int> x) Function(int x);
+typedef F1430<T> = List<T> Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F1431<T> = List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1432<T> = List<T> Function([core.List<core.int> x]) Function();
+typedef F1433<T> = List<T> Function([core.List<core.int> x]) Function(int x);
+typedef F1434<T> = List<T> Function([core.List<core.int> x]) Function<B extends core.int>();
+typedef F1435<T> = List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1436<T> = List<T> Function(int x0, [core.List<core.int> x]) Function();
+typedef F1437<T> = List<T> Function(int x1, [core.List<core.int> x]) Function(int x);
+typedef F1438<T> = List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F1439<T> = List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1440<T> = List<T> Function(int y, [core.List<core.int> x]) Function();
+typedef F1441<T> = List<T> Function(int y, [core.List<core.int> x]) Function(int x);
+typedef F1442<T> = List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F1443<T> = List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1444<T> = List<T> Function(core.List<core.int> x0) Function();
+typedef F1445<T> = List<T> Function(core.List<core.int> x1) Function(int x);
+typedef F1446<T> = List<T> Function(core.List<core.int> x1) Function<B extends core.int>();
+typedef F1447<T> = List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x);
+typedef F1448<T> = List<T> Function([core.List<core.int> x1]) Function();
+typedef F1449<T> = List<T> Function([core.List<core.int> x1]) Function(int x);
+typedef F1450<T> = List<T> Function([core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1451<T> = List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1452<T> = List<T> Function(int x1, [core.List<core.int> x2]) Function();
+typedef F1453<T> = List<T> Function(int x2, [core.List<core.int> x3]) Function(int x);
+typedef F1454<T> = List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>();
+typedef F1455<T> = List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x);
+typedef F1456<T> = List<T> Function(int x, [core.List<core.int> x2]) Function();
+typedef F1457<T> = List<T> Function(int x, [core.List<core.int> x1]) Function(int x);
+typedef F1458<T> = List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1459<T> = List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1460<T> = List<T> Function({core.List<core.int> x}) Function();
+typedef F1461<T> = List<T> Function({core.List<core.int> x}) Function(int x);
+typedef F1462<T> = List<T> Function({core.List<core.int> x}) Function<B extends core.int>();
+typedef F1463<T> = List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1464<T> = List<T> Function(int x0, {core.List<core.int> x}) Function();
+typedef F1465<T> = List<T> Function(int x1, {core.List<core.int> x}) Function(int x);
+typedef F1466<T> = List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1467<T> = List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1468<T> = List<T> Function(int y, {core.List<core.int> x}) Function();
+typedef F1469<T> = List<T> Function(int y, {core.List<core.int> x}) Function(int x);
+typedef F1470<T> = List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1471<T> = List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1472<T> = List<T> Function(List<T> x) Function();
+typedef F1473<T> = List<T> Function(List<T> x) Function(int x);
+typedef F1474<T> = List<T> Function(List<T> x) Function<B extends core.int>();
+typedef F1475<T> = List<T> Function(List<T> x) Function<B extends core.int>(int x);
+typedef F1476<T> = List<T> Function([List<T> x]) Function();
+typedef F1477<T> = List<T> Function([List<T> x]) Function(int x);
+typedef F1478<T> = List<T> Function([List<T> x]) Function<B extends core.int>();
+typedef F1479<T> = List<T> Function([List<T> x]) Function<B extends core.int>(int x);
+typedef F1480<T> = List<T> Function(int x0, [List<T> x]) Function();
+typedef F1481<T> = List<T> Function(int x1, [List<T> x]) Function(int x);
+typedef F1482<T> = List<T> Function(int x1, [List<T> x]) Function<B extends core.int>();
+typedef F1483<T> = List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1484<T> = List<T> Function(int y, [List<T> x]) Function();
+typedef F1485<T> = List<T> Function(int y, [List<T> x]) Function(int x);
+typedef F1486<T> = List<T> Function(int y, [List<T> x]) Function<B extends core.int>();
+typedef F1487<T> = List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1488<T> = List<T> Function(List<T> x0) Function();
+typedef F1489<T> = List<T> Function(List<T> x1) Function(int x);
+typedef F1490<T> = List<T> Function(List<T> x1) Function<B extends core.int>();
+typedef F1491<T> = List<T> Function(List<T> x1) Function<B extends core.int>(int x);
+typedef F1492<T> = List<T> Function([List<T> x1]) Function();
+typedef F1493<T> = List<T> Function([List<T> x1]) Function(int x);
+typedef F1494<T> = List<T> Function([List<T> x1]) Function<B extends core.int>();
+typedef F1495<T> = List<T> Function([List<T> x1]) Function<B extends core.int>(int x);
+typedef F1496<T> = List<T> Function(int x1, [List<T> x2]) Function();
+typedef F1497<T> = List<T> Function(int x2, [List<T> x3]) Function(int x);
+typedef F1498<T> = List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>();
+typedef F1499<T> = List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x);
+typedef F1500<T> = List<T> Function(int x, [List<T> x2]) Function();
+typedef F1501<T> = List<T> Function(int x, [List<T> x1]) Function(int x);
+typedef F1502<T> = List<T> Function(int x, [List<T> x1]) Function<B extends core.int>();
+typedef F1503<T> = List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x);
+typedef F1504<T> = List<T> Function({List<T> x}) Function();
+typedef F1505<T> = List<T> Function({List<T> x}) Function(int x);
+typedef F1506<T> = List<T> Function({List<T> x}) Function<B extends core.int>();
+typedef F1507<T> = List<T> Function({List<T> x}) Function<B extends core.int>(int x);
+typedef F1508<T> = List<T> Function(int x0, {List<T> x}) Function();
+typedef F1509<T> = List<T> Function(int x1, {List<T> x}) Function(int x);
+typedef F1510<T> = List<T> Function(int x1, {List<T> x}) Function<B extends core.int>();
+typedef F1511<T> = List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1512<T> = List<T> Function(int y, {List<T> x}) Function();
+typedef F1513<T> = List<T> Function(int y, {List<T> x}) Function(int x);
+typedef F1514<T> = List<T> Function(int y, {List<T> x}) Function<B extends core.int>();
+typedef F1515<T> = List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1516<T> = List<T> Function() Function();
+typedef F1517<T> = List<T> Function() Function(int x);
+typedef F1518<T> = List<T> Function() Function<B extends core.int>();
+typedef F1519<T> = List<T> Function() Function<B extends core.int>(int x);
+typedef F1520<T> = Function(int x) Function();
+typedef F1521<T> = Function(int x) Function(int x);
+typedef F1522<T> = Function(int x) Function<B extends core.int>();
+typedef F1523<T> = Function(int x) Function<B extends core.int>(int x);
+typedef F1524<T> = Function([int x]) Function();
+typedef F1525<T> = Function([int x]) Function(int x);
+typedef F1526<T> = Function([int x]) Function<B extends core.int>();
+typedef F1527<T> = Function([int x]) Function<B extends core.int>(int x);
+typedef F1528<T> = Function(int x0, [int x]) Function();
+typedef F1529<T> = Function(int x1, [int x]) Function(int x);
+typedef F1530<T> = Function(int x1, [int x]) Function<B extends core.int>();
+typedef F1531<T> = Function(int x1, [int x]) Function<B extends core.int>(int x);
+typedef F1532<T> = Function(int y, [int x]) Function();
+typedef F1533<T> = Function(int y, [int x]) Function(int x);
+typedef F1534<T> = Function(int y, [int x]) Function<B extends core.int>();
+typedef F1535<T> = Function(int y, [int x]) Function<B extends core.int>(int x);
+typedef F1536<T> = Function(int x0) Function();
+typedef F1537<T> = Function(int x1) Function(int x);
+typedef F1538<T> = Function(int x1) Function<B extends core.int>();
+typedef F1539<T> = Function(int x1) Function<B extends core.int>(int x);
+typedef F1540<T> = Function([int x1]) Function();
+typedef F1541<T> = Function([int x1]) Function(int x);
+typedef F1542<T> = Function([int x1]) Function<B extends core.int>();
+typedef F1543<T> = Function([int x1]) Function<B extends core.int>(int x);
+typedef F1544<T> = Function(int x1, [int x2]) Function();
+typedef F1545<T> = Function(int x2, [int x3]) Function(int x);
+typedef F1546<T> = Function(int x2, [int x3]) Function<B extends core.int>();
+typedef F1547<T> = Function(int x2, [int x3]) Function<B extends core.int>(int x);
+typedef F1548<T> = Function(int x, [int x2]) Function();
+typedef F1549<T> = Function(int x, [int x1]) Function(int x);
+typedef F1550<T> = Function(int x, [int x1]) Function<B extends core.int>();
+typedef F1551<T> = Function(int x, [int x1]) Function<B extends core.int>(int x);
+typedef F1552<T> = Function({int x}) Function();
+typedef F1553<T> = Function({int x}) Function(int x);
+typedef F1554<T> = Function({int x}) Function<B extends core.int>();
+typedef F1555<T> = Function({int x}) Function<B extends core.int>(int x);
+typedef F1556<T> = Function(int x0, {int x}) Function();
+typedef F1557<T> = Function(int x1, {int x}) Function(int x);
+typedef F1558<T> = Function(int x1, {int x}) Function<B extends core.int>();
+typedef F1559<T> = Function(int x1, {int x}) Function<B extends core.int>(int x);
+typedef F1560<T> = Function(int y, {int x}) Function();
+typedef F1561<T> = Function(int y, {int x}) Function(int x);
+typedef F1562<T> = Function(int y, {int x}) Function<B extends core.int>();
+typedef F1563<T> = Function(int y, {int x}) Function<B extends core.int>(int x);
+typedef F1564<T> = Function(Function x) Function();
+typedef F1565<T> = Function(Function x) Function(int x);
+typedef F1566<T> = Function(Function x) Function<B extends core.int>();
+typedef F1567<T> = Function(Function x) Function<B extends core.int>(int x);
+typedef F1568<T> = Function([Function x]) Function();
+typedef F1569<T> = Function([Function x]) Function(int x);
+typedef F1570<T> = Function([Function x]) Function<B extends core.int>();
+typedef F1571<T> = Function([Function x]) Function<B extends core.int>(int x);
+typedef F1572<T> = Function(int x0, [Function x]) Function();
+typedef F1573<T> = Function(int x1, [Function x]) Function(int x);
+typedef F1574<T> = Function(int x1, [Function x]) Function<B extends core.int>();
+typedef F1575<T> = Function(int x1, [Function x]) Function<B extends core.int>(int x);
+typedef F1576<T> = Function(int y, [Function x]) Function();
+typedef F1577<T> = Function(int y, [Function x]) Function(int x);
+typedef F1578<T> = Function(int y, [Function x]) Function<B extends core.int>();
+typedef F1579<T> = Function(int y, [Function x]) Function<B extends core.int>(int x);
+typedef F1580<T> = Function(Function x0) Function();
+typedef F1581<T> = Function(Function x1) Function(int x);
+typedef F1582<T> = Function(Function x1) Function<B extends core.int>();
+typedef F1583<T> = Function(Function x1) Function<B extends core.int>(int x);
+typedef F1584<T> = Function([Function x1]) Function();
+typedef F1585<T> = Function([Function x1]) Function(int x);
+typedef F1586<T> = Function([Function x1]) Function<B extends core.int>();
+typedef F1587<T> = Function([Function x1]) Function<B extends core.int>(int x);
+typedef F1588<T> = Function(int x1, [Function x2]) Function();
+typedef F1589<T> = Function(int x2, [Function x3]) Function(int x);
+typedef F1590<T> = Function(int x2, [Function x3]) Function<B extends core.int>();
+typedef F1591<T> = Function(int x2, [Function x3]) Function<B extends core.int>(int x);
+typedef F1592<T> = Function(int x, [Function x2]) Function();
+typedef F1593<T> = Function(int x, [Function x1]) Function(int x);
+typedef F1594<T> = Function(int x, [Function x1]) Function<B extends core.int>();
+typedef F1595<T> = Function(int x, [Function x1]) Function<B extends core.int>(int x);
+typedef F1596<T> = Function({Function x}) Function();
+typedef F1597<T> = Function({Function x}) Function(int x);
+typedef F1598<T> = Function({Function x}) Function<B extends core.int>();
+typedef F1599<T> = Function({Function x}) Function<B extends core.int>(int x);
+typedef F1600<T> = Function(int x0, {Function x}) Function();
+typedef F1601<T> = Function(int x1, {Function x}) Function(int x);
+typedef F1602<T> = Function(int x1, {Function x}) Function<B extends core.int>();
+typedef F1603<T> = Function(int x1, {Function x}) Function<B extends core.int>(int x);
+typedef F1604<T> = Function(int y, {Function x}) Function();
+typedef F1605<T> = Function(int y, {Function x}) Function(int x);
+typedef F1606<T> = Function(int y, {Function x}) Function<B extends core.int>();
+typedef F1607<T> = Function(int y, {Function x}) Function<B extends core.int>(int x);
+typedef F1608<T> = Function(List<Function> x) Function();
+typedef F1609<T> = Function(List<Function> x) Function(int x);
+typedef F1610<T> = Function(List<Function> x) Function<B extends core.int>();
+typedef F1611<T> = Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F1612<T> = Function([List<Function> x]) Function();
+typedef F1613<T> = Function([List<Function> x]) Function(int x);
+typedef F1614<T> = Function([List<Function> x]) Function<B extends core.int>();
+typedef F1615<T> = Function([List<Function> x]) Function<B extends core.int>(int x);
+typedef F1616<T> = Function(int x0, [List<Function> x]) Function();
+typedef F1617<T> = Function(int x1, [List<Function> x]) Function(int x);
+typedef F1618<T> = Function(int x1, [List<Function> x]) Function<B extends core.int>();
+typedef F1619<T> = Function(int x1, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F1620<T> = Function(int y, [List<Function> x]) Function();
+typedef F1621<T> = Function(int y, [List<Function> x]) Function(int x);
+typedef F1622<T> = Function(int y, [List<Function> x]) Function<B extends core.int>();
+typedef F1623<T> = Function(int y, [List<Function> x]) Function<B extends core.int>(int x);
+typedef F1624<T> = Function(List<Function> x0) Function();
+typedef F1625<T> = Function(List<Function> x1) Function(int x);
+typedef F1626<T> = Function(List<Function> x1) Function<B extends core.int>();
+typedef F1627<T> = Function(List<Function> x1) Function<B extends core.int>(int x);
+typedef F1628<T> = Function([List<Function> x1]) Function();
+typedef F1629<T> = Function([List<Function> x1]) Function(int x);
+typedef F1630<T> = Function([List<Function> x1]) Function<B extends core.int>();
+typedef F1631<T> = Function([List<Function> x1]) Function<B extends core.int>(int x);
+typedef F1632<T> = Function(int x1, [List<Function> x2]) Function();
+typedef F1633<T> = Function(int x2, [List<Function> x3]) Function(int x);
+typedef F1634<T> = Function(int x2, [List<Function> x3]) Function<B extends core.int>();
+typedef F1635<T> = Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x);
+typedef F1636<T> = Function(int x, [List<Function> x2]) Function();
+typedef F1637<T> = Function(int x, [List<Function> x1]) Function(int x);
+typedef F1638<T> = Function(int x, [List<Function> x1]) Function<B extends core.int>();
+typedef F1639<T> = Function(int x, [List<Function> x1]) Function<B extends core.int>(int x);
+typedef F1640<T> = Function({List<Function> x}) Function();
+typedef F1641<T> = Function({List<Function> x}) Function(int x);
+typedef F1642<T> = Function({List<Function> x}) Function<B extends core.int>();
+typedef F1643<T> = Function({List<Function> x}) Function<B extends core.int>(int x);
+typedef F1644<T> = Function(int x0, {List<Function> x}) Function();
+typedef F1645<T> = Function(int x1, {List<Function> x}) Function(int x);
+typedef F1646<T> = Function(int x1, {List<Function> x}) Function<B extends core.int>();
+typedef F1647<T> = Function(int x1, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F1648<T> = Function(int y, {List<Function> x}) Function();
+typedef F1649<T> = Function(int y, {List<Function> x}) Function(int x);
+typedef F1650<T> = Function(int y, {List<Function> x}) Function<B extends core.int>();
+typedef F1651<T> = Function(int y, {List<Function> x}) Function<B extends core.int>(int x);
+typedef F1652<T> = Function(core.List<core.int> x) Function();
+typedef F1653<T> = Function(core.List<core.int> x) Function(int x);
+typedef F1654<T> = Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F1655<T> = Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1656<T> = Function([core.List<core.int> x]) Function();
+typedef F1657<T> = Function([core.List<core.int> x]) Function(int x);
+typedef F1658<T> = Function([core.List<core.int> x]) Function<B extends core.int>();
+typedef F1659<T> = Function([core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1660<T> = Function(int x0, [core.List<core.int> x]) Function();
+typedef F1661<T> = Function(int x1, [core.List<core.int> x]) Function(int x);
+typedef F1662<T> = Function(int x1, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F1663<T> = Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1664<T> = Function(int y, [core.List<core.int> x]) Function();
+typedef F1665<T> = Function(int y, [core.List<core.int> x]) Function(int x);
+typedef F1666<T> = Function(int y, [core.List<core.int> x]) Function<B extends core.int>();
+typedef F1667<T> = Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x);
+typedef F1668<T> = Function(core.List<core.int> x0) Function();
+typedef F1669<T> = Function(core.List<core.int> x1) Function(int x);
+typedef F1670<T> = Function(core.List<core.int> x1) Function<B extends core.int>();
+typedef F1671<T> = Function(core.List<core.int> x1) Function<B extends core.int>(int x);
+typedef F1672<T> = Function([core.List<core.int> x1]) Function();
+typedef F1673<T> = Function([core.List<core.int> x1]) Function(int x);
+typedef F1674<T> = Function([core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1675<T> = Function([core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1676<T> = Function(int x1, [core.List<core.int> x2]) Function();
+typedef F1677<T> = Function(int x2, [core.List<core.int> x3]) Function(int x);
+typedef F1678<T> = Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>();
+typedef F1679<T> = Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x);
+typedef F1680<T> = Function(int x, [core.List<core.int> x2]) Function();
+typedef F1681<T> = Function(int x, [core.List<core.int> x1]) Function(int x);
+typedef F1682<T> = Function(int x, [core.List<core.int> x1]) Function<B extends core.int>();
+typedef F1683<T> = Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x);
+typedef F1684<T> = Function({core.List<core.int> x}) Function();
+typedef F1685<T> = Function({core.List<core.int> x}) Function(int x);
+typedef F1686<T> = Function({core.List<core.int> x}) Function<B extends core.int>();
+typedef F1687<T> = Function({core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1688<T> = Function(int x0, {core.List<core.int> x}) Function();
+typedef F1689<T> = Function(int x1, {core.List<core.int> x}) Function(int x);
+typedef F1690<T> = Function(int x1, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1691<T> = Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1692<T> = Function(int y, {core.List<core.int> x}) Function();
+typedef F1693<T> = Function(int y, {core.List<core.int> x}) Function(int x);
+typedef F1694<T> = Function(int y, {core.List<core.int> x}) Function<B extends core.int>();
+typedef F1695<T> = Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x);
+typedef F1696<T> = Function(List<T> x) Function();
+typedef F1697<T> = Function(List<T> x) Function(int x);
+typedef F1698<T> = Function(List<T> x) Function<B extends core.int>();
+typedef F1699<T> = Function(List<T> x) Function<B extends core.int>(int x);
+typedef F1700<T> = Function([List<T> x]) Function();
+typedef F1701<T> = Function([List<T> x]) Function(int x);
+typedef F1702<T> = Function([List<T> x]) Function<B extends core.int>();
+typedef F1703<T> = Function([List<T> x]) Function<B extends core.int>(int x);
+typedef F1704<T> = Function(int x0, [List<T> x]) Function();
+typedef F1705<T> = Function(int x1, [List<T> x]) Function(int x);
+typedef F1706<T> = Function(int x1, [List<T> x]) Function<B extends core.int>();
+typedef F1707<T> = Function(int x1, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1708<T> = Function(int y, [List<T> x]) Function();
+typedef F1709<T> = Function(int y, [List<T> x]) Function(int x);
+typedef F1710<T> = Function(int y, [List<T> x]) Function<B extends core.int>();
+typedef F1711<T> = Function(int y, [List<T> x]) Function<B extends core.int>(int x);
+typedef F1712<T> = Function(List<T> x0) Function();
+typedef F1713<T> = Function(List<T> x1) Function(int x);
+typedef F1714<T> = Function(List<T> x1) Function<B extends core.int>();
+typedef F1715<T> = Function(List<T> x1) Function<B extends core.int>(int x);
+typedef F1716<T> = Function([List<T> x1]) Function();
+typedef F1717<T> = Function([List<T> x1]) Function(int x);
+typedef F1718<T> = Function([List<T> x1]) Function<B extends core.int>();
+typedef F1719<T> = Function([List<T> x1]) Function<B extends core.int>(int x);
+typedef F1720<T> = Function(int x1, [List<T> x2]) Function();
+typedef F1721<T> = Function(int x2, [List<T> x3]) Function(int x);
+typedef F1722<T> = Function(int x2, [List<T> x3]) Function<B extends core.int>();
+typedef F1723<T> = Function(int x2, [List<T> x3]) Function<B extends core.int>(int x);
+typedef F1724<T> = Function(int x, [List<T> x2]) Function();
+typedef F1725<T> = Function(int x, [List<T> x1]) Function(int x);
+typedef F1726<T> = Function(int x, [List<T> x1]) Function<B extends core.int>();
+typedef F1727<T> = Function(int x, [List<T> x1]) Function<B extends core.int>(int x);
+typedef F1728<T> = Function({List<T> x}) Function();
+typedef F1729<T> = Function({List<T> x}) Function(int x);
+typedef F1730<T> = Function({List<T> x}) Function<B extends core.int>();
+typedef F1731<T> = Function({List<T> x}) Function<B extends core.int>(int x);
+typedef F1732<T> = Function(int x0, {List<T> x}) Function();
+typedef F1733<T> = Function(int x1, {List<T> x}) Function(int x);
+typedef F1734<T> = Function(int x1, {List<T> x}) Function<B extends core.int>();
+typedef F1735<T> = Function(int x1, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1736<T> = Function(int y, {List<T> x}) Function();
+typedef F1737<T> = Function(int y, {List<T> x}) Function(int x);
+typedef F1738<T> = Function(int y, {List<T> x}) Function<B extends core.int>();
+typedef F1739<T> = Function(int y, {List<T> x}) Function<B extends core.int>(int x);
+typedef F1740<T> = Function() Function();
+typedef F1741<T> = Function() Function(int x);
+typedef F1742<T> = Function() Function<B extends core.int>();
+typedef F1743<T> = Function() Function<B extends core.int>(int x);
+typedef F1744<T> = int Function<A>(int x) Function();
+typedef F1745<T> = int Function<A>(int x) Function(int x);
+typedef F1746<T> = int Function<A>(int x) Function<B extends core.int>();
+typedef F1747<T> = int Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1748<T> = int Function<A>(Function x) Function();
+typedef F1749<T> = int Function<A>(Function x) Function(int x);
+typedef F1750<T> = int Function<A>(Function x) Function<B extends core.int>();
+typedef F1751<T> = int Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1752<T> = int Function<A>(List<Function> x) Function();
+typedef F1753<T> = int Function<A>(List<Function> x) Function(int x);
+typedef F1754<T> = int Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1755<T> = int Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1756<T> = int Function<A>(core.List<core.int> x) Function();
+typedef F1757<T> = int Function<A>(core.List<core.int> x) Function(int x);
+typedef F1758<T> = int Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1759<T> = int Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1760<T> = int Function<A>(List<T> x) Function();
+typedef F1761<T> = int Function<A>(List<T> x) Function(int x);
+typedef F1762<T> = int Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1763<T> = int Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1764<T> = int Function<A>() Function();
+typedef F1765<T> = int Function<A>() Function(int x);
+typedef F1766<T> = int Function<A>() Function<B extends core.int>();
+typedef F1767<T> = int Function<A>() Function<B extends core.int>(int x);
+typedef F1768<T> = int Function<A>(A x) Function();
+typedef F1769<T> = int Function<A>(A x) Function(int x);
+typedef F1770<T> = int Function<A>(A x) Function<B extends core.int>();
+typedef F1771<T> = int Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1772<T> = int Function<A>(List<A> x) Function();
+typedef F1773<T> = int Function<A>(List<A> x) Function(int x);
+typedef F1774<T> = int Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1775<T> = int Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1776<T> = Function Function<A>(int x) Function();
+typedef F1777<T> = Function Function<A>(int x) Function(int x);
+typedef F1778<T> = Function Function<A>(int x) Function<B extends core.int>();
+typedef F1779<T> = Function Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1780<T> = Function Function<A>(Function x) Function();
+typedef F1781<T> = Function Function<A>(Function x) Function(int x);
+typedef F1782<T> = Function Function<A>(Function x) Function<B extends core.int>();
+typedef F1783<T> = Function Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1784<T> = Function Function<A>(List<Function> x) Function();
+typedef F1785<T> = Function Function<A>(List<Function> x) Function(int x);
+typedef F1786<T> = Function Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1787<T> = Function Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1788<T> = Function Function<A>(core.List<core.int> x) Function();
+typedef F1789<T> = Function Function<A>(core.List<core.int> x) Function(int x);
+typedef F1790<T> = Function Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1791<T> = Function Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1792<T> = Function Function<A>(List<T> x) Function();
+typedef F1793<T> = Function Function<A>(List<T> x) Function(int x);
+typedef F1794<T> = Function Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1795<T> = Function Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1796<T> = Function Function<A>() Function();
+typedef F1797<T> = Function Function<A>() Function(int x);
+typedef F1798<T> = Function Function<A>() Function<B extends core.int>();
+typedef F1799<T> = Function Function<A>() Function<B extends core.int>(int x);
+typedef F1800<T> = Function Function<A>(A x) Function();
+typedef F1801<T> = Function Function<A>(A x) Function(int x);
+typedef F1802<T> = Function Function<A>(A x) Function<B extends core.int>();
+typedef F1803<T> = Function Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1804<T> = Function Function<A>(List<A> x) Function();
+typedef F1805<T> = Function Function<A>(List<A> x) Function(int x);
+typedef F1806<T> = Function Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1807<T> = Function Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1808<T> = List<Function> Function<A>(int x) Function();
+typedef F1809<T> = List<Function> Function<A>(int x) Function(int x);
+typedef F1810<T> = List<Function> Function<A>(int x) Function<B extends core.int>();
+typedef F1811<T> = List<Function> Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1812<T> = List<Function> Function<A>(Function x) Function();
+typedef F1813<T> = List<Function> Function<A>(Function x) Function(int x);
+typedef F1814<T> = List<Function> Function<A>(Function x) Function<B extends core.int>();
+typedef F1815<T> = List<Function> Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1816<T> = List<Function> Function<A>(List<Function> x) Function();
+typedef F1817<T> = List<Function> Function<A>(List<Function> x) Function(int x);
+typedef F1818<T> = List<Function> Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1819<T> = List<Function> Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1820<T> = List<Function> Function<A>(core.List<core.int> x) Function();
+typedef F1821<T> = List<Function> Function<A>(core.List<core.int> x) Function(int x);
+typedef F1822<T> = List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1823<T> = List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1824<T> = List<Function> Function<A>(List<T> x) Function();
+typedef F1825<T> = List<Function> Function<A>(List<T> x) Function(int x);
+typedef F1826<T> = List<Function> Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1827<T> = List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1828<T> = List<Function> Function<A>() Function();
+typedef F1829<T> = List<Function> Function<A>() Function(int x);
+typedef F1830<T> = List<Function> Function<A>() Function<B extends core.int>();
+typedef F1831<T> = List<Function> Function<A>() Function<B extends core.int>(int x);
+typedef F1832<T> = List<Function> Function<A>(A x) Function();
+typedef F1833<T> = List<Function> Function<A>(A x) Function(int x);
+typedef F1834<T> = List<Function> Function<A>(A x) Function<B extends core.int>();
+typedef F1835<T> = List<Function> Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1836<T> = List<Function> Function<A>(List<A> x) Function();
+typedef F1837<T> = List<Function> Function<A>(List<A> x) Function(int x);
+typedef F1838<T> = List<Function> Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1839<T> = List<Function> Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1840<T> = core.List<core.int> Function<A>(int x) Function();
+typedef F1841<T> = core.List<core.int> Function<A>(int x) Function(int x);
+typedef F1842<T> = core.List<core.int> Function<A>(int x) Function<B extends core.int>();
+typedef F1843<T> = core.List<core.int> Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1844<T> = core.List<core.int> Function<A>(Function x) Function();
+typedef F1845<T> = core.List<core.int> Function<A>(Function x) Function(int x);
+typedef F1846<T> = core.List<core.int> Function<A>(Function x) Function<B extends core.int>();
+typedef F1847<T> = core.List<core.int> Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1848<T> = core.List<core.int> Function<A>(List<Function> x) Function();
+typedef F1849<T> = core.List<core.int> Function<A>(List<Function> x) Function(int x);
+typedef F1850<T> = core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1851<T> = core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1852<T> = core.List<core.int> Function<A>(core.List<core.int> x) Function();
+typedef F1853<T> = core.List<core.int> Function<A>(core.List<core.int> x) Function(int x);
+typedef F1854<T> = core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1855<T> = core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1856<T> = core.List<core.int> Function<A>(List<T> x) Function();
+typedef F1857<T> = core.List<core.int> Function<A>(List<T> x) Function(int x);
+typedef F1858<T> = core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1859<T> = core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1860<T> = core.List<core.int> Function<A>() Function();
+typedef F1861<T> = core.List<core.int> Function<A>() Function(int x);
+typedef F1862<T> = core.List<core.int> Function<A>() Function<B extends core.int>();
+typedef F1863<T> = core.List<core.int> Function<A>() Function<B extends core.int>(int x);
+typedef F1864<T> = core.List<core.int> Function<A>(A x) Function();
+typedef F1865<T> = core.List<core.int> Function<A>(A x) Function(int x);
+typedef F1866<T> = core.List<core.int> Function<A>(A x) Function<B extends core.int>();
+typedef F1867<T> = core.List<core.int> Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1868<T> = core.List<core.int> Function<A>(List<A> x) Function();
+typedef F1869<T> = core.List<core.int> Function<A>(List<A> x) Function(int x);
+typedef F1870<T> = core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1871<T> = core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1872<T> = List<T> Function<A>(int x) Function();
+typedef F1873<T> = List<T> Function<A>(int x) Function(int x);
+typedef F1874<T> = List<T> Function<A>(int x) Function<B extends core.int>();
+typedef F1875<T> = List<T> Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1876<T> = List<T> Function<A>(Function x) Function();
+typedef F1877<T> = List<T> Function<A>(Function x) Function(int x);
+typedef F1878<T> = List<T> Function<A>(Function x) Function<B extends core.int>();
+typedef F1879<T> = List<T> Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1880<T> = List<T> Function<A>(List<Function> x) Function();
+typedef F1881<T> = List<T> Function<A>(List<Function> x) Function(int x);
+typedef F1882<T> = List<T> Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1883<T> = List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1884<T> = List<T> Function<A>(core.List<core.int> x) Function();
+typedef F1885<T> = List<T> Function<A>(core.List<core.int> x) Function(int x);
+typedef F1886<T> = List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1887<T> = List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1888<T> = List<T> Function<A>(List<T> x) Function();
+typedef F1889<T> = List<T> Function<A>(List<T> x) Function(int x);
+typedef F1890<T> = List<T> Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1891<T> = List<T> Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1892<T> = List<T> Function<A>() Function();
+typedef F1893<T> = List<T> Function<A>() Function(int x);
+typedef F1894<T> = List<T> Function<A>() Function<B extends core.int>();
+typedef F1895<T> = List<T> Function<A>() Function<B extends core.int>(int x);
+typedef F1896<T> = List<T> Function<A>(A x) Function();
+typedef F1897<T> = List<T> Function<A>(A x) Function(int x);
+typedef F1898<T> = List<T> Function<A>(A x) Function<B extends core.int>();
+typedef F1899<T> = List<T> Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1900<T> = List<T> Function<A>(List<A> x) Function();
+typedef F1901<T> = List<T> Function<A>(List<A> x) Function(int x);
+typedef F1902<T> = List<T> Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1903<T> = List<T> Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1904<T> = Function<A>(int x) Function();
+typedef F1905<T> = Function<A>(int x) Function(int x);
+typedef F1906<T> = Function<A>(int x) Function<B extends core.int>();
+typedef F1907<T> = Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1908<T> = Function<A>(Function x) Function();
+typedef F1909<T> = Function<A>(Function x) Function(int x);
+typedef F1910<T> = Function<A>(Function x) Function<B extends core.int>();
+typedef F1911<T> = Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1912<T> = Function<A>(List<Function> x) Function();
+typedef F1913<T> = Function<A>(List<Function> x) Function(int x);
+typedef F1914<T> = Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1915<T> = Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1916<T> = Function<A>(core.List<core.int> x) Function();
+typedef F1917<T> = Function<A>(core.List<core.int> x) Function(int x);
+typedef F1918<T> = Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1919<T> = Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1920<T> = Function<A>(List<T> x) Function();
+typedef F1921<T> = Function<A>(List<T> x) Function(int x);
+typedef F1922<T> = Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1923<T> = Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1924<T> = Function<A>() Function();
+typedef F1925<T> = Function<A>() Function(int x);
+typedef F1926<T> = Function<A>() Function<B extends core.int>();
+typedef F1927<T> = Function<A>() Function<B extends core.int>(int x);
+typedef F1928<T> = Function<A>(A x) Function();
+typedef F1929<T> = Function<A>(A x) Function(int x);
+typedef F1930<T> = Function<A>(A x) Function<B extends core.int>();
+typedef F1931<T> = Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1932<T> = Function<A>(List<A> x) Function();
+typedef F1933<T> = Function<A>(List<A> x) Function(int x);
+typedef F1934<T> = Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1935<T> = Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1936<T> = A Function<A>(int x) Function();
+typedef F1937<T> = A Function<A>(int x) Function(int x);
+typedef F1938<T> = A Function<A>(int x) Function<B extends core.int>();
+typedef F1939<T> = A Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1940<T> = A Function<A>(Function x) Function();
+typedef F1941<T> = A Function<A>(Function x) Function(int x);
+typedef F1942<T> = A Function<A>(Function x) Function<B extends core.int>();
+typedef F1943<T> = A Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1944<T> = A Function<A>(List<Function> x) Function();
+typedef F1945<T> = A Function<A>(List<Function> x) Function(int x);
+typedef F1946<T> = A Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1947<T> = A Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1948<T> = A Function<A>(core.List<core.int> x) Function();
+typedef F1949<T> = A Function<A>(core.List<core.int> x) Function(int x);
+typedef F1950<T> = A Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1951<T> = A Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1952<T> = A Function<A>(List<T> x) Function();
+typedef F1953<T> = A Function<A>(List<T> x) Function(int x);
+typedef F1954<T> = A Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1955<T> = A Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1956<T> = A Function<A>() Function();
+typedef F1957<T> = A Function<A>() Function(int x);
+typedef F1958<T> = A Function<A>() Function<B extends core.int>();
+typedef F1959<T> = A Function<A>() Function<B extends core.int>(int x);
+typedef F1960<T> = A Function<A>(A x) Function();
+typedef F1961<T> = A Function<A>(A x) Function(int x);
+typedef F1962<T> = A Function<A>(A x) Function<B extends core.int>();
+typedef F1963<T> = A Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1964<T> = A Function<A>(List<A> x) Function();
+typedef F1965<T> = A Function<A>(List<A> x) Function(int x);
+typedef F1966<T> = A Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1967<T> = A Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F1968<T> = List<A> Function<A>(int x) Function();
+typedef F1969<T> = List<A> Function<A>(int x) Function(int x);
+typedef F1970<T> = List<A> Function<A>(int x) Function<B extends core.int>();
+typedef F1971<T> = List<A> Function<A>(int x) Function<B extends core.int>(int x);
+typedef F1972<T> = List<A> Function<A>(Function x) Function();
+typedef F1973<T> = List<A> Function<A>(Function x) Function(int x);
+typedef F1974<T> = List<A> Function<A>(Function x) Function<B extends core.int>();
+typedef F1975<T> = List<A> Function<A>(Function x) Function<B extends core.int>(int x);
+typedef F1976<T> = List<A> Function<A>(List<Function> x) Function();
+typedef F1977<T> = List<A> Function<A>(List<Function> x) Function(int x);
+typedef F1978<T> = List<A> Function<A>(List<Function> x) Function<B extends core.int>();
+typedef F1979<T> = List<A> Function<A>(List<Function> x) Function<B extends core.int>(int x);
+typedef F1980<T> = List<A> Function<A>(core.List<core.int> x) Function();
+typedef F1981<T> = List<A> Function<A>(core.List<core.int> x) Function(int x);
+typedef F1982<T> = List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>();
+typedef F1983<T> = List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F1984<T> = List<A> Function<A>(List<T> x) Function();
+typedef F1985<T> = List<A> Function<A>(List<T> x) Function(int x);
+typedef F1986<T> = List<A> Function<A>(List<T> x) Function<B extends core.int>();
+typedef F1987<T> = List<A> Function<A>(List<T> x) Function<B extends core.int>(int x);
+typedef F1988<T> = List<A> Function<A>() Function();
+typedef F1989<T> = List<A> Function<A>() Function(int x);
+typedef F1990<T> = List<A> Function<A>() Function<B extends core.int>();
+typedef F1991<T> = List<A> Function<A>() Function<B extends core.int>(int x);
+typedef F1992<T> = List<A> Function<A>(A x) Function();
+typedef F1993<T> = List<A> Function<A>(A x) Function(int x);
+typedef F1994<T> = List<A> Function<A>(A x) Function<B extends core.int>();
+typedef F1995<T> = List<A> Function<A>(A x) Function<B extends core.int>(int x);
+typedef F1996<T> = List<A> Function<A>(List<A> x) Function();
+typedef F1997<T> = List<A> Function<A>(List<A> x) Function(int x);
+typedef F1998<T> = List<A> Function<A>(List<A> x) Function<B extends core.int>();
+typedef F1999<T> = List<A> Function<A>(List<A> x) Function<B extends core.int>(int x);
+typedef F2000<T> = int Function(B x) Function<B extends core.int>();
+typedef F2001<T> = int Function(B x) Function<B extends core.int>(int x);
+typedef F2002<T> = Function Function(B x) Function<B extends core.int>();
+typedef F2003<T> = Function Function(B x) Function<B extends core.int>(int x);
+typedef F2004<T> = List<Function> Function(B x) Function<B extends core.int>();
+typedef F2005<T> = List<Function> Function(B x) Function<B extends core.int>(int x);
+typedef F2006<T> = core.List<core.int> Function(B x) Function<B extends core.int>();
+typedef F2007<T> = core.List<core.int> Function(B x) Function<B extends core.int>(int x);
+typedef F2008<T> = List<T> Function(B x) Function<B extends core.int>();
+typedef F2009<T> = List<T> Function(B x) Function<B extends core.int>(int x);
+typedef F2010<T> = Function(B x) Function<B extends core.int>();
+typedef F2011<T> = Function(B x) Function<B extends core.int>(int x);
+typedef F2012<T> = B Function(B x) Function<B extends core.int>();
+typedef F2013<T> = B Function(B x) Function<B extends core.int>(int x);
+typedef F2014<T> = List<B> Function(B x) Function<B extends core.int>();
+typedef F2015<T> = List<B> Function(B x) Function<B extends core.int>(int x);
+typedef F2016<T> = B Function(int x) Function<B extends core.int>();
+typedef F2017<T> = B Function(int x) Function<B extends core.int>(int x);
+typedef F2018<T> = B Function(Function x) Function<B extends core.int>();
+typedef F2019<T> = B Function(Function x) Function<B extends core.int>(int x);
+typedef F2020<T> = B Function(List<Function> x) Function<B extends core.int>();
+typedef F2021<T> = B Function(List<Function> x) Function<B extends core.int>(int x);
+typedef F2022<T> = B Function(core.List<core.int> x) Function<B extends core.int>();
+typedef F2023<T> = B Function(core.List<core.int> x) Function<B extends core.int>(int x);
+typedef F2024<T> = B Function(List<T> x) Function<B extends core.int>();
+typedef F2025<T> = B Function(List<T> x) Function<B extends core.int>(int x);
+typedef F2026<T> = B Function() Function<B extends core.int>();
+typedef F2027<T> = B Function() Function<B extends core.int>(int x);
+
+int f0(int x) => null;
+int f1([int x]) => null;
+int f2(int x0, [int x]) => null;
+int f3(int y, [int x]) => null;
+int f4(int x0) => null;
+int f5([int x0]) => null;
+int f6(int x0, [int x1]) => null;
+int f7(int x, [int x0]) => null;
+int f8({int x}) => null;
+int f9(int x0, {int x}) => null;
+int f10(int y, {int x}) => null;
+int f11(Function x) => null;
+int f12([Function x]) => null;
+int f13(int x0, [Function x]) => null;
+int f14(int y, [Function x]) => null;
+int f15(Function x0) => null;
+int f16([Function x0]) => null;
+int f17(int x0, [Function x1]) => null;
+int f18(int x, [Function x0]) => null;
+int f19({Function x}) => null;
+int f20(int x0, {Function x}) => null;
+int f21(int y, {Function x}) => null;
+int f22(List<Function> x) => null;
+int f23([List<Function> x]) => null;
+int f24(int x0, [List<Function> x]) => null;
+int f25(int y, [List<Function> x]) => null;
+int f26(List<Function> x0) => null;
+int f27([List<Function> x0]) => null;
+int f28(int x0, [List<Function> x1]) => null;
+int f29(int x, [List<Function> x0]) => null;
+int f30({List<Function> x}) => null;
+int f31(int x0, {List<Function> x}) => null;
+int f32(int y, {List<Function> x}) => null;
+int f33(core.List<core.int> x) => null;
+int f34([core.List<core.int> x]) => null;
+int f35(int x0, [core.List<core.int> x]) => null;
+int f36(int y, [core.List<core.int> x]) => null;
+int f37(core.List<core.int> x0) => null;
+int f38([core.List<core.int> x0]) => null;
+int f39(int x0, [core.List<core.int> x1]) => null;
+int f40(int x, [core.List<core.int> x0]) => null;
+int f41({core.List<core.int> x}) => null;
+int f42(int x0, {core.List<core.int> x}) => null;
+int f43(int y, {core.List<core.int> x}) => null;
+int f44(List<int> x) => null;
+int f45([List<int> x]) => null;
+int f46(int x0, [List<int> x]) => null;
+int f47(int y, [List<int> x]) => null;
+int f48(List<int> x0) => null;
+int f49([List<int> x0]) => null;
+int f50(int x0, [List<int> x1]) => null;
+int f51(int x, [List<int> x0]) => null;
+int f52({List<int> x}) => null;
+int f53(int x0, {List<int> x}) => null;
+int f54(int y, {List<int> x}) => null;
+int f55() => null;
+Function f56(int x) => null;
+Function f57([int x]) => null;
+Function f58(int x0, [int x]) => null;
+Function f59(int y, [int x]) => null;
+Function f60(int x0) => null;
+Function f61([int x0]) => null;
+Function f62(int x0, [int x1]) => null;
+Function f63(int x, [int x0]) => null;
+Function f64({int x}) => null;
+Function f65(int x0, {int x}) => null;
+Function f66(int y, {int x}) => null;
+Function f67(Function x) => null;
+Function f68([Function x]) => null;
+Function f69(int x0, [Function x]) => null;
+Function f70(int y, [Function x]) => null;
+Function f71(Function x0) => null;
+Function f72([Function x0]) => null;
+Function f73(int x0, [Function x1]) => null;
+Function f74(int x, [Function x0]) => null;
+Function f75({Function x}) => null;
+Function f76(int x0, {Function x}) => null;
+Function f77(int y, {Function x}) => null;
+Function f78(List<Function> x) => null;
+Function f79([List<Function> x]) => null;
+Function f80(int x0, [List<Function> x]) => null;
+Function f81(int y, [List<Function> x]) => null;
+Function f82(List<Function> x0) => null;
+Function f83([List<Function> x0]) => null;
+Function f84(int x0, [List<Function> x1]) => null;
+Function f85(int x, [List<Function> x0]) => null;
+Function f86({List<Function> x}) => null;
+Function f87(int x0, {List<Function> x}) => null;
+Function f88(int y, {List<Function> x}) => null;
+Function f89(core.List<core.int> x) => null;
+Function f90([core.List<core.int> x]) => null;
+Function f91(int x0, [core.List<core.int> x]) => null;
+Function f92(int y, [core.List<core.int> x]) => null;
+Function f93(core.List<core.int> x0) => null;
+Function f94([core.List<core.int> x0]) => null;
+Function f95(int x0, [core.List<core.int> x1]) => null;
+Function f96(int x, [core.List<core.int> x0]) => null;
+Function f97({core.List<core.int> x}) => null;
+Function f98(int x0, {core.List<core.int> x}) => null;
+Function f99(int y, {core.List<core.int> x}) => null;
+Function f100(List<int> x) => null;
+Function f101([List<int> x]) => null;
+Function f102(int x0, [List<int> x]) => null;
+Function f103(int y, [List<int> x]) => null;
+Function f104(List<int> x0) => null;
+Function f105([List<int> x0]) => null;
+Function f106(int x0, [List<int> x1]) => null;
+Function f107(int x, [List<int> x0]) => null;
+Function f108({List<int> x}) => null;
+Function f109(int x0, {List<int> x}) => null;
+Function f110(int y, {List<int> x}) => null;
+Function f111() => null;
+List<Function> f112(int x) => null;
+List<Function> f113([int x]) => null;
+List<Function> f114(int x0, [int x]) => null;
+List<Function> f115(int y, [int x]) => null;
+List<Function> f116(int x0) => null;
+List<Function> f117([int x0]) => null;
+List<Function> f118(int x0, [int x1]) => null;
+List<Function> f119(int x, [int x0]) => null;
+List<Function> f120({int x}) => null;
+List<Function> f121(int x0, {int x}) => null;
+List<Function> f122(int y, {int x}) => null;
+List<Function> f123(Function x) => null;
+List<Function> f124([Function x]) => null;
+List<Function> f125(int x0, [Function x]) => null;
+List<Function> f126(int y, [Function x]) => null;
+List<Function> f127(Function x0) => null;
+List<Function> f128([Function x0]) => null;
+List<Function> f129(int x0, [Function x1]) => null;
+List<Function> f130(int x, [Function x0]) => null;
+List<Function> f131({Function x}) => null;
+List<Function> f132(int x0, {Function x}) => null;
+List<Function> f133(int y, {Function x}) => null;
+List<Function> f134(List<Function> x) => null;
+List<Function> f135([List<Function> x]) => null;
+List<Function> f136(int x0, [List<Function> x]) => null;
+List<Function> f137(int y, [List<Function> x]) => null;
+List<Function> f138(List<Function> x0) => null;
+List<Function> f139([List<Function> x0]) => null;
+List<Function> f140(int x0, [List<Function> x1]) => null;
+List<Function> f141(int x, [List<Function> x0]) => null;
+List<Function> f142({List<Function> x}) => null;
+List<Function> f143(int x0, {List<Function> x}) => null;
+List<Function> f144(int y, {List<Function> x}) => null;
+List<Function> f145(core.List<core.int> x) => null;
+List<Function> f146([core.List<core.int> x]) => null;
+List<Function> f147(int x0, [core.List<core.int> x]) => null;
+List<Function> f148(int y, [core.List<core.int> x]) => null;
+List<Function> f149(core.List<core.int> x0) => null;
+List<Function> f150([core.List<core.int> x0]) => null;
+List<Function> f151(int x0, [core.List<core.int> x1]) => null;
+List<Function> f152(int x, [core.List<core.int> x0]) => null;
+List<Function> f153({core.List<core.int> x}) => null;
+List<Function> f154(int x0, {core.List<core.int> x}) => null;
+List<Function> f155(int y, {core.List<core.int> x}) => null;
+List<Function> f156(List<int> x) => null;
+List<Function> f157([List<int> x]) => null;
+List<Function> f158(int x0, [List<int> x]) => null;
+List<Function> f159(int y, [List<int> x]) => null;
+List<Function> f160(List<int> x0) => null;
+List<Function> f161([List<int> x0]) => null;
+List<Function> f162(int x0, [List<int> x1]) => null;
+List<Function> f163(int x, [List<int> x0]) => null;
+List<Function> f164({List<int> x}) => null;
+List<Function> f165(int x0, {List<int> x}) => null;
+List<Function> f166(int y, {List<int> x}) => null;
+List<Function> f167() => null;
+core.List<core.int> f168(int x) => null;
+core.List<core.int> f169([int x]) => null;
+core.List<core.int> f170(int x0, [int x]) => null;
+core.List<core.int> f171(int y, [int x]) => null;
+core.List<core.int> f172(int x0) => null;
+core.List<core.int> f173([int x0]) => null;
+core.List<core.int> f174(int x0, [int x1]) => null;
+core.List<core.int> f175(int x, [int x0]) => null;
+core.List<core.int> f176({int x}) => null;
+core.List<core.int> f177(int x0, {int x}) => null;
+core.List<core.int> f178(int y, {int x}) => null;
+core.List<core.int> f179(Function x) => null;
+core.List<core.int> f180([Function x]) => null;
+core.List<core.int> f181(int x0, [Function x]) => null;
+core.List<core.int> f182(int y, [Function x]) => null;
+core.List<core.int> f183(Function x0) => null;
+core.List<core.int> f184([Function x0]) => null;
+core.List<core.int> f185(int x0, [Function x1]) => null;
+core.List<core.int> f186(int x, [Function x0]) => null;
+core.List<core.int> f187({Function x}) => null;
+core.List<core.int> f188(int x0, {Function x}) => null;
+core.List<core.int> f189(int y, {Function x}) => null;
+core.List<core.int> f190(List<Function> x) => null;
+core.List<core.int> f191([List<Function> x]) => null;
+core.List<core.int> f192(int x0, [List<Function> x]) => null;
+core.List<core.int> f193(int y, [List<Function> x]) => null;
+core.List<core.int> f194(List<Function> x0) => null;
+core.List<core.int> f195([List<Function> x0]) => null;
+core.List<core.int> f196(int x0, [List<Function> x1]) => null;
+core.List<core.int> f197(int x, [List<Function> x0]) => null;
+core.List<core.int> f198({List<Function> x}) => null;
+core.List<core.int> f199(int x0, {List<Function> x}) => null;
+core.List<core.int> f200(int y, {List<Function> x}) => null;
+core.List<core.int> f201(core.List<core.int> x) => null;
+core.List<core.int> f202([core.List<core.int> x]) => null;
+core.List<core.int> f203(int x0, [core.List<core.int> x]) => null;
+core.List<core.int> f204(int y, [core.List<core.int> x]) => null;
+core.List<core.int> f205(core.List<core.int> x0) => null;
+core.List<core.int> f206([core.List<core.int> x0]) => null;
+core.List<core.int> f207(int x0, [core.List<core.int> x1]) => null;
+core.List<core.int> f208(int x, [core.List<core.int> x0]) => null;
+core.List<core.int> f209({core.List<core.int> x}) => null;
+core.List<core.int> f210(int x0, {core.List<core.int> x}) => null;
+core.List<core.int> f211(int y, {core.List<core.int> x}) => null;
+core.List<core.int> f212(List<int> x) => null;
+core.List<core.int> f213([List<int> x]) => null;
+core.List<core.int> f214(int x0, [List<int> x]) => null;
+core.List<core.int> f215(int y, [List<int> x]) => null;
+core.List<core.int> f216(List<int> x0) => null;
+core.List<core.int> f217([List<int> x0]) => null;
+core.List<core.int> f218(int x0, [List<int> x1]) => null;
+core.List<core.int> f219(int x, [List<int> x0]) => null;
+core.List<core.int> f220({List<int> x}) => null;
+core.List<core.int> f221(int x0, {List<int> x}) => null;
+core.List<core.int> f222(int y, {List<int> x}) => null;
+core.List<core.int> f223() => null;
+List<int> f224(int x) => null;
+List<int> f225([int x]) => null;
+List<int> f226(int x0, [int x]) => null;
+List<int> f227(int y, [int x]) => null;
+List<int> f228(int x0) => null;
+List<int> f229([int x0]) => null;
+List<int> f230(int x0, [int x1]) => null;
+List<int> f231(int x, [int x0]) => null;
+List<int> f232({int x}) => null;
+List<int> f233(int x0, {int x}) => null;
+List<int> f234(int y, {int x}) => null;
+List<int> f235(Function x) => null;
+List<int> f236([Function x]) => null;
+List<int> f237(int x0, [Function x]) => null;
+List<int> f238(int y, [Function x]) => null;
+List<int> f239(Function x0) => null;
+List<int> f240([Function x0]) => null;
+List<int> f241(int x0, [Function x1]) => null;
+List<int> f242(int x, [Function x0]) => null;
+List<int> f243({Function x}) => null;
+List<int> f244(int x0, {Function x}) => null;
+List<int> f245(int y, {Function x}) => null;
+List<int> f246(List<Function> x) => null;
+List<int> f247([List<Function> x]) => null;
+List<int> f248(int x0, [List<Function> x]) => null;
+List<int> f249(int y, [List<Function> x]) => null;
+List<int> f250(List<Function> x0) => null;
+List<int> f251([List<Function> x0]) => null;
+List<int> f252(int x0, [List<Function> x1]) => null;
+List<int> f253(int x, [List<Function> x0]) => null;
+List<int> f254({List<Function> x}) => null;
+List<int> f255(int x0, {List<Function> x}) => null;
+List<int> f256(int y, {List<Function> x}) => null;
+List<int> f257(core.List<core.int> x) => null;
+List<int> f258([core.List<core.int> x]) => null;
+List<int> f259(int x0, [core.List<core.int> x]) => null;
+List<int> f260(int y, [core.List<core.int> x]) => null;
+List<int> f261(core.List<core.int> x0) => null;
+List<int> f262([core.List<core.int> x0]) => null;
+List<int> f263(int x0, [core.List<core.int> x1]) => null;
+List<int> f264(int x, [core.List<core.int> x0]) => null;
+List<int> f265({core.List<core.int> x}) => null;
+List<int> f266(int x0, {core.List<core.int> x}) => null;
+List<int> f267(int y, {core.List<core.int> x}) => null;
+List<int> f268(List<int> x) => null;
+List<int> f269([List<int> x]) => null;
+List<int> f270(int x0, [List<int> x]) => null;
+List<int> f271(int y, [List<int> x]) => null;
+List<int> f272(List<int> x0) => null;
+List<int> f273([List<int> x0]) => null;
+List<int> f274(int x0, [List<int> x1]) => null;
+List<int> f275(int x, [List<int> x0]) => null;
+List<int> f276({List<int> x}) => null;
+List<int> f277(int x0, {List<int> x}) => null;
+List<int> f278(int y, {List<int> x}) => null;
+List<int> f279() => null;
+f280(int x) => null;
+f281([int x]) => null;
+f282(int x0, [int x]) => null;
+f283(int y, [int x]) => null;
+f284(int x0) => null;
+f285([int x0]) => null;
+f286(int x0, [int x1]) => null;
+f287(int x, [int x0]) => null;
+f288({int x}) => null;
+f289(int x0, {int x}) => null;
+f290(int y, {int x}) => null;
+f291(Function x) => null;
+f292([Function x]) => null;
+f293(int x0, [Function x]) => null;
+f294(int y, [Function x]) => null;
+f295(Function x0) => null;
+f296([Function x0]) => null;
+f297(int x0, [Function x1]) => null;
+f298(int x, [Function x0]) => null;
+f299({Function x}) => null;
+f300(int x0, {Function x}) => null;
+f301(int y, {Function x}) => null;
+f302(List<Function> x) => null;
+f303([List<Function> x]) => null;
+f304(int x0, [List<Function> x]) => null;
+f305(int y, [List<Function> x]) => null;
+f306(List<Function> x0) => null;
+f307([List<Function> x0]) => null;
+f308(int x0, [List<Function> x1]) => null;
+f309(int x, [List<Function> x0]) => null;
+f310({List<Function> x}) => null;
+f311(int x0, {List<Function> x}) => null;
+f312(int y, {List<Function> x}) => null;
+f313(core.List<core.int> x) => null;
+f314([core.List<core.int> x]) => null;
+f315(int x0, [core.List<core.int> x]) => null;
+f316(int y, [core.List<core.int> x]) => null;
+f317(core.List<core.int> x0) => null;
+f318([core.List<core.int> x0]) => null;
+f319(int x0, [core.List<core.int> x1]) => null;
+f320(int x, [core.List<core.int> x0]) => null;
+f321({core.List<core.int> x}) => null;
+f322(int x0, {core.List<core.int> x}) => null;
+f323(int y, {core.List<core.int> x}) => null;
+f324(List<int> x) => null;
+f325([List<int> x]) => null;
+f326(int x0, [List<int> x]) => null;
+f327(int y, [List<int> x]) => null;
+f328(List<int> x0) => null;
+f329([List<int> x0]) => null;
+f330(int x0, [List<int> x1]) => null;
+f331(int x, [List<int> x0]) => null;
+f332({List<int> x}) => null;
+f333(int x0, {List<int> x}) => null;
+f334(int y, {List<int> x}) => null;
+f335() => null;
+int f336<A>(int x) => null;
+int f337<A>(Function x) => null;
+int f338<A>(List<Function> x) => null;
+int f339<A>(core.List<core.int> x) => null;
+int f340<A>(List<int> x) => null;
+int f341<A>() => null;
+int f342<A>(A x) => null;
+int f343<A>(List<A> x) => null;
+Function f344<A>(int x) => null;
+Function f345<A>(Function x) => null;
+Function f346<A>(List<Function> x) => null;
+Function f347<A>(core.List<core.int> x) => null;
+Function f348<A>(List<int> x) => null;
+Function f349<A>() => null;
+Function f350<A>(A x) => null;
+Function f351<A>(List<A> x) => null;
+List<Function> f352<A>(int x) => null;
+List<Function> f353<A>(Function x) => null;
+List<Function> f354<A>(List<Function> x) => null;
+List<Function> f355<A>(core.List<core.int> x) => null;
+List<Function> f356<A>(List<int> x) => null;
+List<Function> f357<A>() => null;
+List<Function> f358<A>(A x) => null;
+List<Function> f359<A>(List<A> x) => null;
+core.List<core.int> f360<A>(int x) => null;
+core.List<core.int> f361<A>(Function x) => null;
+core.List<core.int> f362<A>(List<Function> x) => null;
+core.List<core.int> f363<A>(core.List<core.int> x) => null;
+core.List<core.int> f364<A>(List<int> x) => null;
+core.List<core.int> f365<A>() => null;
+core.List<core.int> f366<A>(A x) => null;
+core.List<core.int> f367<A>(List<A> x) => null;
+List<int> f368<A>(int x) => null;
+List<int> f369<A>(Function x) => null;
+List<int> f370<A>(List<Function> x) => null;
+List<int> f371<A>(core.List<core.int> x) => null;
+List<int> f372<A>(List<int> x) => null;
+List<int> f373<A>() => null;
+List<int> f374<A>(A x) => null;
+List<int> f375<A>(List<A> x) => null;
+f376<A>(int x) => null;
+f377<A>(Function x) => null;
+f378<A>(List<Function> x) => null;
+f379<A>(core.List<core.int> x) => null;
+f380<A>(List<int> x) => null;
+f381<A>() => null;
+f382<A>(A x) => null;
+f383<A>(List<A> x) => null;
+A f384<A>(int x) => null;
+A f385<A>(Function x) => null;
+A f386<A>(List<Function> x) => null;
+A f387<A>(core.List<core.int> x) => null;
+A f388<A>(List<int> x) => null;
+A f389<A>() => null;
+A f390<A>(A x) => null;
+A f391<A>(List<A> x) => null;
+List<A> f392<A>(int x) => null;
+List<A> f393<A>(Function x) => null;
+List<A> f394<A>(List<Function> x) => null;
+List<A> f395<A>(core.List<core.int> x) => null;
+List<A> f396<A>(List<int> x) => null;
+List<A> f397<A>() => null;
+List<A> f398<A>(A x) => null;
+List<A> f399<A>(List<A> x) => null;
+int Function(int x) f400() => null;
+int Function(int x) f401(int x) => null;
+int Function(int x) f402<B extends core.int>() => null;
+int Function(int x) f403<B extends core.int>(int x) => null;
+int Function([int x]) f404() => null;
+int Function([int x]) f405(int x) => null;
+int Function([int x]) f406<B extends core.int>() => null;
+int Function([int x]) f407<B extends core.int>(int x) => null;
+int Function(int x0, [int x]) f408() => null;
+int Function(int x0, [int x]) f409(int x) => null;
+int Function(int x0, [int x]) f410<B extends core.int>() => null;
+int Function(int x0, [int x]) f411<B extends core.int>(int x) => null;
+int Function(int y, [int x]) f412() => null;
+int Function(int y, [int x]) f413(int x) => null;
+int Function(int y, [int x]) f414<B extends core.int>() => null;
+int Function(int y, [int x]) f415<B extends core.int>(int x) => null;
+int Function(int x0) f416() => null;
+int Function(int x0) f417(int x) => null;
+int Function(int x0) f418<B extends core.int>() => null;
+int Function(int x0) f419<B extends core.int>(int x) => null;
+int Function([int x0]) f420() => null;
+int Function([int x0]) f421(int x) => null;
+int Function([int x0]) f422<B extends core.int>() => null;
+int Function([int x0]) f423<B extends core.int>(int x) => null;
+int Function(int x0, [int x1]) f424() => null;
+int Function(int x0, [int x1]) f425(int x) => null;
+int Function(int x0, [int x1]) f426<B extends core.int>() => null;
+int Function(int x0, [int x1]) f427<B extends core.int>(int x) => null;
+int Function(int x, [int x0]) f428() => null;
+int Function(int x, [int x0]) f429(int x) => null;
+int Function(int x, [int x0]) f430<B extends core.int>() => null;
+int Function(int x, [int x0]) f431<B extends core.int>(int x) => null;
+int Function({int x}) f432() => null;
+int Function({int x}) f433(int x) => null;
+int Function({int x}) f434<B extends core.int>() => null;
+int Function({int x}) f435<B extends core.int>(int x) => null;
+int Function(int x0, {int x}) f436() => null;
+int Function(int x0, {int x}) f437(int x) => null;
+int Function(int x0, {int x}) f438<B extends core.int>() => null;
+int Function(int x0, {int x}) f439<B extends core.int>(int x) => null;
+int Function(int y, {int x}) f440() => null;
+int Function(int y, {int x}) f441(int x) => null;
+int Function(int y, {int x}) f442<B extends core.int>() => null;
+int Function(int y, {int x}) f443<B extends core.int>(int x) => null;
+int Function(Function x) f444() => null;
+int Function(Function x) f445(int x) => null;
+int Function(Function x) f446<B extends core.int>() => null;
+int Function(Function x) f447<B extends core.int>(int x) => null;
+int Function([Function x]) f448() => null;
+int Function([Function x]) f449(int x) => null;
+int Function([Function x]) f450<B extends core.int>() => null;
+int Function([Function x]) f451<B extends core.int>(int x) => null;
+int Function(int x0, [Function x]) f452() => null;
+int Function(int x0, [Function x]) f453(int x) => null;
+int Function(int x0, [Function x]) f454<B extends core.int>() => null;
+int Function(int x0, [Function x]) f455<B extends core.int>(int x) => null;
+int Function(int y, [Function x]) f456() => null;
+int Function(int y, [Function x]) f457(int x) => null;
+int Function(int y, [Function x]) f458<B extends core.int>() => null;
+int Function(int y, [Function x]) f459<B extends core.int>(int x) => null;
+int Function(Function x0) f460() => null;
+int Function(Function x0) f461(int x) => null;
+int Function(Function x0) f462<B extends core.int>() => null;
+int Function(Function x0) f463<B extends core.int>(int x) => null;
+int Function([Function x0]) f464() => null;
+int Function([Function x0]) f465(int x) => null;
+int Function([Function x0]) f466<B extends core.int>() => null;
+int Function([Function x0]) f467<B extends core.int>(int x) => null;
+int Function(int x0, [Function x1]) f468() => null;
+int Function(int x0, [Function x1]) f469(int x) => null;
+int Function(int x0, [Function x1]) f470<B extends core.int>() => null;
+int Function(int x0, [Function x1]) f471<B extends core.int>(int x) => null;
+int Function(int x, [Function x0]) f472() => null;
+int Function(int x, [Function x0]) f473(int x) => null;
+int Function(int x, [Function x0]) f474<B extends core.int>() => null;
+int Function(int x, [Function x0]) f475<B extends core.int>(int x) => null;
+int Function({Function x}) f476() => null;
+int Function({Function x}) f477(int x) => null;
+int Function({Function x}) f478<B extends core.int>() => null;
+int Function({Function x}) f479<B extends core.int>(int x) => null;
+int Function(int x0, {Function x}) f480() => null;
+int Function(int x0, {Function x}) f481(int x) => null;
+int Function(int x0, {Function x}) f482<B extends core.int>() => null;
+int Function(int x0, {Function x}) f483<B extends core.int>(int x) => null;
+int Function(int y, {Function x}) f484() => null;
+int Function(int y, {Function x}) f485(int x) => null;
+int Function(int y, {Function x}) f486<B extends core.int>() => null;
+int Function(int y, {Function x}) f487<B extends core.int>(int x) => null;
+int Function(List<Function> x) f488() => null;
+int Function(List<Function> x) f489(int x) => null;
+int Function(List<Function> x) f490<B extends core.int>() => null;
+int Function(List<Function> x) f491<B extends core.int>(int x) => null;
+int Function([List<Function> x]) f492() => null;
+int Function([List<Function> x]) f493(int x) => null;
+int Function([List<Function> x]) f494<B extends core.int>() => null;
+int Function([List<Function> x]) f495<B extends core.int>(int x) => null;
+int Function(int x0, [List<Function> x]) f496() => null;
+int Function(int x0, [List<Function> x]) f497(int x) => null;
+int Function(int x0, [List<Function> x]) f498<B extends core.int>() => null;
+int Function(int x0, [List<Function> x]) f499<B extends core.int>(int x) => null;
+int Function(int y, [List<Function> x]) f500() => null;
+int Function(int y, [List<Function> x]) f501(int x) => null;
+int Function(int y, [List<Function> x]) f502<B extends core.int>() => null;
+int Function(int y, [List<Function> x]) f503<B extends core.int>(int x) => null;
+int Function(List<Function> x0) f504() => null;
+int Function(List<Function> x0) f505(int x) => null;
+int Function(List<Function> x0) f506<B extends core.int>() => null;
+int Function(List<Function> x0) f507<B extends core.int>(int x) => null;
+int Function([List<Function> x0]) f508() => null;
+int Function([List<Function> x0]) f509(int x) => null;
+int Function([List<Function> x0]) f510<B extends core.int>() => null;
+int Function([List<Function> x0]) f511<B extends core.int>(int x) => null;
+int Function(int x0, [List<Function> x1]) f512() => null;
+int Function(int x0, [List<Function> x1]) f513(int x) => null;
+int Function(int x0, [List<Function> x1]) f514<B extends core.int>() => null;
+int Function(int x0, [List<Function> x1]) f515<B extends core.int>(int x) => null;
+int Function(int x, [List<Function> x0]) f516() => null;
+int Function(int x, [List<Function> x0]) f517(int x) => null;
+int Function(int x, [List<Function> x0]) f518<B extends core.int>() => null;
+int Function(int x, [List<Function> x0]) f519<B extends core.int>(int x) => null;
+int Function({List<Function> x}) f520() => null;
+int Function({List<Function> x}) f521(int x) => null;
+int Function({List<Function> x}) f522<B extends core.int>() => null;
+int Function({List<Function> x}) f523<B extends core.int>(int x) => null;
+int Function(int x0, {List<Function> x}) f524() => null;
+int Function(int x0, {List<Function> x}) f525(int x) => null;
+int Function(int x0, {List<Function> x}) f526<B extends core.int>() => null;
+int Function(int x0, {List<Function> x}) f527<B extends core.int>(int x) => null;
+int Function(int y, {List<Function> x}) f528() => null;
+int Function(int y, {List<Function> x}) f529(int x) => null;
+int Function(int y, {List<Function> x}) f530<B extends core.int>() => null;
+int Function(int y, {List<Function> x}) f531<B extends core.int>(int x) => null;
+int Function(core.List<core.int> x) f532() => null;
+int Function(core.List<core.int> x) f533(int x) => null;
+int Function(core.List<core.int> x) f534<B extends core.int>() => null;
+int Function(core.List<core.int> x) f535<B extends core.int>(int x) => null;
+int Function([core.List<core.int> x]) f536() => null;
+int Function([core.List<core.int> x]) f537(int x) => null;
+int Function([core.List<core.int> x]) f538<B extends core.int>() => null;
+int Function([core.List<core.int> x]) f539<B extends core.int>(int x) => null;
+int Function(int x0, [core.List<core.int> x]) f540() => null;
+int Function(int x0, [core.List<core.int> x]) f541(int x) => null;
+int Function(int x0, [core.List<core.int> x]) f542<B extends core.int>() => null;
+int Function(int x0, [core.List<core.int> x]) f543<B extends core.int>(int x) => null;
+int Function(int y, [core.List<core.int> x]) f544() => null;
+int Function(int y, [core.List<core.int> x]) f545(int x) => null;
+int Function(int y, [core.List<core.int> x]) f546<B extends core.int>() => null;
+int Function(int y, [core.List<core.int> x]) f547<B extends core.int>(int x) => null;
+int Function(core.List<core.int> x0) f548() => null;
+int Function(core.List<core.int> x0) f549(int x) => null;
+int Function(core.List<core.int> x0) f550<B extends core.int>() => null;
+int Function(core.List<core.int> x0) f551<B extends core.int>(int x) => null;
+int Function([core.List<core.int> x0]) f552() => null;
+int Function([core.List<core.int> x0]) f553(int x) => null;
+int Function([core.List<core.int> x0]) f554<B extends core.int>() => null;
+int Function([core.List<core.int> x0]) f555<B extends core.int>(int x) => null;
+int Function(int x0, [core.List<core.int> x1]) f556() => null;
+int Function(int x0, [core.List<core.int> x1]) f557(int x) => null;
+int Function(int x0, [core.List<core.int> x1]) f558<B extends core.int>() => null;
+int Function(int x0, [core.List<core.int> x1]) f559<B extends core.int>(int x) => null;
+int Function(int x, [core.List<core.int> x0]) f560() => null;
+int Function(int x, [core.List<core.int> x0]) f561(int x) => null;
+int Function(int x, [core.List<core.int> x0]) f562<B extends core.int>() => null;
+int Function(int x, [core.List<core.int> x0]) f563<B extends core.int>(int x) => null;
+int Function({core.List<core.int> x}) f564() => null;
+int Function({core.List<core.int> x}) f565(int x) => null;
+int Function({core.List<core.int> x}) f566<B extends core.int>() => null;
+int Function({core.List<core.int> x}) f567<B extends core.int>(int x) => null;
+int Function(int x0, {core.List<core.int> x}) f568() => null;
+int Function(int x0, {core.List<core.int> x}) f569(int x) => null;
+int Function(int x0, {core.List<core.int> x}) f570<B extends core.int>() => null;
+int Function(int x0, {core.List<core.int> x}) f571<B extends core.int>(int x) => null;
+int Function(int y, {core.List<core.int> x}) f572() => null;
+int Function(int y, {core.List<core.int> x}) f573(int x) => null;
+int Function(int y, {core.List<core.int> x}) f574<B extends core.int>() => null;
+int Function(int y, {core.List<core.int> x}) f575<B extends core.int>(int x) => null;
+int Function(List<int> x) f576() => null;
+int Function(List<int> x) f577(int x) => null;
+int Function(List<int> x) f578<B extends core.int>() => null;
+int Function(List<int> x) f579<B extends core.int>(int x) => null;
+int Function([List<int> x]) f580() => null;
+int Function([List<int> x]) f581(int x) => null;
+int Function([List<int> x]) f582<B extends core.int>() => null;
+int Function([List<int> x]) f583<B extends core.int>(int x) => null;
+int Function(int x0, [List<int> x]) f584() => null;
+int Function(int x0, [List<int> x]) f585(int x) => null;
+int Function(int x0, [List<int> x]) f586<B extends core.int>() => null;
+int Function(int x0, [List<int> x]) f587<B extends core.int>(int x) => null;
+int Function(int y, [List<int> x]) f588() => null;
+int Function(int y, [List<int> x]) f589(int x) => null;
+int Function(int y, [List<int> x]) f590<B extends core.int>() => null;
+int Function(int y, [List<int> x]) f591<B extends core.int>(int x) => null;
+int Function(List<int> x0) f592() => null;
+int Function(List<int> x0) f593(int x) => null;
+int Function(List<int> x0) f594<B extends core.int>() => null;
+int Function(List<int> x0) f595<B extends core.int>(int x) => null;
+int Function([List<int> x0]) f596() => null;
+int Function([List<int> x0]) f597(int x) => null;
+int Function([List<int> x0]) f598<B extends core.int>() => null;
+int Function([List<int> x0]) f599<B extends core.int>(int x) => null;
+int Function(int x0, [List<int> x1]) f600() => null;
+int Function(int x0, [List<int> x1]) f601(int x) => null;
+int Function(int x0, [List<int> x1]) f602<B extends core.int>() => null;
+int Function(int x0, [List<int> x1]) f603<B extends core.int>(int x) => null;
+int Function(int x, [List<int> x0]) f604() => null;
+int Function(int x, [List<int> x0]) f605(int x) => null;
+int Function(int x, [List<int> x0]) f606<B extends core.int>() => null;
+int Function(int x, [List<int> x0]) f607<B extends core.int>(int x) => null;
+int Function({List<int> x}) f608() => null;
+int Function({List<int> x}) f609(int x) => null;
+int Function({List<int> x}) f610<B extends core.int>() => null;
+int Function({List<int> x}) f611<B extends core.int>(int x) => null;
+int Function(int x0, {List<int> x}) f612() => null;
+int Function(int x0, {List<int> x}) f613(int x) => null;
+int Function(int x0, {List<int> x}) f614<B extends core.int>() => null;
+int Function(int x0, {List<int> x}) f615<B extends core.int>(int x) => null;
+int Function(int y, {List<int> x}) f616() => null;
+int Function(int y, {List<int> x}) f617(int x) => null;
+int Function(int y, {List<int> x}) f618<B extends core.int>() => null;
+int Function(int y, {List<int> x}) f619<B extends core.int>(int x) => null;
+int Function() f620() => null;
+int Function() f621(int x) => null;
+int Function() f622<B extends core.int>() => null;
+int Function() f623<B extends core.int>(int x) => null;
+Function Function(int x) f624() => null;
+Function Function(int x) f625(int x) => null;
+Function Function(int x) f626<B extends core.int>() => null;
+Function Function(int x) f627<B extends core.int>(int x) => null;
+Function Function([int x]) f628() => null;
+Function Function([int x]) f629(int x) => null;
+Function Function([int x]) f630<B extends core.int>() => null;
+Function Function([int x]) f631<B extends core.int>(int x) => null;
+Function Function(int x0, [int x]) f632() => null;
+Function Function(int x0, [int x]) f633(int x) => null;
+Function Function(int x0, [int x]) f634<B extends core.int>() => null;
+Function Function(int x0, [int x]) f635<B extends core.int>(int x) => null;
+Function Function(int y, [int x]) f636() => null;
+Function Function(int y, [int x]) f637(int x) => null;
+Function Function(int y, [int x]) f638<B extends core.int>() => null;
+Function Function(int y, [int x]) f639<B extends core.int>(int x) => null;
+Function Function(int x0) f640() => null;
+Function Function(int x0) f641(int x) => null;
+Function Function(int x0) f642<B extends core.int>() => null;
+Function Function(int x0) f643<B extends core.int>(int x) => null;
+Function Function([int x0]) f644() => null;
+Function Function([int x0]) f645(int x) => null;
+Function Function([int x0]) f646<B extends core.int>() => null;
+Function Function([int x0]) f647<B extends core.int>(int x) => null;
+Function Function(int x0, [int x1]) f648() => null;
+Function Function(int x0, [int x1]) f649(int x) => null;
+Function Function(int x0, [int x1]) f650<B extends core.int>() => null;
+Function Function(int x0, [int x1]) f651<B extends core.int>(int x) => null;
+Function Function(int x, [int x0]) f652() => null;
+Function Function(int x, [int x0]) f653(int x) => null;
+Function Function(int x, [int x0]) f654<B extends core.int>() => null;
+Function Function(int x, [int x0]) f655<B extends core.int>(int x) => null;
+Function Function({int x}) f656() => null;
+Function Function({int x}) f657(int x) => null;
+Function Function({int x}) f658<B extends core.int>() => null;
+Function Function({int x}) f659<B extends core.int>(int x) => null;
+Function Function(int x0, {int x}) f660() => null;
+Function Function(int x0, {int x}) f661(int x) => null;
+Function Function(int x0, {int x}) f662<B extends core.int>() => null;
+Function Function(int x0, {int x}) f663<B extends core.int>(int x) => null;
+Function Function(int y, {int x}) f664() => null;
+Function Function(int y, {int x}) f665(int x) => null;
+Function Function(int y, {int x}) f666<B extends core.int>() => null;
+Function Function(int y, {int x}) f667<B extends core.int>(int x) => null;
+Function Function(Function x) f668() => null;
+Function Function(Function x) f669(int x) => null;
+Function Function(Function x) f670<B extends core.int>() => null;
+Function Function(Function x) f671<B extends core.int>(int x) => null;
+Function Function([Function x]) f672() => null;
+Function Function([Function x]) f673(int x) => null;
+Function Function([Function x]) f674<B extends core.int>() => null;
+Function Function([Function x]) f675<B extends core.int>(int x) => null;
+Function Function(int x0, [Function x]) f676() => null;
+Function Function(int x0, [Function x]) f677(int x) => null;
+Function Function(int x0, [Function x]) f678<B extends core.int>() => null;
+Function Function(int x0, [Function x]) f679<B extends core.int>(int x) => null;
+Function Function(int y, [Function x]) f680() => null;
+Function Function(int y, [Function x]) f681(int x) => null;
+Function Function(int y, [Function x]) f682<B extends core.int>() => null;
+Function Function(int y, [Function x]) f683<B extends core.int>(int x) => null;
+Function Function(Function x0) f684() => null;
+Function Function(Function x0) f685(int x) => null;
+Function Function(Function x0) f686<B extends core.int>() => null;
+Function Function(Function x0) f687<B extends core.int>(int x) => null;
+Function Function([Function x0]) f688() => null;
+Function Function([Function x0]) f689(int x) => null;
+Function Function([Function x0]) f690<B extends core.int>() => null;
+Function Function([Function x0]) f691<B extends core.int>(int x) => null;
+Function Function(int x0, [Function x1]) f692() => null;
+Function Function(int x0, [Function x1]) f693(int x) => null;
+Function Function(int x0, [Function x1]) f694<B extends core.int>() => null;
+Function Function(int x0, [Function x1]) f695<B extends core.int>(int x) => null;
+Function Function(int x, [Function x0]) f696() => null;
+Function Function(int x, [Function x0]) f697(int x) => null;
+Function Function(int x, [Function x0]) f698<B extends core.int>() => null;
+Function Function(int x, [Function x0]) f699<B extends core.int>(int x) => null;
+Function Function({Function x}) f700() => null;
+Function Function({Function x}) f701(int x) => null;
+Function Function({Function x}) f702<B extends core.int>() => null;
+Function Function({Function x}) f703<B extends core.int>(int x) => null;
+Function Function(int x0, {Function x}) f704() => null;
+Function Function(int x0, {Function x}) f705(int x) => null;
+Function Function(int x0, {Function x}) f706<B extends core.int>() => null;
+Function Function(int x0, {Function x}) f707<B extends core.int>(int x) => null;
+Function Function(int y, {Function x}) f708() => null;
+Function Function(int y, {Function x}) f709(int x) => null;
+Function Function(int y, {Function x}) f710<B extends core.int>() => null;
+Function Function(int y, {Function x}) f711<B extends core.int>(int x) => null;
+Function Function(List<Function> x) f712() => null;
+Function Function(List<Function> x) f713(int x) => null;
+Function Function(List<Function> x) f714<B extends core.int>() => null;
+Function Function(List<Function> x) f715<B extends core.int>(int x) => null;
+Function Function([List<Function> x]) f716() => null;
+Function Function([List<Function> x]) f717(int x) => null;
+Function Function([List<Function> x]) f718<B extends core.int>() => null;
+Function Function([List<Function> x]) f719<B extends core.int>(int x) => null;
+Function Function(int x0, [List<Function> x]) f720() => null;
+Function Function(int x0, [List<Function> x]) f721(int x) => null;
+Function Function(int x0, [List<Function> x]) f722<B extends core.int>() => null;
+Function Function(int x0, [List<Function> x]) f723<B extends core.int>(int x) => null;
+Function Function(int y, [List<Function> x]) f724() => null;
+Function Function(int y, [List<Function> x]) f725(int x) => null;
+Function Function(int y, [List<Function> x]) f726<B extends core.int>() => null;
+Function Function(int y, [List<Function> x]) f727<B extends core.int>(int x) => null;
+Function Function(List<Function> x0) f728() => null;
+Function Function(List<Function> x0) f729(int x) => null;
+Function Function(List<Function> x0) f730<B extends core.int>() => null;
+Function Function(List<Function> x0) f731<B extends core.int>(int x) => null;
+Function Function([List<Function> x0]) f732() => null;
+Function Function([List<Function> x0]) f733(int x) => null;
+Function Function([List<Function> x0]) f734<B extends core.int>() => null;
+Function Function([List<Function> x0]) f735<B extends core.int>(int x) => null;
+Function Function(int x0, [List<Function> x1]) f736() => null;
+Function Function(int x0, [List<Function> x1]) f737(int x) => null;
+Function Function(int x0, [List<Function> x1]) f738<B extends core.int>() => null;
+Function Function(int x0, [List<Function> x1]) f739<B extends core.int>(int x) => null;
+Function Function(int x, [List<Function> x0]) f740() => null;
+Function Function(int x, [List<Function> x0]) f741(int x) => null;
+Function Function(int x, [List<Function> x0]) f742<B extends core.int>() => null;
+Function Function(int x, [List<Function> x0]) f743<B extends core.int>(int x) => null;
+Function Function({List<Function> x}) f744() => null;
+Function Function({List<Function> x}) f745(int x) => null;
+Function Function({List<Function> x}) f746<B extends core.int>() => null;
+Function Function({List<Function> x}) f747<B extends core.int>(int x) => null;
+Function Function(int x0, {List<Function> x}) f748() => null;
+Function Function(int x0, {List<Function> x}) f749(int x) => null;
+Function Function(int x0, {List<Function> x}) f750<B extends core.int>() => null;
+Function Function(int x0, {List<Function> x}) f751<B extends core.int>(int x) => null;
+Function Function(int y, {List<Function> x}) f752() => null;
+Function Function(int y, {List<Function> x}) f753(int x) => null;
+Function Function(int y, {List<Function> x}) f754<B extends core.int>() => null;
+Function Function(int y, {List<Function> x}) f755<B extends core.int>(int x) => null;
+Function Function(core.List<core.int> x) f756() => null;
+Function Function(core.List<core.int> x) f757(int x) => null;
+Function Function(core.List<core.int> x) f758<B extends core.int>() => null;
+Function Function(core.List<core.int> x) f759<B extends core.int>(int x) => null;
+Function Function([core.List<core.int> x]) f760() => null;
+Function Function([core.List<core.int> x]) f761(int x) => null;
+Function Function([core.List<core.int> x]) f762<B extends core.int>() => null;
+Function Function([core.List<core.int> x]) f763<B extends core.int>(int x) => null;
+Function Function(int x0, [core.List<core.int> x]) f764() => null;
+Function Function(int x0, [core.List<core.int> x]) f765(int x) => null;
+Function Function(int x0, [core.List<core.int> x]) f766<B extends core.int>() => null;
+Function Function(int x0, [core.List<core.int> x]) f767<B extends core.int>(int x) => null;
+Function Function(int y, [core.List<core.int> x]) f768() => null;
+Function Function(int y, [core.List<core.int> x]) f769(int x) => null;
+Function Function(int y, [core.List<core.int> x]) f770<B extends core.int>() => null;
+Function Function(int y, [core.List<core.int> x]) f771<B extends core.int>(int x) => null;
+Function Function(core.List<core.int> x0) f772() => null;
+Function Function(core.List<core.int> x0) f773(int x) => null;
+Function Function(core.List<core.int> x0) f774<B extends core.int>() => null;
+Function Function(core.List<core.int> x0) f775<B extends core.int>(int x) => null;
+Function Function([core.List<core.int> x0]) f776() => null;
+Function Function([core.List<core.int> x0]) f777(int x) => null;
+Function Function([core.List<core.int> x0]) f778<B extends core.int>() => null;
+Function Function([core.List<core.int> x0]) f779<B extends core.int>(int x) => null;
+Function Function(int x0, [core.List<core.int> x1]) f780() => null;
+Function Function(int x0, [core.List<core.int> x1]) f781(int x) => null;
+Function Function(int x0, [core.List<core.int> x1]) f782<B extends core.int>() => null;
+Function Function(int x0, [core.List<core.int> x1]) f783<B extends core.int>(int x) => null;
+Function Function(int x, [core.List<core.int> x0]) f784() => null;
+Function Function(int x, [core.List<core.int> x0]) f785(int x) => null;
+Function Function(int x, [core.List<core.int> x0]) f786<B extends core.int>() => null;
+Function Function(int x, [core.List<core.int> x0]) f787<B extends core.int>(int x) => null;
+Function Function({core.List<core.int> x}) f788() => null;
+Function Function({core.List<core.int> x}) f789(int x) => null;
+Function Function({core.List<core.int> x}) f790<B extends core.int>() => null;
+Function Function({core.List<core.int> x}) f791<B extends core.int>(int x) => null;
+Function Function(int x0, {core.List<core.int> x}) f792() => null;
+Function Function(int x0, {core.List<core.int> x}) f793(int x) => null;
+Function Function(int x0, {core.List<core.int> x}) f794<B extends core.int>() => null;
+Function Function(int x0, {core.List<core.int> x}) f795<B extends core.int>(int x) => null;
+Function Function(int y, {core.List<core.int> x}) f796() => null;
+Function Function(int y, {core.List<core.int> x}) f797(int x) => null;
+Function Function(int y, {core.List<core.int> x}) f798<B extends core.int>() => null;
+Function Function(int y, {core.List<core.int> x}) f799<B extends core.int>(int x) => null;
+Function Function(List<int> x) f800() => null;
+Function Function(List<int> x) f801(int x) => null;
+Function Function(List<int> x) f802<B extends core.int>() => null;
+Function Function(List<int> x) f803<B extends core.int>(int x) => null;
+Function Function([List<int> x]) f804() => null;
+Function Function([List<int> x]) f805(int x) => null;
+Function Function([List<int> x]) f806<B extends core.int>() => null;
+Function Function([List<int> x]) f807<B extends core.int>(int x) => null;
+Function Function(int x0, [List<int> x]) f808() => null;
+Function Function(int x0, [List<int> x]) f809(int x) => null;
+Function Function(int x0, [List<int> x]) f810<B extends core.int>() => null;
+Function Function(int x0, [List<int> x]) f811<B extends core.int>(int x) => null;
+Function Function(int y, [List<int> x]) f812() => null;
+Function Function(int y, [List<int> x]) f813(int x) => null;
+Function Function(int y, [List<int> x]) f814<B extends core.int>() => null;
+Function Function(int y, [List<int> x]) f815<B extends core.int>(int x) => null;
+Function Function(List<int> x0) f816() => null;
+Function Function(List<int> x0) f817(int x) => null;
+Function Function(List<int> x0) f818<B extends core.int>() => null;
+Function Function(List<int> x0) f819<B extends core.int>(int x) => null;
+Function Function([List<int> x0]) f820() => null;
+Function Function([List<int> x0]) f821(int x) => null;
+Function Function([List<int> x0]) f822<B extends core.int>() => null;
+Function Function([List<int> x0]) f823<B extends core.int>(int x) => null;
+Function Function(int x0, [List<int> x1]) f824() => null;
+Function Function(int x0, [List<int> x1]) f825(int x) => null;
+Function Function(int x0, [List<int> x1]) f826<B extends core.int>() => null;
+Function Function(int x0, [List<int> x1]) f827<B extends core.int>(int x) => null;
+Function Function(int x, [List<int> x0]) f828() => null;
+Function Function(int x, [List<int> x0]) f829(int x) => null;
+Function Function(int x, [List<int> x0]) f830<B extends core.int>() => null;
+Function Function(int x, [List<int> x0]) f831<B extends core.int>(int x) => null;
+Function Function({List<int> x}) f832() => null;
+Function Function({List<int> x}) f833(int x) => null;
+Function Function({List<int> x}) f834<B extends core.int>() => null;
+Function Function({List<int> x}) f835<B extends core.int>(int x) => null;
+Function Function(int x0, {List<int> x}) f836() => null;
+Function Function(int x0, {List<int> x}) f837(int x) => null;
+Function Function(int x0, {List<int> x}) f838<B extends core.int>() => null;
+Function Function(int x0, {List<int> x}) f839<B extends core.int>(int x) => null;
+Function Function(int y, {List<int> x}) f840() => null;
+Function Function(int y, {List<int> x}) f841(int x) => null;
+Function Function(int y, {List<int> x}) f842<B extends core.int>() => null;
+Function Function(int y, {List<int> x}) f843<B extends core.int>(int x) => null;
+Function Function() f844() => null;
+Function Function() f845(int x) => null;
+Function Function() f846<B extends core.int>() => null;
+Function Function() f847<B extends core.int>(int x) => null;
+List<Function> Function(int x) f848() => null;
+List<Function> Function(int x) f849(int x) => null;
+List<Function> Function(int x) f850<B extends core.int>() => null;
+List<Function> Function(int x) f851<B extends core.int>(int x) => null;
+List<Function> Function([int x]) f852() => null;
+List<Function> Function([int x]) f853(int x) => null;
+List<Function> Function([int x]) f854<B extends core.int>() => null;
+List<Function> Function([int x]) f855<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [int x]) f856() => null;
+List<Function> Function(int x0, [int x]) f857(int x) => null;
+List<Function> Function(int x0, [int x]) f858<B extends core.int>() => null;
+List<Function> Function(int x0, [int x]) f859<B extends core.int>(int x) => null;
+List<Function> Function(int y, [int x]) f860() => null;
+List<Function> Function(int y, [int x]) f861(int x) => null;
+List<Function> Function(int y, [int x]) f862<B extends core.int>() => null;
+List<Function> Function(int y, [int x]) f863<B extends core.int>(int x) => null;
+List<Function> Function(int x0) f864() => null;
+List<Function> Function(int x0) f865(int x) => null;
+List<Function> Function(int x0) f866<B extends core.int>() => null;
+List<Function> Function(int x0) f867<B extends core.int>(int x) => null;
+List<Function> Function([int x0]) f868() => null;
+List<Function> Function([int x0]) f869(int x) => null;
+List<Function> Function([int x0]) f870<B extends core.int>() => null;
+List<Function> Function([int x0]) f871<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [int x1]) f872() => null;
+List<Function> Function(int x0, [int x1]) f873(int x) => null;
+List<Function> Function(int x0, [int x1]) f874<B extends core.int>() => null;
+List<Function> Function(int x0, [int x1]) f875<B extends core.int>(int x) => null;
+List<Function> Function(int x, [int x0]) f876() => null;
+List<Function> Function(int x, [int x0]) f877(int x) => null;
+List<Function> Function(int x, [int x0]) f878<B extends core.int>() => null;
+List<Function> Function(int x, [int x0]) f879<B extends core.int>(int x) => null;
+List<Function> Function({int x}) f880() => null;
+List<Function> Function({int x}) f881(int x) => null;
+List<Function> Function({int x}) f882<B extends core.int>() => null;
+List<Function> Function({int x}) f883<B extends core.int>(int x) => null;
+List<Function> Function(int x0, {int x}) f884() => null;
+List<Function> Function(int x0, {int x}) f885(int x) => null;
+List<Function> Function(int x0, {int x}) f886<B extends core.int>() => null;
+List<Function> Function(int x0, {int x}) f887<B extends core.int>(int x) => null;
+List<Function> Function(int y, {int x}) f888() => null;
+List<Function> Function(int y, {int x}) f889(int x) => null;
+List<Function> Function(int y, {int x}) f890<B extends core.int>() => null;
+List<Function> Function(int y, {int x}) f891<B extends core.int>(int x) => null;
+List<Function> Function(Function x) f892() => null;
+List<Function> Function(Function x) f893(int x) => null;
+List<Function> Function(Function x) f894<B extends core.int>() => null;
+List<Function> Function(Function x) f895<B extends core.int>(int x) => null;
+List<Function> Function([Function x]) f896() => null;
+List<Function> Function([Function x]) f897(int x) => null;
+List<Function> Function([Function x]) f898<B extends core.int>() => null;
+List<Function> Function([Function x]) f899<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [Function x]) f900() => null;
+List<Function> Function(int x0, [Function x]) f901(int x) => null;
+List<Function> Function(int x0, [Function x]) f902<B extends core.int>() => null;
+List<Function> Function(int x0, [Function x]) f903<B extends core.int>(int x) => null;
+List<Function> Function(int y, [Function x]) f904() => null;
+List<Function> Function(int y, [Function x]) f905(int x) => null;
+List<Function> Function(int y, [Function x]) f906<B extends core.int>() => null;
+List<Function> Function(int y, [Function x]) f907<B extends core.int>(int x) => null;
+List<Function> Function(Function x0) f908() => null;
+List<Function> Function(Function x0) f909(int x) => null;
+List<Function> Function(Function x0) f910<B extends core.int>() => null;
+List<Function> Function(Function x0) f911<B extends core.int>(int x) => null;
+List<Function> Function([Function x0]) f912() => null;
+List<Function> Function([Function x0]) f913(int x) => null;
+List<Function> Function([Function x0]) f914<B extends core.int>() => null;
+List<Function> Function([Function x0]) f915<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [Function x1]) f916() => null;
+List<Function> Function(int x0, [Function x1]) f917(int x) => null;
+List<Function> Function(int x0, [Function x1]) f918<B extends core.int>() => null;
+List<Function> Function(int x0, [Function x1]) f919<B extends core.int>(int x) => null;
+List<Function> Function(int x, [Function x0]) f920() => null;
+List<Function> Function(int x, [Function x0]) f921(int x) => null;
+List<Function> Function(int x, [Function x0]) f922<B extends core.int>() => null;
+List<Function> Function(int x, [Function x0]) f923<B extends core.int>(int x) => null;
+List<Function> Function({Function x}) f924() => null;
+List<Function> Function({Function x}) f925(int x) => null;
+List<Function> Function({Function x}) f926<B extends core.int>() => null;
+List<Function> Function({Function x}) f927<B extends core.int>(int x) => null;
+List<Function> Function(int x0, {Function x}) f928() => null;
+List<Function> Function(int x0, {Function x}) f929(int x) => null;
+List<Function> Function(int x0, {Function x}) f930<B extends core.int>() => null;
+List<Function> Function(int x0, {Function x}) f931<B extends core.int>(int x) => null;
+List<Function> Function(int y, {Function x}) f932() => null;
+List<Function> Function(int y, {Function x}) f933(int x) => null;
+List<Function> Function(int y, {Function x}) f934<B extends core.int>() => null;
+List<Function> Function(int y, {Function x}) f935<B extends core.int>(int x) => null;
+List<Function> Function(List<Function> x) f936() => null;
+List<Function> Function(List<Function> x) f937(int x) => null;
+List<Function> Function(List<Function> x) f938<B extends core.int>() => null;
+List<Function> Function(List<Function> x) f939<B extends core.int>(int x) => null;
+List<Function> Function([List<Function> x]) f940() => null;
+List<Function> Function([List<Function> x]) f941(int x) => null;
+List<Function> Function([List<Function> x]) f942<B extends core.int>() => null;
+List<Function> Function([List<Function> x]) f943<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [List<Function> x]) f944() => null;
+List<Function> Function(int x0, [List<Function> x]) f945(int x) => null;
+List<Function> Function(int x0, [List<Function> x]) f946<B extends core.int>() => null;
+List<Function> Function(int x0, [List<Function> x]) f947<B extends core.int>(int x) => null;
+List<Function> Function(int y, [List<Function> x]) f948() => null;
+List<Function> Function(int y, [List<Function> x]) f949(int x) => null;
+List<Function> Function(int y, [List<Function> x]) f950<B extends core.int>() => null;
+List<Function> Function(int y, [List<Function> x]) f951<B extends core.int>(int x) => null;
+List<Function> Function(List<Function> x0) f952() => null;
+List<Function> Function(List<Function> x0) f953(int x) => null;
+List<Function> Function(List<Function> x0) f954<B extends core.int>() => null;
+List<Function> Function(List<Function> x0) f955<B extends core.int>(int x) => null;
+List<Function> Function([List<Function> x0]) f956() => null;
+List<Function> Function([List<Function> x0]) f957(int x) => null;
+List<Function> Function([List<Function> x0]) f958<B extends core.int>() => null;
+List<Function> Function([List<Function> x0]) f959<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [List<Function> x1]) f960() => null;
+List<Function> Function(int x0, [List<Function> x1]) f961(int x) => null;
+List<Function> Function(int x0, [List<Function> x1]) f962<B extends core.int>() => null;
+List<Function> Function(int x0, [List<Function> x1]) f963<B extends core.int>(int x) => null;
+List<Function> Function(int x, [List<Function> x0]) f964() => null;
+List<Function> Function(int x, [List<Function> x0]) f965(int x) => null;
+List<Function> Function(int x, [List<Function> x0]) f966<B extends core.int>() => null;
+List<Function> Function(int x, [List<Function> x0]) f967<B extends core.int>(int x) => null;
+List<Function> Function({List<Function> x}) f968() => null;
+List<Function> Function({List<Function> x}) f969(int x) => null;
+List<Function> Function({List<Function> x}) f970<B extends core.int>() => null;
+List<Function> Function({List<Function> x}) f971<B extends core.int>(int x) => null;
+List<Function> Function(int x0, {List<Function> x}) f972() => null;
+List<Function> Function(int x0, {List<Function> x}) f973(int x) => null;
+List<Function> Function(int x0, {List<Function> x}) f974<B extends core.int>() => null;
+List<Function> Function(int x0, {List<Function> x}) f975<B extends core.int>(int x) => null;
+List<Function> Function(int y, {List<Function> x}) f976() => null;
+List<Function> Function(int y, {List<Function> x}) f977(int x) => null;
+List<Function> Function(int y, {List<Function> x}) f978<B extends core.int>() => null;
+List<Function> Function(int y, {List<Function> x}) f979<B extends core.int>(int x) => null;
+List<Function> Function(core.List<core.int> x) f980() => null;
+List<Function> Function(core.List<core.int> x) f981(int x) => null;
+List<Function> Function(core.List<core.int> x) f982<B extends core.int>() => null;
+List<Function> Function(core.List<core.int> x) f983<B extends core.int>(int x) => null;
+List<Function> Function([core.List<core.int> x]) f984() => null;
+List<Function> Function([core.List<core.int> x]) f985(int x) => null;
+List<Function> Function([core.List<core.int> x]) f986<B extends core.int>() => null;
+List<Function> Function([core.List<core.int> x]) f987<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [core.List<core.int> x]) f988() => null;
+List<Function> Function(int x0, [core.List<core.int> x]) f989(int x) => null;
+List<Function> Function(int x0, [core.List<core.int> x]) f990<B extends core.int>() => null;
+List<Function> Function(int x0, [core.List<core.int> x]) f991<B extends core.int>(int x) => null;
+List<Function> Function(int y, [core.List<core.int> x]) f992() => null;
+List<Function> Function(int y, [core.List<core.int> x]) f993(int x) => null;
+List<Function> Function(int y, [core.List<core.int> x]) f994<B extends core.int>() => null;
+List<Function> Function(int y, [core.List<core.int> x]) f995<B extends core.int>(int x) => null;
+List<Function> Function(core.List<core.int> x0) f996() => null;
+List<Function> Function(core.List<core.int> x0) f997(int x) => null;
+List<Function> Function(core.List<core.int> x0) f998<B extends core.int>() => null;
+List<Function> Function(core.List<core.int> x0) f999<B extends core.int>(int x) => null;
+List<Function> Function([core.List<core.int> x0]) f1000() => null;
+List<Function> Function([core.List<core.int> x0]) f1001(int x) => null;
+List<Function> Function([core.List<core.int> x0]) f1002<B extends core.int>() => null;
+List<Function> Function([core.List<core.int> x0]) f1003<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [core.List<core.int> x1]) f1004() => null;
+List<Function> Function(int x0, [core.List<core.int> x1]) f1005(int x) => null;
+List<Function> Function(int x0, [core.List<core.int> x1]) f1006<B extends core.int>() => null;
+List<Function> Function(int x0, [core.List<core.int> x1]) f1007<B extends core.int>(int x) => null;
+List<Function> Function(int x, [core.List<core.int> x0]) f1008() => null;
+List<Function> Function(int x, [core.List<core.int> x0]) f1009(int x) => null;
+List<Function> Function(int x, [core.List<core.int> x0]) f1010<B extends core.int>() => null;
+List<Function> Function(int x, [core.List<core.int> x0]) f1011<B extends core.int>(int x) => null;
+List<Function> Function({core.List<core.int> x}) f1012() => null;
+List<Function> Function({core.List<core.int> x}) f1013(int x) => null;
+List<Function> Function({core.List<core.int> x}) f1014<B extends core.int>() => null;
+List<Function> Function({core.List<core.int> x}) f1015<B extends core.int>(int x) => null;
+List<Function> Function(int x0, {core.List<core.int> x}) f1016() => null;
+List<Function> Function(int x0, {core.List<core.int> x}) f1017(int x) => null;
+List<Function> Function(int x0, {core.List<core.int> x}) f1018<B extends core.int>() => null;
+List<Function> Function(int x0, {core.List<core.int> x}) f1019<B extends core.int>(int x) => null;
+List<Function> Function(int y, {core.List<core.int> x}) f1020() => null;
+List<Function> Function(int y, {core.List<core.int> x}) f1021(int x) => null;
+List<Function> Function(int y, {core.List<core.int> x}) f1022<B extends core.int>() => null;
+List<Function> Function(int y, {core.List<core.int> x}) f1023<B extends core.int>(int x) => null;
+List<Function> Function(List<int> x) f1024() => null;
+List<Function> Function(List<int> x) f1025(int x) => null;
+List<Function> Function(List<int> x) f1026<B extends core.int>() => null;
+List<Function> Function(List<int> x) f1027<B extends core.int>(int x) => null;
+List<Function> Function([List<int> x]) f1028() => null;
+List<Function> Function([List<int> x]) f1029(int x) => null;
+List<Function> Function([List<int> x]) f1030<B extends core.int>() => null;
+List<Function> Function([List<int> x]) f1031<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [List<int> x]) f1032() => null;
+List<Function> Function(int x0, [List<int> x]) f1033(int x) => null;
+List<Function> Function(int x0, [List<int> x]) f1034<B extends core.int>() => null;
+List<Function> Function(int x0, [List<int> x]) f1035<B extends core.int>(int x) => null;
+List<Function> Function(int y, [List<int> x]) f1036() => null;
+List<Function> Function(int y, [List<int> x]) f1037(int x) => null;
+List<Function> Function(int y, [List<int> x]) f1038<B extends core.int>() => null;
+List<Function> Function(int y, [List<int> x]) f1039<B extends core.int>(int x) => null;
+List<Function> Function(List<int> x0) f1040() => null;
+List<Function> Function(List<int> x0) f1041(int x) => null;
+List<Function> Function(List<int> x0) f1042<B extends core.int>() => null;
+List<Function> Function(List<int> x0) f1043<B extends core.int>(int x) => null;
+List<Function> Function([List<int> x0]) f1044() => null;
+List<Function> Function([List<int> x0]) f1045(int x) => null;
+List<Function> Function([List<int> x0]) f1046<B extends core.int>() => null;
+List<Function> Function([List<int> x0]) f1047<B extends core.int>(int x) => null;
+List<Function> Function(int x0, [List<int> x1]) f1048() => null;
+List<Function> Function(int x0, [List<int> x1]) f1049(int x) => null;
+List<Function> Function(int x0, [List<int> x1]) f1050<B extends core.int>() => null;
+List<Function> Function(int x0, [List<int> x1]) f1051<B extends core.int>(int x) => null;
+List<Function> Function(int x, [List<int> x0]) f1052() => null;
+List<Function> Function(int x, [List<int> x0]) f1053(int x) => null;
+List<Function> Function(int x, [List<int> x0]) f1054<B extends core.int>() => null;
+List<Function> Function(int x, [List<int> x0]) f1055<B extends core.int>(int x) => null;
+List<Function> Function({List<int> x}) f1056() => null;
+List<Function> Function({List<int> x}) f1057(int x) => null;
+List<Function> Function({List<int> x}) f1058<B extends core.int>() => null;
+List<Function> Function({List<int> x}) f1059<B extends core.int>(int x) => null;
+List<Function> Function(int x0, {List<int> x}) f1060() => null;
+List<Function> Function(int x0, {List<int> x}) f1061(int x) => null;
+List<Function> Function(int x0, {List<int> x}) f1062<B extends core.int>() => null;
+List<Function> Function(int x0, {List<int> x}) f1063<B extends core.int>(int x) => null;
+List<Function> Function(int y, {List<int> x}) f1064() => null;
+List<Function> Function(int y, {List<int> x}) f1065(int x) => null;
+List<Function> Function(int y, {List<int> x}) f1066<B extends core.int>() => null;
+List<Function> Function(int y, {List<int> x}) f1067<B extends core.int>(int x) => null;
+List<Function> Function() f1068() => null;
+List<Function> Function() f1069(int x) => null;
+List<Function> Function() f1070<B extends core.int>() => null;
+List<Function> Function() f1071<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x) f1072() => null;
+core.List<core.int> Function(int x) f1073(int x) => null;
+core.List<core.int> Function(int x) f1074<B extends core.int>() => null;
+core.List<core.int> Function(int x) f1075<B extends core.int>(int x) => null;
+core.List<core.int> Function([int x]) f1076() => null;
+core.List<core.int> Function([int x]) f1077(int x) => null;
+core.List<core.int> Function([int x]) f1078<B extends core.int>() => null;
+core.List<core.int> Function([int x]) f1079<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [int x]) f1080() => null;
+core.List<core.int> Function(int x0, [int x]) f1081(int x) => null;
+core.List<core.int> Function(int x0, [int x]) f1082<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [int x]) f1083<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, [int x]) f1084() => null;
+core.List<core.int> Function(int y, [int x]) f1085(int x) => null;
+core.List<core.int> Function(int y, [int x]) f1086<B extends core.int>() => null;
+core.List<core.int> Function(int y, [int x]) f1087<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0) f1088() => null;
+core.List<core.int> Function(int x0) f1089(int x) => null;
+core.List<core.int> Function(int x0) f1090<B extends core.int>() => null;
+core.List<core.int> Function(int x0) f1091<B extends core.int>(int x) => null;
+core.List<core.int> Function([int x0]) f1092() => null;
+core.List<core.int> Function([int x0]) f1093(int x) => null;
+core.List<core.int> Function([int x0]) f1094<B extends core.int>() => null;
+core.List<core.int> Function([int x0]) f1095<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [int x1]) f1096() => null;
+core.List<core.int> Function(int x0, [int x1]) f1097(int x) => null;
+core.List<core.int> Function(int x0, [int x1]) f1098<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [int x1]) f1099<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x, [int x0]) f1100() => null;
+core.List<core.int> Function(int x, [int x0]) f1101(int x) => null;
+core.List<core.int> Function(int x, [int x0]) f1102<B extends core.int>() => null;
+core.List<core.int> Function(int x, [int x0]) f1103<B extends core.int>(int x) => null;
+core.List<core.int> Function({int x}) f1104() => null;
+core.List<core.int> Function({int x}) f1105(int x) => null;
+core.List<core.int> Function({int x}) f1106<B extends core.int>() => null;
+core.List<core.int> Function({int x}) f1107<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, {int x}) f1108() => null;
+core.List<core.int> Function(int x0, {int x}) f1109(int x) => null;
+core.List<core.int> Function(int x0, {int x}) f1110<B extends core.int>() => null;
+core.List<core.int> Function(int x0, {int x}) f1111<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, {int x}) f1112() => null;
+core.List<core.int> Function(int y, {int x}) f1113(int x) => null;
+core.List<core.int> Function(int y, {int x}) f1114<B extends core.int>() => null;
+core.List<core.int> Function(int y, {int x}) f1115<B extends core.int>(int x) => null;
+core.List<core.int> Function(Function x) f1116() => null;
+core.List<core.int> Function(Function x) f1117(int x) => null;
+core.List<core.int> Function(Function x) f1118<B extends core.int>() => null;
+core.List<core.int> Function(Function x) f1119<B extends core.int>(int x) => null;
+core.List<core.int> Function([Function x]) f1120() => null;
+core.List<core.int> Function([Function x]) f1121(int x) => null;
+core.List<core.int> Function([Function x]) f1122<B extends core.int>() => null;
+core.List<core.int> Function([Function x]) f1123<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [Function x]) f1124() => null;
+core.List<core.int> Function(int x0, [Function x]) f1125(int x) => null;
+core.List<core.int> Function(int x0, [Function x]) f1126<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [Function x]) f1127<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, [Function x]) f1128() => null;
+core.List<core.int> Function(int y, [Function x]) f1129(int x) => null;
+core.List<core.int> Function(int y, [Function x]) f1130<B extends core.int>() => null;
+core.List<core.int> Function(int y, [Function x]) f1131<B extends core.int>(int x) => null;
+core.List<core.int> Function(Function x0) f1132() => null;
+core.List<core.int> Function(Function x0) f1133(int x) => null;
+core.List<core.int> Function(Function x0) f1134<B extends core.int>() => null;
+core.List<core.int> Function(Function x0) f1135<B extends core.int>(int x) => null;
+core.List<core.int> Function([Function x0]) f1136() => null;
+core.List<core.int> Function([Function x0]) f1137(int x) => null;
+core.List<core.int> Function([Function x0]) f1138<B extends core.int>() => null;
+core.List<core.int> Function([Function x0]) f1139<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [Function x1]) f1140() => null;
+core.List<core.int> Function(int x0, [Function x1]) f1141(int x) => null;
+core.List<core.int> Function(int x0, [Function x1]) f1142<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [Function x1]) f1143<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x, [Function x0]) f1144() => null;
+core.List<core.int> Function(int x, [Function x0]) f1145(int x) => null;
+core.List<core.int> Function(int x, [Function x0]) f1146<B extends core.int>() => null;
+core.List<core.int> Function(int x, [Function x0]) f1147<B extends core.int>(int x) => null;
+core.List<core.int> Function({Function x}) f1148() => null;
+core.List<core.int> Function({Function x}) f1149(int x) => null;
+core.List<core.int> Function({Function x}) f1150<B extends core.int>() => null;
+core.List<core.int> Function({Function x}) f1151<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, {Function x}) f1152() => null;
+core.List<core.int> Function(int x0, {Function x}) f1153(int x) => null;
+core.List<core.int> Function(int x0, {Function x}) f1154<B extends core.int>() => null;
+core.List<core.int> Function(int x0, {Function x}) f1155<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, {Function x}) f1156() => null;
+core.List<core.int> Function(int y, {Function x}) f1157(int x) => null;
+core.List<core.int> Function(int y, {Function x}) f1158<B extends core.int>() => null;
+core.List<core.int> Function(int y, {Function x}) f1159<B extends core.int>(int x) => null;
+core.List<core.int> Function(List<Function> x) f1160() => null;
+core.List<core.int> Function(List<Function> x) f1161(int x) => null;
+core.List<core.int> Function(List<Function> x) f1162<B extends core.int>() => null;
+core.List<core.int> Function(List<Function> x) f1163<B extends core.int>(int x) => null;
+core.List<core.int> Function([List<Function> x]) f1164() => null;
+core.List<core.int> Function([List<Function> x]) f1165(int x) => null;
+core.List<core.int> Function([List<Function> x]) f1166<B extends core.int>() => null;
+core.List<core.int> Function([List<Function> x]) f1167<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [List<Function> x]) f1168() => null;
+core.List<core.int> Function(int x0, [List<Function> x]) f1169(int x) => null;
+core.List<core.int> Function(int x0, [List<Function> x]) f1170<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [List<Function> x]) f1171<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, [List<Function> x]) f1172() => null;
+core.List<core.int> Function(int y, [List<Function> x]) f1173(int x) => null;
+core.List<core.int> Function(int y, [List<Function> x]) f1174<B extends core.int>() => null;
+core.List<core.int> Function(int y, [List<Function> x]) f1175<B extends core.int>(int x) => null;
+core.List<core.int> Function(List<Function> x0) f1176() => null;
+core.List<core.int> Function(List<Function> x0) f1177(int x) => null;
+core.List<core.int> Function(List<Function> x0) f1178<B extends core.int>() => null;
+core.List<core.int> Function(List<Function> x0) f1179<B extends core.int>(int x) => null;
+core.List<core.int> Function([List<Function> x0]) f1180() => null;
+core.List<core.int> Function([List<Function> x0]) f1181(int x) => null;
+core.List<core.int> Function([List<Function> x0]) f1182<B extends core.int>() => null;
+core.List<core.int> Function([List<Function> x0]) f1183<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [List<Function> x1]) f1184() => null;
+core.List<core.int> Function(int x0, [List<Function> x1]) f1185(int x) => null;
+core.List<core.int> Function(int x0, [List<Function> x1]) f1186<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [List<Function> x1]) f1187<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x, [List<Function> x0]) f1188() => null;
+core.List<core.int> Function(int x, [List<Function> x0]) f1189(int x) => null;
+core.List<core.int> Function(int x, [List<Function> x0]) f1190<B extends core.int>() => null;
+core.List<core.int> Function(int x, [List<Function> x0]) f1191<B extends core.int>(int x) => null;
+core.List<core.int> Function({List<Function> x}) f1192() => null;
+core.List<core.int> Function({List<Function> x}) f1193(int x) => null;
+core.List<core.int> Function({List<Function> x}) f1194<B extends core.int>() => null;
+core.List<core.int> Function({List<Function> x}) f1195<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, {List<Function> x}) f1196() => null;
+core.List<core.int> Function(int x0, {List<Function> x}) f1197(int x) => null;
+core.List<core.int> Function(int x0, {List<Function> x}) f1198<B extends core.int>() => null;
+core.List<core.int> Function(int x0, {List<Function> x}) f1199<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, {List<Function> x}) f1200() => null;
+core.List<core.int> Function(int y, {List<Function> x}) f1201(int x) => null;
+core.List<core.int> Function(int y, {List<Function> x}) f1202<B extends core.int>() => null;
+core.List<core.int> Function(int y, {List<Function> x}) f1203<B extends core.int>(int x) => null;
+core.List<core.int> Function(core.List<core.int> x) f1204() => null;
+core.List<core.int> Function(core.List<core.int> x) f1205(int x) => null;
+core.List<core.int> Function(core.List<core.int> x) f1206<B extends core.int>() => null;
+core.List<core.int> Function(core.List<core.int> x) f1207<B extends core.int>(int x) => null;
+core.List<core.int> Function([core.List<core.int> x]) f1208() => null;
+core.List<core.int> Function([core.List<core.int> x]) f1209(int x) => null;
+core.List<core.int> Function([core.List<core.int> x]) f1210<B extends core.int>() => null;
+core.List<core.int> Function([core.List<core.int> x]) f1211<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x]) f1212() => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x]) f1213(int x) => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x]) f1214<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x]) f1215<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, [core.List<core.int> x]) f1216() => null;
+core.List<core.int> Function(int y, [core.List<core.int> x]) f1217(int x) => null;
+core.List<core.int> Function(int y, [core.List<core.int> x]) f1218<B extends core.int>() => null;
+core.List<core.int> Function(int y, [core.List<core.int> x]) f1219<B extends core.int>(int x) => null;
+core.List<core.int> Function(core.List<core.int> x0) f1220() => null;
+core.List<core.int> Function(core.List<core.int> x0) f1221(int x) => null;
+core.List<core.int> Function(core.List<core.int> x0) f1222<B extends core.int>() => null;
+core.List<core.int> Function(core.List<core.int> x0) f1223<B extends core.int>(int x) => null;
+core.List<core.int> Function([core.List<core.int> x0]) f1224() => null;
+core.List<core.int> Function([core.List<core.int> x0]) f1225(int x) => null;
+core.List<core.int> Function([core.List<core.int> x0]) f1226<B extends core.int>() => null;
+core.List<core.int> Function([core.List<core.int> x0]) f1227<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x1]) f1228() => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x1]) f1229(int x) => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x1]) f1230<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [core.List<core.int> x1]) f1231<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x, [core.List<core.int> x0]) f1232() => null;
+core.List<core.int> Function(int x, [core.List<core.int> x0]) f1233(int x) => null;
+core.List<core.int> Function(int x, [core.List<core.int> x0]) f1234<B extends core.int>() => null;
+core.List<core.int> Function(int x, [core.List<core.int> x0]) f1235<B extends core.int>(int x) => null;
+core.List<core.int> Function({core.List<core.int> x}) f1236() => null;
+core.List<core.int> Function({core.List<core.int> x}) f1237(int x) => null;
+core.List<core.int> Function({core.List<core.int> x}) f1238<B extends core.int>() => null;
+core.List<core.int> Function({core.List<core.int> x}) f1239<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, {core.List<core.int> x}) f1240() => null;
+core.List<core.int> Function(int x0, {core.List<core.int> x}) f1241(int x) => null;
+core.List<core.int> Function(int x0, {core.List<core.int> x}) f1242<B extends core.int>() => null;
+core.List<core.int> Function(int x0, {core.List<core.int> x}) f1243<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, {core.List<core.int> x}) f1244() => null;
+core.List<core.int> Function(int y, {core.List<core.int> x}) f1245(int x) => null;
+core.List<core.int> Function(int y, {core.List<core.int> x}) f1246<B extends core.int>() => null;
+core.List<core.int> Function(int y, {core.List<core.int> x}) f1247<B extends core.int>(int x) => null;
+core.List<core.int> Function(List<int> x) f1248() => null;
+core.List<core.int> Function(List<int> x) f1249(int x) => null;
+core.List<core.int> Function(List<int> x) f1250<B extends core.int>() => null;
+core.List<core.int> Function(List<int> x) f1251<B extends core.int>(int x) => null;
+core.List<core.int> Function([List<int> x]) f1252() => null;
+core.List<core.int> Function([List<int> x]) f1253(int x) => null;
+core.List<core.int> Function([List<int> x]) f1254<B extends core.int>() => null;
+core.List<core.int> Function([List<int> x]) f1255<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [List<int> x]) f1256() => null;
+core.List<core.int> Function(int x0, [List<int> x]) f1257(int x) => null;
+core.List<core.int> Function(int x0, [List<int> x]) f1258<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [List<int> x]) f1259<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, [List<int> x]) f1260() => null;
+core.List<core.int> Function(int y, [List<int> x]) f1261(int x) => null;
+core.List<core.int> Function(int y, [List<int> x]) f1262<B extends core.int>() => null;
+core.List<core.int> Function(int y, [List<int> x]) f1263<B extends core.int>(int x) => null;
+core.List<core.int> Function(List<int> x0) f1264() => null;
+core.List<core.int> Function(List<int> x0) f1265(int x) => null;
+core.List<core.int> Function(List<int> x0) f1266<B extends core.int>() => null;
+core.List<core.int> Function(List<int> x0) f1267<B extends core.int>(int x) => null;
+core.List<core.int> Function([List<int> x0]) f1268() => null;
+core.List<core.int> Function([List<int> x0]) f1269(int x) => null;
+core.List<core.int> Function([List<int> x0]) f1270<B extends core.int>() => null;
+core.List<core.int> Function([List<int> x0]) f1271<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, [List<int> x1]) f1272() => null;
+core.List<core.int> Function(int x0, [List<int> x1]) f1273(int x) => null;
+core.List<core.int> Function(int x0, [List<int> x1]) f1274<B extends core.int>() => null;
+core.List<core.int> Function(int x0, [List<int> x1]) f1275<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x, [List<int> x0]) f1276() => null;
+core.List<core.int> Function(int x, [List<int> x0]) f1277(int x) => null;
+core.List<core.int> Function(int x, [List<int> x0]) f1278<B extends core.int>() => null;
+core.List<core.int> Function(int x, [List<int> x0]) f1279<B extends core.int>(int x) => null;
+core.List<core.int> Function({List<int> x}) f1280() => null;
+core.List<core.int> Function({List<int> x}) f1281(int x) => null;
+core.List<core.int> Function({List<int> x}) f1282<B extends core.int>() => null;
+core.List<core.int> Function({List<int> x}) f1283<B extends core.int>(int x) => null;
+core.List<core.int> Function(int x0, {List<int> x}) f1284() => null;
+core.List<core.int> Function(int x0, {List<int> x}) f1285(int x) => null;
+core.List<core.int> Function(int x0, {List<int> x}) f1286<B extends core.int>() => null;
+core.List<core.int> Function(int x0, {List<int> x}) f1287<B extends core.int>(int x) => null;
+core.List<core.int> Function(int y, {List<int> x}) f1288() => null;
+core.List<core.int> Function(int y, {List<int> x}) f1289(int x) => null;
+core.List<core.int> Function(int y, {List<int> x}) f1290<B extends core.int>() => null;
+core.List<core.int> Function(int y, {List<int> x}) f1291<B extends core.int>(int x) => null;
+core.List<core.int> Function() f1292() => null;
+core.List<core.int> Function() f1293(int x) => null;
+core.List<core.int> Function() f1294<B extends core.int>() => null;
+core.List<core.int> Function() f1295<B extends core.int>(int x) => null;
+List<int> Function(int x) f1296() => null;
+List<int> Function(int x) f1297(int x) => null;
+List<int> Function(int x) f1298<B extends core.int>() => null;
+List<int> Function(int x) f1299<B extends core.int>(int x) => null;
+List<int> Function([int x]) f1300() => null;
+List<int> Function([int x]) f1301(int x) => null;
+List<int> Function([int x]) f1302<B extends core.int>() => null;
+List<int> Function([int x]) f1303<B extends core.int>(int x) => null;
+List<int> Function(int x0, [int x]) f1304() => null;
+List<int> Function(int x0, [int x]) f1305(int x) => null;
+List<int> Function(int x0, [int x]) f1306<B extends core.int>() => null;
+List<int> Function(int x0, [int x]) f1307<B extends core.int>(int x) => null;
+List<int> Function(int y, [int x]) f1308() => null;
+List<int> Function(int y, [int x]) f1309(int x) => null;
+List<int> Function(int y, [int x]) f1310<B extends core.int>() => null;
+List<int> Function(int y, [int x]) f1311<B extends core.int>(int x) => null;
+List<int> Function(int x0) f1312() => null;
+List<int> Function(int x0) f1313(int x) => null;
+List<int> Function(int x0) f1314<B extends core.int>() => null;
+List<int> Function(int x0) f1315<B extends core.int>(int x) => null;
+List<int> Function([int x0]) f1316() => null;
+List<int> Function([int x0]) f1317(int x) => null;
+List<int> Function([int x0]) f1318<B extends core.int>() => null;
+List<int> Function([int x0]) f1319<B extends core.int>(int x) => null;
+List<int> Function(int x0, [int x1]) f1320() => null;
+List<int> Function(int x0, [int x1]) f1321(int x) => null;
+List<int> Function(int x0, [int x1]) f1322<B extends core.int>() => null;
+List<int> Function(int x0, [int x1]) f1323<B extends core.int>(int x) => null;
+List<int> Function(int x, [int x0]) f1324() => null;
+List<int> Function(int x, [int x0]) f1325(int x) => null;
+List<int> Function(int x, [int x0]) f1326<B extends core.int>() => null;
+List<int> Function(int x, [int x0]) f1327<B extends core.int>(int x) => null;
+List<int> Function({int x}) f1328() => null;
+List<int> Function({int x}) f1329(int x) => null;
+List<int> Function({int x}) f1330<B extends core.int>() => null;
+List<int> Function({int x}) f1331<B extends core.int>(int x) => null;
+List<int> Function(int x0, {int x}) f1332() => null;
+List<int> Function(int x0, {int x}) f1333(int x) => null;
+List<int> Function(int x0, {int x}) f1334<B extends core.int>() => null;
+List<int> Function(int x0, {int x}) f1335<B extends core.int>(int x) => null;
+List<int> Function(int y, {int x}) f1336() => null;
+List<int> Function(int y, {int x}) f1337(int x) => null;
+List<int> Function(int y, {int x}) f1338<B extends core.int>() => null;
+List<int> Function(int y, {int x}) f1339<B extends core.int>(int x) => null;
+List<int> Function(Function x) f1340() => null;
+List<int> Function(Function x) f1341(int x) => null;
+List<int> Function(Function x) f1342<B extends core.int>() => null;
+List<int> Function(Function x) f1343<B extends core.int>(int x) => null;
+List<int> Function([Function x]) f1344() => null;
+List<int> Function([Function x]) f1345(int x) => null;
+List<int> Function([Function x]) f1346<B extends core.int>() => null;
+List<int> Function([Function x]) f1347<B extends core.int>(int x) => null;
+List<int> Function(int x0, [Function x]) f1348() => null;
+List<int> Function(int x0, [Function x]) f1349(int x) => null;
+List<int> Function(int x0, [Function x]) f1350<B extends core.int>() => null;
+List<int> Function(int x0, [Function x]) f1351<B extends core.int>(int x) => null;
+List<int> Function(int y, [Function x]) f1352() => null;
+List<int> Function(int y, [Function x]) f1353(int x) => null;
+List<int> Function(int y, [Function x]) f1354<B extends core.int>() => null;
+List<int> Function(int y, [Function x]) f1355<B extends core.int>(int x) => null;
+List<int> Function(Function x0) f1356() => null;
+List<int> Function(Function x0) f1357(int x) => null;
+List<int> Function(Function x0) f1358<B extends core.int>() => null;
+List<int> Function(Function x0) f1359<B extends core.int>(int x) => null;
+List<int> Function([Function x0]) f1360() => null;
+List<int> Function([Function x0]) f1361(int x) => null;
+List<int> Function([Function x0]) f1362<B extends core.int>() => null;
+List<int> Function([Function x0]) f1363<B extends core.int>(int x) => null;
+List<int> Function(int x0, [Function x1]) f1364() => null;
+List<int> Function(int x0, [Function x1]) f1365(int x) => null;
+List<int> Function(int x0, [Function x1]) f1366<B extends core.int>() => null;
+List<int> Function(int x0, [Function x1]) f1367<B extends core.int>(int x) => null;
+List<int> Function(int x, [Function x0]) f1368() => null;
+List<int> Function(int x, [Function x0]) f1369(int x) => null;
+List<int> Function(int x, [Function x0]) f1370<B extends core.int>() => null;
+List<int> Function(int x, [Function x0]) f1371<B extends core.int>(int x) => null;
+List<int> Function({Function x}) f1372() => null;
+List<int> Function({Function x}) f1373(int x) => null;
+List<int> Function({Function x}) f1374<B extends core.int>() => null;
+List<int> Function({Function x}) f1375<B extends core.int>(int x) => null;
+List<int> Function(int x0, {Function x}) f1376() => null;
+List<int> Function(int x0, {Function x}) f1377(int x) => null;
+List<int> Function(int x0, {Function x}) f1378<B extends core.int>() => null;
+List<int> Function(int x0, {Function x}) f1379<B extends core.int>(int x) => null;
+List<int> Function(int y, {Function x}) f1380() => null;
+List<int> Function(int y, {Function x}) f1381(int x) => null;
+List<int> Function(int y, {Function x}) f1382<B extends core.int>() => null;
+List<int> Function(int y, {Function x}) f1383<B extends core.int>(int x) => null;
+List<int> Function(List<Function> x) f1384() => null;
+List<int> Function(List<Function> x) f1385(int x) => null;
+List<int> Function(List<Function> x) f1386<B extends core.int>() => null;
+List<int> Function(List<Function> x) f1387<B extends core.int>(int x) => null;
+List<int> Function([List<Function> x]) f1388() => null;
+List<int> Function([List<Function> x]) f1389(int x) => null;
+List<int> Function([List<Function> x]) f1390<B extends core.int>() => null;
+List<int> Function([List<Function> x]) f1391<B extends core.int>(int x) => null;
+List<int> Function(int x0, [List<Function> x]) f1392() => null;
+List<int> Function(int x0, [List<Function> x]) f1393(int x) => null;
+List<int> Function(int x0, [List<Function> x]) f1394<B extends core.int>() => null;
+List<int> Function(int x0, [List<Function> x]) f1395<B extends core.int>(int x) => null;
+List<int> Function(int y, [List<Function> x]) f1396() => null;
+List<int> Function(int y, [List<Function> x]) f1397(int x) => null;
+List<int> Function(int y, [List<Function> x]) f1398<B extends core.int>() => null;
+List<int> Function(int y, [List<Function> x]) f1399<B extends core.int>(int x) => null;
+List<int> Function(List<Function> x0) f1400() => null;
+List<int> Function(List<Function> x0) f1401(int x) => null;
+List<int> Function(List<Function> x0) f1402<B extends core.int>() => null;
+List<int> Function(List<Function> x0) f1403<B extends core.int>(int x) => null;
+List<int> Function([List<Function> x0]) f1404() => null;
+List<int> Function([List<Function> x0]) f1405(int x) => null;
+List<int> Function([List<Function> x0]) f1406<B extends core.int>() => null;
+List<int> Function([List<Function> x0]) f1407<B extends core.int>(int x) => null;
+List<int> Function(int x0, [List<Function> x1]) f1408() => null;
+List<int> Function(int x0, [List<Function> x1]) f1409(int x) => null;
+List<int> Function(int x0, [List<Function> x1]) f1410<B extends core.int>() => null;
+List<int> Function(int x0, [List<Function> x1]) f1411<B extends core.int>(int x) => null;
+List<int> Function(int x, [List<Function> x0]) f1412() => null;
+List<int> Function(int x, [List<Function> x0]) f1413(int x) => null;
+List<int> Function(int x, [List<Function> x0]) f1414<B extends core.int>() => null;
+List<int> Function(int x, [List<Function> x0]) f1415<B extends core.int>(int x) => null;
+List<int> Function({List<Function> x}) f1416() => null;
+List<int> Function({List<Function> x}) f1417(int x) => null;
+List<int> Function({List<Function> x}) f1418<B extends core.int>() => null;
+List<int> Function({List<Function> x}) f1419<B extends core.int>(int x) => null;
+List<int> Function(int x0, {List<Function> x}) f1420() => null;
+List<int> Function(int x0, {List<Function> x}) f1421(int x) => null;
+List<int> Function(int x0, {List<Function> x}) f1422<B extends core.int>() => null;
+List<int> Function(int x0, {List<Function> x}) f1423<B extends core.int>(int x) => null;
+List<int> Function(int y, {List<Function> x}) f1424() => null;
+List<int> Function(int y, {List<Function> x}) f1425(int x) => null;
+List<int> Function(int y, {List<Function> x}) f1426<B extends core.int>() => null;
+List<int> Function(int y, {List<Function> x}) f1427<B extends core.int>(int x) => null;
+List<int> Function(core.List<core.int> x) f1428() => null;
+List<int> Function(core.List<core.int> x) f1429(int x) => null;
+List<int> Function(core.List<core.int> x) f1430<B extends core.int>() => null;
+List<int> Function(core.List<core.int> x) f1431<B extends core.int>(int x) => null;
+List<int> Function([core.List<core.int> x]) f1432() => null;
+List<int> Function([core.List<core.int> x]) f1433(int x) => null;
+List<int> Function([core.List<core.int> x]) f1434<B extends core.int>() => null;
+List<int> Function([core.List<core.int> x]) f1435<B extends core.int>(int x) => null;
+List<int> Function(int x0, [core.List<core.int> x]) f1436() => null;
+List<int> Function(int x0, [core.List<core.int> x]) f1437(int x) => null;
+List<int> Function(int x0, [core.List<core.int> x]) f1438<B extends core.int>() => null;
+List<int> Function(int x0, [core.List<core.int> x]) f1439<B extends core.int>(int x) => null;
+List<int> Function(int y, [core.List<core.int> x]) f1440() => null;
+List<int> Function(int y, [core.List<core.int> x]) f1441(int x) => null;
+List<int> Function(int y, [core.List<core.int> x]) f1442<B extends core.int>() => null;
+List<int> Function(int y, [core.List<core.int> x]) f1443<B extends core.int>(int x) => null;
+List<int> Function(core.List<core.int> x0) f1444() => null;
+List<int> Function(core.List<core.int> x0) f1445(int x) => null;
+List<int> Function(core.List<core.int> x0) f1446<B extends core.int>() => null;
+List<int> Function(core.List<core.int> x0) f1447<B extends core.int>(int x) => null;
+List<int> Function([core.List<core.int> x0]) f1448() => null;
+List<int> Function([core.List<core.int> x0]) f1449(int x) => null;
+List<int> Function([core.List<core.int> x0]) f1450<B extends core.int>() => null;
+List<int> Function([core.List<core.int> x0]) f1451<B extends core.int>(int x) => null;
+List<int> Function(int x0, [core.List<core.int> x1]) f1452() => null;
+List<int> Function(int x0, [core.List<core.int> x1]) f1453(int x) => null;
+List<int> Function(int x0, [core.List<core.int> x1]) f1454<B extends core.int>() => null;
+List<int> Function(int x0, [core.List<core.int> x1]) f1455<B extends core.int>(int x) => null;
+List<int> Function(int x, [core.List<core.int> x0]) f1456() => null;
+List<int> Function(int x, [core.List<core.int> x0]) f1457(int x) => null;
+List<int> Function(int x, [core.List<core.int> x0]) f1458<B extends core.int>() => null;
+List<int> Function(int x, [core.List<core.int> x0]) f1459<B extends core.int>(int x) => null;
+List<int> Function({core.List<core.int> x}) f1460() => null;
+List<int> Function({core.List<core.int> x}) f1461(int x) => null;
+List<int> Function({core.List<core.int> x}) f1462<B extends core.int>() => null;
+List<int> Function({core.List<core.int> x}) f1463<B extends core.int>(int x) => null;
+List<int> Function(int x0, {core.List<core.int> x}) f1464() => null;
+List<int> Function(int x0, {core.List<core.int> x}) f1465(int x) => null;
+List<int> Function(int x0, {core.List<core.int> x}) f1466<B extends core.int>() => null;
+List<int> Function(int x0, {core.List<core.int> x}) f1467<B extends core.int>(int x) => null;
+List<int> Function(int y, {core.List<core.int> x}) f1468() => null;
+List<int> Function(int y, {core.List<core.int> x}) f1469(int x) => null;
+List<int> Function(int y, {core.List<core.int> x}) f1470<B extends core.int>() => null;
+List<int> Function(int y, {core.List<core.int> x}) f1471<B extends core.int>(int x) => null;
+List<int> Function(List<int> x) f1472() => null;
+List<int> Function(List<int> x) f1473(int x) => null;
+List<int> Function(List<int> x) f1474<B extends core.int>() => null;
+List<int> Function(List<int> x) f1475<B extends core.int>(int x) => null;
+List<int> Function([List<int> x]) f1476() => null;
+List<int> Function([List<int> x]) f1477(int x) => null;
+List<int> Function([List<int> x]) f1478<B extends core.int>() => null;
+List<int> Function([List<int> x]) f1479<B extends core.int>(int x) => null;
+List<int> Function(int x0, [List<int> x]) f1480() => null;
+List<int> Function(int x0, [List<int> x]) f1481(int x) => null;
+List<int> Function(int x0, [List<int> x]) f1482<B extends core.int>() => null;
+List<int> Function(int x0, [List<int> x]) f1483<B extends core.int>(int x) => null;
+List<int> Function(int y, [List<int> x]) f1484() => null;
+List<int> Function(int y, [List<int> x]) f1485(int x) => null;
+List<int> Function(int y, [List<int> x]) f1486<B extends core.int>() => null;
+List<int> Function(int y, [List<int> x]) f1487<B extends core.int>(int x) => null;
+List<int> Function(List<int> x0) f1488() => null;
+List<int> Function(List<int> x0) f1489(int x) => null;
+List<int> Function(List<int> x0) f1490<B extends core.int>() => null;
+List<int> Function(List<int> x0) f1491<B extends core.int>(int x) => null;
+List<int> Function([List<int> x0]) f1492() => null;
+List<int> Function([List<int> x0]) f1493(int x) => null;
+List<int> Function([List<int> x0]) f1494<B extends core.int>() => null;
+List<int> Function([List<int> x0]) f1495<B extends core.int>(int x) => null;
+List<int> Function(int x0, [List<int> x1]) f1496() => null;
+List<int> Function(int x0, [List<int> x1]) f1497(int x) => null;
+List<int> Function(int x0, [List<int> x1]) f1498<B extends core.int>() => null;
+List<int> Function(int x0, [List<int> x1]) f1499<B extends core.int>(int x) => null;
+List<int> Function(int x, [List<int> x0]) f1500() => null;
+List<int> Function(int x, [List<int> x0]) f1501(int x) => null;
+List<int> Function(int x, [List<int> x0]) f1502<B extends core.int>() => null;
+List<int> Function(int x, [List<int> x0]) f1503<B extends core.int>(int x) => null;
+List<int> Function({List<int> x}) f1504() => null;
+List<int> Function({List<int> x}) f1505(int x) => null;
+List<int> Function({List<int> x}) f1506<B extends core.int>() => null;
+List<int> Function({List<int> x}) f1507<B extends core.int>(int x) => null;
+List<int> Function(int x0, {List<int> x}) f1508() => null;
+List<int> Function(int x0, {List<int> x}) f1509(int x) => null;
+List<int> Function(int x0, {List<int> x}) f1510<B extends core.int>() => null;
+List<int> Function(int x0, {List<int> x}) f1511<B extends core.int>(int x) => null;
+List<int> Function(int y, {List<int> x}) f1512() => null;
+List<int> Function(int y, {List<int> x}) f1513(int x) => null;
+List<int> Function(int y, {List<int> x}) f1514<B extends core.int>() => null;
+List<int> Function(int y, {List<int> x}) f1515<B extends core.int>(int x) => null;
+List<int> Function() f1516() => null;
+List<int> Function() f1517(int x) => null;
+List<int> Function() f1518<B extends core.int>() => null;
+List<int> Function() f1519<B extends core.int>(int x) => null;
+Function(int x) f1520() => null;
+Function(int x) f1521(int x) => null;
+Function(int x) f1522<B extends core.int>() => null;
+Function(int x) f1523<B extends core.int>(int x) => null;
+Function([int x]) f1524() => null;
+Function([int x]) f1525(int x) => null;
+Function([int x]) f1526<B extends core.int>() => null;
+Function([int x]) f1527<B extends core.int>(int x) => null;
+Function(int x0, [int x]) f1528() => null;
+Function(int x0, [int x]) f1529(int x) => null;
+Function(int x0, [int x]) f1530<B extends core.int>() => null;
+Function(int x0, [int x]) f1531<B extends core.int>(int x) => null;
+Function(int y, [int x]) f1532() => null;
+Function(int y, [int x]) f1533(int x) => null;
+Function(int y, [int x]) f1534<B extends core.int>() => null;
+Function(int y, [int x]) f1535<B extends core.int>(int x) => null;
+Function(int x0) f1536() => null;
+Function(int x0) f1537(int x) => null;
+Function(int x0) f1538<B extends core.int>() => null;
+Function(int x0) f1539<B extends core.int>(int x) => null;
+Function([int x0]) f1540() => null;
+Function([int x0]) f1541(int x) => null;
+Function([int x0]) f1542<B extends core.int>() => null;
+Function([int x0]) f1543<B extends core.int>(int x) => null;
+Function(int x0, [int x1]) f1544() => null;
+Function(int x0, [int x1]) f1545(int x) => null;
+Function(int x0, [int x1]) f1546<B extends core.int>() => null;
+Function(int x0, [int x1]) f1547<B extends core.int>(int x) => null;
+Function(int x, [int x0]) f1548() => null;
+Function(int x, [int x0]) f1549(int x) => null;
+Function(int x, [int x0]) f1550<B extends core.int>() => null;
+Function(int x, [int x0]) f1551<B extends core.int>(int x) => null;
+Function({int x}) f1552() => null;
+Function({int x}) f1553(int x) => null;
+Function({int x}) f1554<B extends core.int>() => null;
+Function({int x}) f1555<B extends core.int>(int x) => null;
+Function(int x0, {int x}) f1556() => null;
+Function(int x0, {int x}) f1557(int x) => null;
+Function(int x0, {int x}) f1558<B extends core.int>() => null;
+Function(int x0, {int x}) f1559<B extends core.int>(int x) => null;
+Function(int y, {int x}) f1560() => null;
+Function(int y, {int x}) f1561(int x) => null;
+Function(int y, {int x}) f1562<B extends core.int>() => null;
+Function(int y, {int x}) f1563<B extends core.int>(int x) => null;
+Function(Function x) f1564() => null;
+Function(Function x) f1565(int x) => null;
+Function(Function x) f1566<B extends core.int>() => null;
+Function(Function x) f1567<B extends core.int>(int x) => null;
+Function([Function x]) f1568() => null;
+Function([Function x]) f1569(int x) => null;
+Function([Function x]) f1570<B extends core.int>() => null;
+Function([Function x]) f1571<B extends core.int>(int x) => null;
+Function(int x0, [Function x]) f1572() => null;
+Function(int x0, [Function x]) f1573(int x) => null;
+Function(int x0, [Function x]) f1574<B extends core.int>() => null;
+Function(int x0, [Function x]) f1575<B extends core.int>(int x) => null;
+Function(int y, [Function x]) f1576() => null;
+Function(int y, [Function x]) f1577(int x) => null;
+Function(int y, [Function x]) f1578<B extends core.int>() => null;
+Function(int y, [Function x]) f1579<B extends core.int>(int x) => null;
+Function(Function x0) f1580() => null;
+Function(Function x0) f1581(int x) => null;
+Function(Function x0) f1582<B extends core.int>() => null;
+Function(Function x0) f1583<B extends core.int>(int x) => null;
+Function([Function x0]) f1584() => null;
+Function([Function x0]) f1585(int x) => null;
+Function([Function x0]) f1586<B extends core.int>() => null;
+Function([Function x0]) f1587<B extends core.int>(int x) => null;
+Function(int x0, [Function x1]) f1588() => null;
+Function(int x0, [Function x1]) f1589(int x) => null;
+Function(int x0, [Function x1]) f1590<B extends core.int>() => null;
+Function(int x0, [Function x1]) f1591<B extends core.int>(int x) => null;
+Function(int x, [Function x0]) f1592() => null;
+Function(int x, [Function x0]) f1593(int x) => null;
+Function(int x, [Function x0]) f1594<B extends core.int>() => null;
+Function(int x, [Function x0]) f1595<B extends core.int>(int x) => null;
+Function({Function x}) f1596() => null;
+Function({Function x}) f1597(int x) => null;
+Function({Function x}) f1598<B extends core.int>() => null;
+Function({Function x}) f1599<B extends core.int>(int x) => null;
+Function(int x0, {Function x}) f1600() => null;
+Function(int x0, {Function x}) f1601(int x) => null;
+Function(int x0, {Function x}) f1602<B extends core.int>() => null;
+Function(int x0, {Function x}) f1603<B extends core.int>(int x) => null;
+Function(int y, {Function x}) f1604() => null;
+Function(int y, {Function x}) f1605(int x) => null;
+Function(int y, {Function x}) f1606<B extends core.int>() => null;
+Function(int y, {Function x}) f1607<B extends core.int>(int x) => null;
+Function(List<Function> x) f1608() => null;
+Function(List<Function> x) f1609(int x) => null;
+Function(List<Function> x) f1610<B extends core.int>() => null;
+Function(List<Function> x) f1611<B extends core.int>(int x) => null;
+Function([List<Function> x]) f1612() => null;
+Function([List<Function> x]) f1613(int x) => null;
+Function([List<Function> x]) f1614<B extends core.int>() => null;
+Function([List<Function> x]) f1615<B extends core.int>(int x) => null;
+Function(int x0, [List<Function> x]) f1616() => null;
+Function(int x0, [List<Function> x]) f1617(int x) => null;
+Function(int x0, [List<Function> x]) f1618<B extends core.int>() => null;
+Function(int x0, [List<Function> x]) f1619<B extends core.int>(int x) => null;
+Function(int y, [List<Function> x]) f1620() => null;
+Function(int y, [List<Function> x]) f1621(int x) => null;
+Function(int y, [List<Function> x]) f1622<B extends core.int>() => null;
+Function(int y, [List<Function> x]) f1623<B extends core.int>(int x) => null;
+Function(List<Function> x0) f1624() => null;
+Function(List<Function> x0) f1625(int x) => null;
+Function(List<Function> x0) f1626<B extends core.int>() => null;
+Function(List<Function> x0) f1627<B extends core.int>(int x) => null;
+Function([List<Function> x0]) f1628() => null;
+Function([List<Function> x0]) f1629(int x) => null;
+Function([List<Function> x0]) f1630<B extends core.int>() => null;
+Function([List<Function> x0]) f1631<B extends core.int>(int x) => null;
+Function(int x0, [List<Function> x1]) f1632() => null;
+Function(int x0, [List<Function> x1]) f1633(int x) => null;
+Function(int x0, [List<Function> x1]) f1634<B extends core.int>() => null;
+Function(int x0, [List<Function> x1]) f1635<B extends core.int>(int x) => null;
+Function(int x, [List<Function> x0]) f1636() => null;
+Function(int x, [List<Function> x0]) f1637(int x) => null;
+Function(int x, [List<Function> x0]) f1638<B extends core.int>() => null;
+Function(int x, [List<Function> x0]) f1639<B extends core.int>(int x) => null;
+Function({List<Function> x}) f1640() => null;
+Function({List<Function> x}) f1641(int x) => null;
+Function({List<Function> x}) f1642<B extends core.int>() => null;
+Function({List<Function> x}) f1643<B extends core.int>(int x) => null;
+Function(int x0, {List<Function> x}) f1644() => null;
+Function(int x0, {List<Function> x}) f1645(int x) => null;
+Function(int x0, {List<Function> x}) f1646<B extends core.int>() => null;
+Function(int x0, {List<Function> x}) f1647<B extends core.int>(int x) => null;
+Function(int y, {List<Function> x}) f1648() => null;
+Function(int y, {List<Function> x}) f1649(int x) => null;
+Function(int y, {List<Function> x}) f1650<B extends core.int>() => null;
+Function(int y, {List<Function> x}) f1651<B extends core.int>(int x) => null;
+Function(core.List<core.int> x) f1652() => null;
+Function(core.List<core.int> x) f1653(int x) => null;
+Function(core.List<core.int> x) f1654<B extends core.int>() => null;
+Function(core.List<core.int> x) f1655<B extends core.int>(int x) => null;
+Function([core.List<core.int> x]) f1656() => null;
+Function([core.List<core.int> x]) f1657(int x) => null;
+Function([core.List<core.int> x]) f1658<B extends core.int>() => null;
+Function([core.List<core.int> x]) f1659<B extends core.int>(int x) => null;
+Function(int x0, [core.List<core.int> x]) f1660() => null;
+Function(int x0, [core.List<core.int> x]) f1661(int x) => null;
+Function(int x0, [core.List<core.int> x]) f1662<B extends core.int>() => null;
+Function(int x0, [core.List<core.int> x]) f1663<B extends core.int>(int x) => null;
+Function(int y, [core.List<core.int> x]) f1664() => null;
+Function(int y, [core.List<core.int> x]) f1665(int x) => null;
+Function(int y, [core.List<core.int> x]) f1666<B extends core.int>() => null;
+Function(int y, [core.List<core.int> x]) f1667<B extends core.int>(int x) => null;
+Function(core.List<core.int> x0) f1668() => null;
+Function(core.List<core.int> x0) f1669(int x) => null;
+Function(core.List<core.int> x0) f1670<B extends core.int>() => null;
+Function(core.List<core.int> x0) f1671<B extends core.int>(int x) => null;
+Function([core.List<core.int> x0]) f1672() => null;
+Function([core.List<core.int> x0]) f1673(int x) => null;
+Function([core.List<core.int> x0]) f1674<B extends core.int>() => null;
+Function([core.List<core.int> x0]) f1675<B extends core.int>(int x) => null;
+Function(int x0, [core.List<core.int> x1]) f1676() => null;
+Function(int x0, [core.List<core.int> x1]) f1677(int x) => null;
+Function(int x0, [core.List<core.int> x1]) f1678<B extends core.int>() => null;
+Function(int x0, [core.List<core.int> x1]) f1679<B extends core.int>(int x) => null;
+Function(int x, [core.List<core.int> x0]) f1680() => null;
+Function(int x, [core.List<core.int> x0]) f1681(int x) => null;
+Function(int x, [core.List<core.int> x0]) f1682<B extends core.int>() => null;
+Function(int x, [core.List<core.int> x0]) f1683<B extends core.int>(int x) => null;
+Function({core.List<core.int> x}) f1684() => null;
+Function({core.List<core.int> x}) f1685(int x) => null;
+Function({core.List<core.int> x}) f1686<B extends core.int>() => null;
+Function({core.List<core.int> x}) f1687<B extends core.int>(int x) => null;
+Function(int x0, {core.List<core.int> x}) f1688() => null;
+Function(int x0, {core.List<core.int> x}) f1689(int x) => null;
+Function(int x0, {core.List<core.int> x}) f1690<B extends core.int>() => null;
+Function(int x0, {core.List<core.int> x}) f1691<B extends core.int>(int x) => null;
+Function(int y, {core.List<core.int> x}) f1692() => null;
+Function(int y, {core.List<core.int> x}) f1693(int x) => null;
+Function(int y, {core.List<core.int> x}) f1694<B extends core.int>() => null;
+Function(int y, {core.List<core.int> x}) f1695<B extends core.int>(int x) => null;
+Function(List<int> x) f1696() => null;
+Function(List<int> x) f1697(int x) => null;
+Function(List<int> x) f1698<B extends core.int>() => null;
+Function(List<int> x) f1699<B extends core.int>(int x) => null;
+Function([List<int> x]) f1700() => null;
+Function([List<int> x]) f1701(int x) => null;
+Function([List<int> x]) f1702<B extends core.int>() => null;
+Function([List<int> x]) f1703<B extends core.int>(int x) => null;
+Function(int x0, [List<int> x]) f1704() => null;
+Function(int x0, [List<int> x]) f1705(int x) => null;
+Function(int x0, [List<int> x]) f1706<B extends core.int>() => null;
+Function(int x0, [List<int> x]) f1707<B extends core.int>(int x) => null;
+Function(int y, [List<int> x]) f1708() => null;
+Function(int y, [List<int> x]) f1709(int x) => null;
+Function(int y, [List<int> x]) f1710<B extends core.int>() => null;
+Function(int y, [List<int> x]) f1711<B extends core.int>(int x) => null;
+Function(List<int> x0) f1712() => null;
+Function(List<int> x0) f1713(int x) => null;
+Function(List<int> x0) f1714<B extends core.int>() => null;
+Function(List<int> x0) f1715<B extends core.int>(int x) => null;
+Function([List<int> x0]) f1716() => null;
+Function([List<int> x0]) f1717(int x) => null;
+Function([List<int> x0]) f1718<B extends core.int>() => null;
+Function([List<int> x0]) f1719<B extends core.int>(int x) => null;
+Function(int x0, [List<int> x1]) f1720() => null;
+Function(int x0, [List<int> x1]) f1721(int x) => null;
+Function(int x0, [List<int> x1]) f1722<B extends core.int>() => null;
+Function(int x0, [List<int> x1]) f1723<B extends core.int>(int x) => null;
+Function(int x, [List<int> x0]) f1724() => null;
+Function(int x, [List<int> x0]) f1725(int x) => null;
+Function(int x, [List<int> x0]) f1726<B extends core.int>() => null;
+Function(int x, [List<int> x0]) f1727<B extends core.int>(int x) => null;
+Function({List<int> x}) f1728() => null;
+Function({List<int> x}) f1729(int x) => null;
+Function({List<int> x}) f1730<B extends core.int>() => null;
+Function({List<int> x}) f1731<B extends core.int>(int x) => null;
+Function(int x0, {List<int> x}) f1732() => null;
+Function(int x0, {List<int> x}) f1733(int x) => null;
+Function(int x0, {List<int> x}) f1734<B extends core.int>() => null;
+Function(int x0, {List<int> x}) f1735<B extends core.int>(int x) => null;
+Function(int y, {List<int> x}) f1736() => null;
+Function(int y, {List<int> x}) f1737(int x) => null;
+Function(int y, {List<int> x}) f1738<B extends core.int>() => null;
+Function(int y, {List<int> x}) f1739<B extends core.int>(int x) => null;
+Function() f1740() => null;
+Function() f1741(int x) => null;
+Function() f1742<B extends core.int>() => null;
+Function() f1743<B extends core.int>(int x) => null;
+int Function<A>(int x) f1744() => null;
+int Function<A>(int x) f1745(int x) => null;
+int Function<A>(int x) f1746<B extends core.int>() => null;
+int Function<A>(int x) f1747<B extends core.int>(int x) => null;
+int Function<A>(Function x) f1748() => null;
+int Function<A>(Function x) f1749(int x) => null;
+int Function<A>(Function x) f1750<B extends core.int>() => null;
+int Function<A>(Function x) f1751<B extends core.int>(int x) => null;
+int Function<A>(List<Function> x) f1752() => null;
+int Function<A>(List<Function> x) f1753(int x) => null;
+int Function<A>(List<Function> x) f1754<B extends core.int>() => null;
+int Function<A>(List<Function> x) f1755<B extends core.int>(int x) => null;
+int Function<A>(core.List<core.int> x) f1756() => null;
+int Function<A>(core.List<core.int> x) f1757(int x) => null;
+int Function<A>(core.List<core.int> x) f1758<B extends core.int>() => null;
+int Function<A>(core.List<core.int> x) f1759<B extends core.int>(int x) => null;
+int Function<A>(List<int> x) f1760() => null;
+int Function<A>(List<int> x) f1761(int x) => null;
+int Function<A>(List<int> x) f1762<B extends core.int>() => null;
+int Function<A>(List<int> x) f1763<B extends core.int>(int x) => null;
+int Function<A>() f1764() => null;
+int Function<A>() f1765(int x) => null;
+int Function<A>() f1766<B extends core.int>() => null;
+int Function<A>() f1767<B extends core.int>(int x) => null;
+int Function<A>(A x) f1768() => null;
+int Function<A>(A x) f1769(int x) => null;
+int Function<A>(A x) f1770<B extends core.int>() => null;
+int Function<A>(A x) f1771<B extends core.int>(int x) => null;
+int Function<A>(List<A> x) f1772() => null;
+int Function<A>(List<A> x) f1773(int x) => null;
+int Function<A>(List<A> x) f1774<B extends core.int>() => null;
+int Function<A>(List<A> x) f1775<B extends core.int>(int x) => null;
+Function Function<A>(int x) f1776() => null;
+Function Function<A>(int x) f1777(int x) => null;
+Function Function<A>(int x) f1778<B extends core.int>() => null;
+Function Function<A>(int x) f1779<B extends core.int>(int x) => null;
+Function Function<A>(Function x) f1780() => null;
+Function Function<A>(Function x) f1781(int x) => null;
+Function Function<A>(Function x) f1782<B extends core.int>() => null;
+Function Function<A>(Function x) f1783<B extends core.int>(int x) => null;
+Function Function<A>(List<Function> x) f1784() => null;
+Function Function<A>(List<Function> x) f1785(int x) => null;
+Function Function<A>(List<Function> x) f1786<B extends core.int>() => null;
+Function Function<A>(List<Function> x) f1787<B extends core.int>(int x) => null;
+Function Function<A>(core.List<core.int> x) f1788() => null;
+Function Function<A>(core.List<core.int> x) f1789(int x) => null;
+Function Function<A>(core.List<core.int> x) f1790<B extends core.int>() => null;
+Function Function<A>(core.List<core.int> x) f1791<B extends core.int>(int x) => null;
+Function Function<A>(List<int> x) f1792() => null;
+Function Function<A>(List<int> x) f1793(int x) => null;
+Function Function<A>(List<int> x) f1794<B extends core.int>() => null;
+Function Function<A>(List<int> x) f1795<B extends core.int>(int x) => null;
+Function Function<A>() f1796() => null;
+Function Function<A>() f1797(int x) => null;
+Function Function<A>() f1798<B extends core.int>() => null;
+Function Function<A>() f1799<B extends core.int>(int x) => null;
+Function Function<A>(A x) f1800() => null;
+Function Function<A>(A x) f1801(int x) => null;
+Function Function<A>(A x) f1802<B extends core.int>() => null;
+Function Function<A>(A x) f1803<B extends core.int>(int x) => null;
+Function Function<A>(List<A> x) f1804() => null;
+Function Function<A>(List<A> x) f1805(int x) => null;
+Function Function<A>(List<A> x) f1806<B extends core.int>() => null;
+Function Function<A>(List<A> x) f1807<B extends core.int>(int x) => null;
+List<Function> Function<A>(int x) f1808() => null;
+List<Function> Function<A>(int x) f1809(int x) => null;
+List<Function> Function<A>(int x) f1810<B extends core.int>() => null;
+List<Function> Function<A>(int x) f1811<B extends core.int>(int x) => null;
+List<Function> Function<A>(Function x) f1812() => null;
+List<Function> Function<A>(Function x) f1813(int x) => null;
+List<Function> Function<A>(Function x) f1814<B extends core.int>() => null;
+List<Function> Function<A>(Function x) f1815<B extends core.int>(int x) => null;
+List<Function> Function<A>(List<Function> x) f1816() => null;
+List<Function> Function<A>(List<Function> x) f1817(int x) => null;
+List<Function> Function<A>(List<Function> x) f1818<B extends core.int>() => null;
+List<Function> Function<A>(List<Function> x) f1819<B extends core.int>(int x) => null;
+List<Function> Function<A>(core.List<core.int> x) f1820() => null;
+List<Function> Function<A>(core.List<core.int> x) f1821(int x) => null;
+List<Function> Function<A>(core.List<core.int> x) f1822<B extends core.int>() => null;
+List<Function> Function<A>(core.List<core.int> x) f1823<B extends core.int>(int x) => null;
+List<Function> Function<A>(List<int> x) f1824() => null;
+List<Function> Function<A>(List<int> x) f1825(int x) => null;
+List<Function> Function<A>(List<int> x) f1826<B extends core.int>() => null;
+List<Function> Function<A>(List<int> x) f1827<B extends core.int>(int x) => null;
+List<Function> Function<A>() f1828() => null;
+List<Function> Function<A>() f1829(int x) => null;
+List<Function> Function<A>() f1830<B extends core.int>() => null;
+List<Function> Function<A>() f1831<B extends core.int>(int x) => null;
+List<Function> Function<A>(A x) f1832() => null;
+List<Function> Function<A>(A x) f1833(int x) => null;
+List<Function> Function<A>(A x) f1834<B extends core.int>() => null;
+List<Function> Function<A>(A x) f1835<B extends core.int>(int x) => null;
+List<Function> Function<A>(List<A> x) f1836() => null;
+List<Function> Function<A>(List<A> x) f1837(int x) => null;
+List<Function> Function<A>(List<A> x) f1838<B extends core.int>() => null;
+List<Function> Function<A>(List<A> x) f1839<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(int x) f1840() => null;
+core.List<core.int> Function<A>(int x) f1841(int x) => null;
+core.List<core.int> Function<A>(int x) f1842<B extends core.int>() => null;
+core.List<core.int> Function<A>(int x) f1843<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(Function x) f1844() => null;
+core.List<core.int> Function<A>(Function x) f1845(int x) => null;
+core.List<core.int> Function<A>(Function x) f1846<B extends core.int>() => null;
+core.List<core.int> Function<A>(Function x) f1847<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(List<Function> x) f1848() => null;
+core.List<core.int> Function<A>(List<Function> x) f1849(int x) => null;
+core.List<core.int> Function<A>(List<Function> x) f1850<B extends core.int>() => null;
+core.List<core.int> Function<A>(List<Function> x) f1851<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(core.List<core.int> x) f1852() => null;
+core.List<core.int> Function<A>(core.List<core.int> x) f1853(int x) => null;
+core.List<core.int> Function<A>(core.List<core.int> x) f1854<B extends core.int>() => null;
+core.List<core.int> Function<A>(core.List<core.int> x) f1855<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(List<int> x) f1856() => null;
+core.List<core.int> Function<A>(List<int> x) f1857(int x) => null;
+core.List<core.int> Function<A>(List<int> x) f1858<B extends core.int>() => null;
+core.List<core.int> Function<A>(List<int> x) f1859<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>() f1860() => null;
+core.List<core.int> Function<A>() f1861(int x) => null;
+core.List<core.int> Function<A>() f1862<B extends core.int>() => null;
+core.List<core.int> Function<A>() f1863<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(A x) f1864() => null;
+core.List<core.int> Function<A>(A x) f1865(int x) => null;
+core.List<core.int> Function<A>(A x) f1866<B extends core.int>() => null;
+core.List<core.int> Function<A>(A x) f1867<B extends core.int>(int x) => null;
+core.List<core.int> Function<A>(List<A> x) f1868() => null;
+core.List<core.int> Function<A>(List<A> x) f1869(int x) => null;
+core.List<core.int> Function<A>(List<A> x) f1870<B extends core.int>() => null;
+core.List<core.int> Function<A>(List<A> x) f1871<B extends core.int>(int x) => null;
+List<int> Function<A>(int x) f1872() => null;
+List<int> Function<A>(int x) f1873(int x) => null;
+List<int> Function<A>(int x) f1874<B extends core.int>() => null;
+List<int> Function<A>(int x) f1875<B extends core.int>(int x) => null;
+List<int> Function<A>(Function x) f1876() => null;
+List<int> Function<A>(Function x) f1877(int x) => null;
+List<int> Function<A>(Function x) f1878<B extends core.int>() => null;
+List<int> Function<A>(Function x) f1879<B extends core.int>(int x) => null;
+List<int> Function<A>(List<Function> x) f1880() => null;
+List<int> Function<A>(List<Function> x) f1881(int x) => null;
+List<int> Function<A>(List<Function> x) f1882<B extends core.int>() => null;
+List<int> Function<A>(List<Function> x) f1883<B extends core.int>(int x) => null;
+List<int> Function<A>(core.List<core.int> x) f1884() => null;
+List<int> Function<A>(core.List<core.int> x) f1885(int x) => null;
+List<int> Function<A>(core.List<core.int> x) f1886<B extends core.int>() => null;
+List<int> Function<A>(core.List<core.int> x) f1887<B extends core.int>(int x) => null;
+List<int> Function<A>(List<int> x) f1888() => null;
+List<int> Function<A>(List<int> x) f1889(int x) => null;
+List<int> Function<A>(List<int> x) f1890<B extends core.int>() => null;
+List<int> Function<A>(List<int> x) f1891<B extends core.int>(int x) => null;
+List<int> Function<A>() f1892() => null;
+List<int> Function<A>() f1893(int x) => null;
+List<int> Function<A>() f1894<B extends core.int>() => null;
+List<int> Function<A>() f1895<B extends core.int>(int x) => null;
+List<int> Function<A>(A x) f1896() => null;
+List<int> Function<A>(A x) f1897(int x) => null;
+List<int> Function<A>(A x) f1898<B extends core.int>() => null;
+List<int> Function<A>(A x) f1899<B extends core.int>(int x) => null;
+List<int> Function<A>(List<A> x) f1900() => null;
+List<int> Function<A>(List<A> x) f1901(int x) => null;
+List<int> Function<A>(List<A> x) f1902<B extends core.int>() => null;
+List<int> Function<A>(List<A> x) f1903<B extends core.int>(int x) => null;
+Function<A>(int x) f1904() => null;
+Function<A>(int x) f1905(int x) => null;
+Function<A>(int x) f1906<B extends core.int>() => null;
+Function<A>(int x) f1907<B extends core.int>(int x) => null;
+Function<A>(Function x) f1908() => null;
+Function<A>(Function x) f1909(int x) => null;
+Function<A>(Function x) f1910<B extends core.int>() => null;
+Function<A>(Function x) f1911<B extends core.int>(int x) => null;
+Function<A>(List<Function> x) f1912() => null;
+Function<A>(List<Function> x) f1913(int x) => null;
+Function<A>(List<Function> x) f1914<B extends core.int>() => null;
+Function<A>(List<Function> x) f1915<B extends core.int>(int x) => null;
+Function<A>(core.List<core.int> x) f1916() => null;
+Function<A>(core.List<core.int> x) f1917(int x) => null;
+Function<A>(core.List<core.int> x) f1918<B extends core.int>() => null;
+Function<A>(core.List<core.int> x) f1919<B extends core.int>(int x) => null;
+Function<A>(List<int> x) f1920() => null;
+Function<A>(List<int> x) f1921(int x) => null;
+Function<A>(List<int> x) f1922<B extends core.int>() => null;
+Function<A>(List<int> x) f1923<B extends core.int>(int x) => null;
+Function<A>() f1924() => null;
+Function<A>() f1925(int x) => null;
+Function<A>() f1926<B extends core.int>() => null;
+Function<A>() f1927<B extends core.int>(int x) => null;
+Function<A>(A x) f1928() => null;
+Function<A>(A x) f1929(int x) => null;
+Function<A>(A x) f1930<B extends core.int>() => null;
+Function<A>(A x) f1931<B extends core.int>(int x) => null;
+Function<A>(List<A> x) f1932() => null;
+Function<A>(List<A> x) f1933(int x) => null;
+Function<A>(List<A> x) f1934<B extends core.int>() => null;
+Function<A>(List<A> x) f1935<B extends core.int>(int x) => null;
+A Function<A>(int x) f1936() => null;
+A Function<A>(int x) f1937(int x) => null;
+A Function<A>(int x) f1938<B extends core.int>() => null;
+A Function<A>(int x) f1939<B extends core.int>(int x) => null;
+A Function<A>(Function x) f1940() => null;
+A Function<A>(Function x) f1941(int x) => null;
+A Function<A>(Function x) f1942<B extends core.int>() => null;
+A Function<A>(Function x) f1943<B extends core.int>(int x) => null;
+A Function<A>(List<Function> x) f1944() => null;
+A Function<A>(List<Function> x) f1945(int x) => null;
+A Function<A>(List<Function> x) f1946<B extends core.int>() => null;
+A Function<A>(List<Function> x) f1947<B extends core.int>(int x) => null;
+A Function<A>(core.List<core.int> x) f1948() => null;
+A Function<A>(core.List<core.int> x) f1949(int x) => null;
+A Function<A>(core.List<core.int> x) f1950<B extends core.int>() => null;
+A Function<A>(core.List<core.int> x) f1951<B extends core.int>(int x) => null;
+A Function<A>(List<int> x) f1952() => null;
+A Function<A>(List<int> x) f1953(int x) => null;
+A Function<A>(List<int> x) f1954<B extends core.int>() => null;
+A Function<A>(List<int> x) f1955<B extends core.int>(int x) => null;
+A Function<A>() f1956() => null;
+A Function<A>() f1957(int x) => null;
+A Function<A>() f1958<B extends core.int>() => null;
+A Function<A>() f1959<B extends core.int>(int x) => null;
+A Function<A>(A x) f1960() => null;
+A Function<A>(A x) f1961(int x) => null;
+A Function<A>(A x) f1962<B extends core.int>() => null;
+A Function<A>(A x) f1963<B extends core.int>(int x) => null;
+A Function<A>(List<A> x) f1964() => null;
+A Function<A>(List<A> x) f1965(int x) => null;
+A Function<A>(List<A> x) f1966<B extends core.int>() => null;
+A Function<A>(List<A> x) f1967<B extends core.int>(int x) => null;
+List<A> Function<A>(int x) f1968() => null;
+List<A> Function<A>(int x) f1969(int x) => null;
+List<A> Function<A>(int x) f1970<B extends core.int>() => null;
+List<A> Function<A>(int x) f1971<B extends core.int>(int x) => null;
+List<A> Function<A>(Function x) f1972() => null;
+List<A> Function<A>(Function x) f1973(int x) => null;
+List<A> Function<A>(Function x) f1974<B extends core.int>() => null;
+List<A> Function<A>(Function x) f1975<B extends core.int>(int x) => null;
+List<A> Function<A>(List<Function> x) f1976() => null;
+List<A> Function<A>(List<Function> x) f1977(int x) => null;
+List<A> Function<A>(List<Function> x) f1978<B extends core.int>() => null;
+List<A> Function<A>(List<Function> x) f1979<B extends core.int>(int x) => null;
+List<A> Function<A>(core.List<core.int> x) f1980() => null;
+List<A> Function<A>(core.List<core.int> x) f1981(int x) => null;
+List<A> Function<A>(core.List<core.int> x) f1982<B extends core.int>() => null;
+List<A> Function<A>(core.List<core.int> x) f1983<B extends core.int>(int x) => null;
+List<A> Function<A>(List<int> x) f1984() => null;
+List<A> Function<A>(List<int> x) f1985(int x) => null;
+List<A> Function<A>(List<int> x) f1986<B extends core.int>() => null;
+List<A> Function<A>(List<int> x) f1987<B extends core.int>(int x) => null;
+List<A> Function<A>() f1988() => null;
+List<A> Function<A>() f1989(int x) => null;
+List<A> Function<A>() f1990<B extends core.int>() => null;
+List<A> Function<A>() f1991<B extends core.int>(int x) => null;
+List<A> Function<A>(A x) f1992() => null;
+List<A> Function<A>(A x) f1993(int x) => null;
+List<A> Function<A>(A x) f1994<B extends core.int>() => null;
+List<A> Function<A>(A x) f1995<B extends core.int>(int x) => null;
+List<A> Function<A>(List<A> x) f1996() => null;
+List<A> Function<A>(List<A> x) f1997(int x) => null;
+List<A> Function<A>(List<A> x) f1998<B extends core.int>() => null;
+List<A> Function<A>(List<A> x) f1999<B extends core.int>(int x) => null;
+int Function(B x) f2000<B extends core.int>() => null;
+int Function(B x) f2001<B extends core.int>(int x) => null;
+Function Function(B x) f2002<B extends core.int>() => null;
+Function Function(B x) f2003<B extends core.int>(int x) => null;
+List<Function> Function(B x) f2004<B extends core.int>() => null;
+List<Function> Function(B x) f2005<B extends core.int>(int x) => null;
+core.List<core.int> Function(B x) f2006<B extends core.int>() => null;
+core.List<core.int> Function(B x) f2007<B extends core.int>(int x) => null;
+List<int> Function(B x) f2008<B extends core.int>() => null;
+List<int> Function(B x) f2009<B extends core.int>(int x) => null;
+Function(B x) f2010<B extends core.int>() => null;
+Function(B x) f2011<B extends core.int>(int x) => null;
+B Function(B x) f2012<B extends core.int>() => null;
+B Function(B x) f2013<B extends core.int>(int x) => null;
+List<B> Function(B x) f2014<B extends core.int>() => null;
+List<B> Function(B x) f2015<B extends core.int>(int x) => null;
+B Function(int x) f2016<B extends core.int>() => null;
+B Function(int x) f2017<B extends core.int>(int x) => null;
+B Function(Function x) f2018<B extends core.int>() => null;
+B Function(Function x) f2019<B extends core.int>(int x) => null;
+B Function(List<Function> x) f2020<B extends core.int>() => null;
+B Function(List<Function> x) f2021<B extends core.int>(int x) => null;
+B Function(core.List<core.int> x) f2022<B extends core.int>() => null;
+B Function(core.List<core.int> x) f2023<B extends core.int>(int x) => null;
+B Function(List<int> x) f2024<B extends core.int>() => null;
+B Function(List<int> x) f2025<B extends core.int>(int x) => null;
+B Function() f2026<B extends core.int>() => null;
+B Function() f2027<B extends core.int>(int x) => null;
+
+class C0<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x) x0;
+ Function Function(List<T> x) x100;
+ core.List<core.int> Function(int y, {List<Function> x}) x200;
+ Function(int x0, {Function x}) x300;
+ int Function(int x) Function() x400;
+ int Function(int y, [List<Function> x]) Function() x500;
+ int Function(int x1, [List<T> x2]) Function() x600;
+ Function Function({Function x}) Function() x700;
+ Function Function(List<T> x) Function() x800;
+ List<Function> Function(int x0, [Function x]) Function() x900;
+ List<Function> Function([core.List<core.int> x1]) Function() x1000;
+ core.List<core.int> Function(int x, [int x2]) Function() x1100;
+ core.List<core.int> Function(int y, {List<Function> x}) Function() x1200;
+ List<T> Function([int x]) Function() x1300;
+ List<T> Function(List<Function> x0) Function() x1400;
+ List<T> Function(int x, [List<T> x2]) Function() x1500;
+ Function(int x0, {Function x}) Function() x1600;
+ Function([List<T> x]) Function() x1700;
+ Function Function<A>(A x) Function() x1800;
+ List<T> Function<A>(List<A> x) Function() x1900;
+ int Function(B x) Function<B extends core.int>() x2000;
+
+
+ C0({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m0(int x) => null;
+ Function m100(List<T> x) => null;
+ core.List<core.int> m200(int y, {List<Function> x}) => null;
+ m300(int x0, {Function x}) => null;
+ int Function(int x) m400() => null;
+ int Function(int y, [List<Function> x]) m500() => null;
+ int Function(int x0, [List<T> x1]) m600() => null;
+ Function Function({Function x}) m700() => null;
+ Function Function(List<T> x) m800() => null;
+ List<Function> Function(int x0, [Function x]) m900() => null;
+ List<Function> Function([core.List<core.int> x0]) m1000() => null;
+ core.List<core.int> Function(int x, [int x0]) m1100() => null;
+ core.List<core.int> Function(int y, {List<Function> x}) m1200() => null;
+ List<T> Function([int x]) m1300() => null;
+ List<T> Function(List<Function> x0) m1400() => null;
+ List<T> Function(int x, [List<T> x0]) m1500() => null;
+ Function(int x0, {Function x}) m1600() => null;
+ Function([List<T> x]) m1700() => null;
+ Function Function<A>(A x) m1800() => null;
+ List<T> Function<A>(List<A> x) m1900() => null;
+ int Function(B x) m2000<B extends core.int>() => null;
+
+
+ runTests() {
+ testF0();
+ testF100();
+ testF200();
+ testF300();
+ testF400();
+ testF500();
+ testF600();
+ testF700();
+ testF800();
+ testF900();
+ testF1000();
+ testF1100();
+ testF1200();
+ testF1300();
+ testF1400();
+ testF1500();
+ testF1600();
+ testF1700();
+ testF1800();
+ testF1900();
+ testF2000();
+ }
+
+ void testF0() {
+ // int Function(int x)
+ Expect.isTrue(f0 is F0);
+ Expect.isTrue(confuse(f0) is F0);
+ // In checked mode, verifies the type.
+ int Function(int x) l0;
+ // The static function f0 sets `T` to `int`.
+ if (!tIsBool) {
+ 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 x));
+ Expect.isTrue(confuse(m0) is F0);
+ // In checked mode, verifies the type.
+ x0 = m0;
+ l0 = m0;
+ x0 = confuse(m0);
+ l0 = confuse(m0);
+
+ }
+
+ void testF100() {
+ // Function Function(List<T> x)
+ Expect.isTrue(f100 is F100);
+ Expect.isTrue(confuse(f100) is F100);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x) l100;
+ // The static function f100 sets `T` to `int`.
+ if (!tIsBool) {
+ x100 = f100 as dynamic;
+ l100 = f100 as dynamic;
+ x100 = confuse(f100);
+ l100 = confuse(f100);
+ }
+
+ Expect.isTrue(m100 is F100);
+ Expect.isTrue(m100 is Function Function(List<T> x));
+ Expect.isTrue(confuse(m100) is F100);
+ // In checked mode, verifies the type.
+ x100 = m100;
+ l100 = m100;
+ x100 = confuse(m100);
+ l100 = confuse(m100);
+ if (!tIsBool) {
+ Expect.isTrue(f100 is F100<int>);
+ Expect.isFalse(f100 is F100<bool>);
+ Expect.isTrue(confuse(f100) is F100<int>);
+ Expect.isFalse(confuse(f100) is F100<bool>);
+ Expect.equals(tIsDynamic, m100 is F100<bool>);
+ Expect.equals(tIsDynamic, confuse(m100) is F100<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x100 = (f100 as dynamic); });
+ Expect.throws(() { x100 = confuse(f100); });
+ Function Function(List<T> x) l100;
+ Expect.throws(() { l100 = (f100 as dynamic); });
+ Expect.throws(() { l100 = confuse(f100); });
+ }
+ Function Function(List<T> x) l100 = m100;
+ // In checked mode, verifies the type.
+ x100 = m100;
+ x100 = confuse(m100);
+ }
+ }
+
+ void testF200() {
+ // core.List<core.int> Function(int y, {List<Function> x})
+ Expect.isTrue(f200 is F200);
+ Expect.isTrue(confuse(f200) is F200);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<Function> x}) l200;
+ // The static function f200 sets `T` to `int`.
+ if (!tIsBool) {
+ x200 = f200 as dynamic;
+ l200 = f200 as dynamic;
+ x200 = confuse(f200);
+ l200 = confuse(f200);
+ }
+
+ Expect.isTrue(m200 is F200);
+ Expect.isTrue(m200 is core.List<core.int> Function(int y, {List<Function> x}));
+ Expect.isTrue(confuse(m200) is F200);
+ // In checked mode, verifies the type.
+ x200 = m200;
+ l200 = m200;
+ x200 = confuse(m200);
+ l200 = confuse(m200);
+
+ }
+
+ void testF300() {
+ // Function(int x0, {Function x})
+ Expect.isTrue(f300 is F300);
+ Expect.isTrue(confuse(f300) is F300);
+ // In checked mode, verifies the type.
+ Function(int x0, {Function x}) l300;
+ // The static function f300 sets `T` to `int`.
+ if (!tIsBool) {
+ x300 = f300 as dynamic;
+ l300 = f300 as dynamic;
+ x300 = confuse(f300);
+ l300 = confuse(f300);
+ }
+
+ Expect.isTrue(m300 is F300);
+ Expect.isTrue(m300 is Function(int x0, {Function x}));
+ Expect.isTrue(confuse(m300) is F300);
+ // In checked mode, verifies the type.
+ x300 = m300;
+ l300 = m300;
+ x300 = confuse(m300);
+ l300 = confuse(m300);
+
+ }
+
+ void testF400() {
+ // int Function(int x) Function()
+ Expect.isTrue(f400 is F400);
+ Expect.isTrue(confuse(f400) is F400);
+ // In checked mode, verifies the type.
+ int Function(int x) Function() l400;
+ // The static function f400 sets `T` to `int`.
+ if (!tIsBool) {
+ x400 = f400 as dynamic;
+ l400 = f400 as dynamic;
+ x400 = confuse(f400);
+ l400 = confuse(f400);
+ }
+
+ Expect.isTrue(m400 is F400);
+ Expect.isTrue(m400 is int Function(int x) Function());
+ Expect.isTrue(confuse(m400) is F400);
+ // In checked mode, verifies the type.
+ x400 = m400;
+ l400 = m400;
+ x400 = confuse(m400);
+ l400 = confuse(m400);
+
+ }
+
+ void testF500() {
+ // int Function(int y, [List<Function> x]) Function()
+ Expect.isTrue(f500 is F500);
+ Expect.isTrue(confuse(f500) is F500);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<Function> x]) Function() l500;
+ // The static function f500 sets `T` to `int`.
+ if (!tIsBool) {
+ x500 = f500 as dynamic;
+ l500 = f500 as dynamic;
+ x500 = confuse(f500);
+ l500 = confuse(f500);
+ }
+
+ Expect.isTrue(m500 is F500);
+ Expect.isTrue(m500 is int Function(int y, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m500) is F500);
+ // In checked mode, verifies the type.
+ x500 = m500;
+ l500 = m500;
+ x500 = confuse(m500);
+ l500 = confuse(m500);
+
+ }
+
+ void testF600() {
+ // int Function(int x1, [List<T> x2]) Function()
+ Expect.isTrue(f600 is F600);
+ Expect.isTrue(confuse(f600) is F600);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<T> x2]) Function() l600;
+ // The static function f600 sets `T` to `int`.
+ if (!tIsBool) {
+ x600 = f600 as dynamic;
+ l600 = f600 as dynamic;
+ x600 = confuse(f600);
+ l600 = confuse(f600);
+ }
+
+ Expect.isTrue(m600 is F600);
+ Expect.isTrue(m600 is int Function(int x1, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m600) is F600);
+ // In checked mode, verifies the type.
+ x600 = m600;
+ l600 = m600;
+ x600 = confuse(m600);
+ l600 = confuse(m600);
+ if (!tIsBool) {
+ Expect.isTrue(f600 is F600<int>);
+ Expect.isFalse(f600 is F600<bool>);
+ Expect.isTrue(confuse(f600) is F600<int>);
+ Expect.isFalse(confuse(f600) is F600<bool>);
+ Expect.equals(tIsDynamic, m600 is F600<bool>);
+ Expect.equals(tIsDynamic, confuse(m600) is F600<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x600 = (f600 as dynamic); });
+ Expect.throws(() { x600 = confuse(f600); });
+ int Function(int x1, [List<T> x2]) Function() l600;
+ Expect.throws(() { l600 = (f600 as dynamic); });
+ Expect.throws(() { l600 = confuse(f600); });
+ }
+ int Function(int x1, [List<T> x2]) Function() l600 = m600;
+ // In checked mode, verifies the type.
+ x600 = m600;
+ x600 = confuse(m600);
+ }
+ }
+
+ void testF700() {
+ // Function Function({Function x}) Function()
+ Expect.isTrue(f700 is F700);
+ Expect.isTrue(confuse(f700) is F700);
+ // In checked mode, verifies the type.
+ Function Function({Function x}) Function() l700;
+ // The static function f700 sets `T` to `int`.
+ if (!tIsBool) {
+ x700 = f700 as dynamic;
+ l700 = f700 as dynamic;
+ x700 = confuse(f700);
+ l700 = confuse(f700);
+ }
+
+ Expect.isTrue(m700 is F700);
+ Expect.isTrue(m700 is Function Function({Function x}) Function());
+ Expect.isTrue(confuse(m700) is F700);
+ // In checked mode, verifies the type.
+ x700 = m700;
+ l700 = m700;
+ x700 = confuse(m700);
+ l700 = confuse(m700);
+
+ }
+
+ void testF800() {
+ // Function Function(List<T> x) Function()
+ Expect.isTrue(f800 is F800);
+ Expect.isTrue(confuse(f800) is F800);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x) Function() l800;
+ // The static function f800 sets `T` to `int`.
+ if (!tIsBool) {
+ x800 = f800 as dynamic;
+ l800 = f800 as dynamic;
+ x800 = confuse(f800);
+ l800 = confuse(f800);
+ }
+
+ Expect.isTrue(m800 is F800);
+ Expect.isTrue(m800 is Function Function(List<T> x) Function());
+ Expect.isTrue(confuse(m800) is F800);
+ // In checked mode, verifies the type.
+ x800 = m800;
+ l800 = m800;
+ x800 = confuse(m800);
+ l800 = confuse(m800);
+ if (!tIsBool) {
+ Expect.isTrue(f800 is F800<int>);
+ Expect.isFalse(f800 is F800<bool>);
+ Expect.isTrue(confuse(f800) is F800<int>);
+ Expect.isFalse(confuse(f800) is F800<bool>);
+ Expect.equals(tIsDynamic, m800 is F800<bool>);
+ Expect.equals(tIsDynamic, confuse(m800) is F800<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x800 = (f800 as dynamic); });
+ Expect.throws(() { x800 = confuse(f800); });
+ Function Function(List<T> x) Function() l800;
+ Expect.throws(() { l800 = (f800 as dynamic); });
+ Expect.throws(() { l800 = confuse(f800); });
+ }
+ Function Function(List<T> x) Function() l800 = m800;
+ // In checked mode, verifies the type.
+ x800 = m800;
+ x800 = confuse(m800);
+ }
+ }
+
+ void testF900() {
+ // List<Function> Function(int x0, [Function x]) Function()
+ Expect.isTrue(f900 is F900);
+ Expect.isTrue(confuse(f900) is F900);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [Function x]) Function() l900;
+ // The static function f900 sets `T` to `int`.
+ if (!tIsBool) {
+ x900 = f900 as dynamic;
+ l900 = f900 as dynamic;
+ x900 = confuse(f900);
+ l900 = confuse(f900);
+ }
+
+ Expect.isTrue(m900 is F900);
+ Expect.isTrue(m900 is List<Function> Function(int x0, [Function x]) Function());
+ Expect.isTrue(confuse(m900) is F900);
+ // In checked mode, verifies the type.
+ x900 = m900;
+ l900 = m900;
+ x900 = confuse(m900);
+ l900 = confuse(m900);
+
+ }
+
+ void testF1000() {
+ // List<Function> Function([core.List<core.int> x1]) Function()
+ Expect.isTrue(f1000 is F1000);
+ Expect.isTrue(confuse(f1000) is F1000);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x1]) Function() l1000;
+ // The static function f1000 sets `T` to `int`.
+ if (!tIsBool) {
+ x1000 = f1000 as dynamic;
+ l1000 = f1000 as dynamic;
+ x1000 = confuse(f1000);
+ l1000 = confuse(f1000);
+ }
+
+ Expect.isTrue(m1000 is F1000);
+ Expect.isTrue(m1000 is List<Function> Function([core.List<core.int> x1]) Function());
+ Expect.isTrue(confuse(m1000) is F1000);
+ // In checked mode, verifies the type.
+ x1000 = m1000;
+ l1000 = m1000;
+ x1000 = confuse(m1000);
+ l1000 = confuse(m1000);
+
+ }
+
+ void testF1100() {
+ // core.List<core.int> Function(int x, [int x2]) Function()
+ Expect.isTrue(f1100 is F1100);
+ Expect.isTrue(confuse(f1100) is F1100);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [int x2]) Function() l1100;
+ // The static function f1100 sets `T` to `int`.
+ if (!tIsBool) {
+ x1100 = f1100 as dynamic;
+ l1100 = f1100 as dynamic;
+ x1100 = confuse(f1100);
+ l1100 = confuse(f1100);
+ }
+
+ Expect.isTrue(m1100 is F1100);
+ Expect.isTrue(m1100 is core.List<core.int> Function(int x, [int x2]) Function());
+ Expect.isTrue(confuse(m1100) is F1100);
+ // In checked mode, verifies the type.
+ x1100 = m1100;
+ l1100 = m1100;
+ x1100 = confuse(m1100);
+ l1100 = confuse(m1100);
+
+ }
+
+ void testF1200() {
+ // core.List<core.int> Function(int y, {List<Function> x}) Function()
+ Expect.isTrue(f1200 is F1200);
+ Expect.isTrue(confuse(f1200) is F1200);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<Function> x}) Function() l1200;
+ // The static function f1200 sets `T` to `int`.
+ if (!tIsBool) {
+ x1200 = f1200 as dynamic;
+ l1200 = f1200 as dynamic;
+ x1200 = confuse(f1200);
+ l1200 = confuse(f1200);
+ }
+
+ Expect.isTrue(m1200 is F1200);
+ Expect.isTrue(m1200 is core.List<core.int> Function(int y, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m1200) is F1200);
+ // In checked mode, verifies the type.
+ x1200 = m1200;
+ l1200 = m1200;
+ x1200 = confuse(m1200);
+ l1200 = confuse(m1200);
+
+ }
+
+ void testF1300() {
+ // List<T> Function([int x]) Function()
+ Expect.isTrue(f1300 is F1300);
+ Expect.isTrue(confuse(f1300) is F1300);
+ // In checked mode, verifies the type.
+ List<T> Function([int x]) Function() l1300;
+ // The static function f1300 sets `T` to `int`.
+ if (!tIsBool) {
+ x1300 = f1300 as dynamic;
+ l1300 = f1300 as dynamic;
+ x1300 = confuse(f1300);
+ l1300 = confuse(f1300);
+ }
+
+ Expect.isTrue(m1300 is F1300);
+ Expect.isTrue(m1300 is List<T> Function([int x]) Function());
+ Expect.isTrue(confuse(m1300) is F1300);
+ // In checked mode, verifies the type.
+ x1300 = m1300;
+ l1300 = m1300;
+ x1300 = confuse(m1300);
+ l1300 = confuse(m1300);
+ if (!tIsBool) {
+ Expect.isTrue(f1300 is F1300<int>);
+ Expect.isFalse(f1300 is F1300<bool>);
+ Expect.isTrue(confuse(f1300) is F1300<int>);
+ Expect.isFalse(confuse(f1300) is F1300<bool>);
+ Expect.equals(tIsDynamic, m1300 is F1300<bool>);
+ Expect.equals(tIsDynamic, confuse(m1300) is F1300<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1300 = (f1300 as dynamic); });
+ Expect.throws(() { x1300 = confuse(f1300); });
+ List<T> Function([int x]) Function() l1300;
+ Expect.throws(() { l1300 = (f1300 as dynamic); });
+ Expect.throws(() { l1300 = confuse(f1300); });
+ }
+ List<T> Function([int x]) Function() l1300 = m1300;
+ // In checked mode, verifies the type.
+ x1300 = m1300;
+ x1300 = confuse(m1300);
+ }
+ }
+
+ void testF1400() {
+ // List<T> Function(List<Function> x0) Function()
+ Expect.isTrue(f1400 is F1400);
+ Expect.isTrue(confuse(f1400) is F1400);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x0) Function() l1400;
+ // The static function f1400 sets `T` to `int`.
+ if (!tIsBool) {
+ x1400 = f1400 as dynamic;
+ l1400 = f1400 as dynamic;
+ x1400 = confuse(f1400);
+ l1400 = confuse(f1400);
+ }
+
+ Expect.isTrue(m1400 is F1400);
+ Expect.isTrue(m1400 is List<T> Function(List<Function> x0) Function());
+ Expect.isTrue(confuse(m1400) is F1400);
+ // In checked mode, verifies the type.
+ x1400 = m1400;
+ l1400 = m1400;
+ x1400 = confuse(m1400);
+ l1400 = confuse(m1400);
+ if (!tIsBool) {
+ Expect.isTrue(f1400 is F1400<int>);
+ Expect.isFalse(f1400 is F1400<bool>);
+ Expect.isTrue(confuse(f1400) is F1400<int>);
+ Expect.isFalse(confuse(f1400) is F1400<bool>);
+ Expect.equals(tIsDynamic, m1400 is F1400<bool>);
+ Expect.equals(tIsDynamic, confuse(m1400) is F1400<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1400 = (f1400 as dynamic); });
+ Expect.throws(() { x1400 = confuse(f1400); });
+ List<T> Function(List<Function> x0) Function() l1400;
+ Expect.throws(() { l1400 = (f1400 as dynamic); });
+ Expect.throws(() { l1400 = confuse(f1400); });
+ }
+ List<T> Function(List<Function> x0) Function() l1400 = m1400;
+ // In checked mode, verifies the type.
+ x1400 = m1400;
+ x1400 = confuse(m1400);
+ }
+ }
+
+ void testF1500() {
+ // List<T> Function(int x, [List<T> x2]) Function()
+ Expect.isTrue(f1500 is F1500);
+ Expect.isTrue(confuse(f1500) is F1500);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<T> x2]) Function() l1500;
+ // The static function f1500 sets `T` to `int`.
+ if (!tIsBool) {
+ x1500 = f1500 as dynamic;
+ l1500 = f1500 as dynamic;
+ x1500 = confuse(f1500);
+ l1500 = confuse(f1500);
+ }
+
+ Expect.isTrue(m1500 is F1500);
+ Expect.isTrue(m1500 is List<T> Function(int x, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1500) is F1500);
+ // In checked mode, verifies the type.
+ x1500 = m1500;
+ l1500 = m1500;
+ x1500 = confuse(m1500);
+ l1500 = confuse(m1500);
+ if (!tIsBool) {
+ Expect.isTrue(f1500 is F1500<int>);
+ Expect.isFalse(f1500 is F1500<bool>);
+ Expect.isTrue(confuse(f1500) is F1500<int>);
+ Expect.isFalse(confuse(f1500) is F1500<bool>);
+ Expect.equals(tIsDynamic, m1500 is F1500<bool>);
+ Expect.equals(tIsDynamic, confuse(m1500) is F1500<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1500 = (f1500 as dynamic); });
+ Expect.throws(() { x1500 = confuse(f1500); });
+ List<T> Function(int x, [List<T> x2]) Function() l1500;
+ Expect.throws(() { l1500 = (f1500 as dynamic); });
+ Expect.throws(() { l1500 = confuse(f1500); });
+ }
+ List<T> Function(int x, [List<T> x2]) Function() l1500 = m1500;
+ // In checked mode, verifies the type.
+ x1500 = m1500;
+ x1500 = confuse(m1500);
+ }
+ }
+
+ void testF1600() {
+ // Function(int x0, {Function x}) Function()
+ Expect.isTrue(f1600 is F1600);
+ Expect.isTrue(confuse(f1600) is F1600);
+ // In checked mode, verifies the type.
+ Function(int x0, {Function x}) Function() l1600;
+ // The static function f1600 sets `T` to `int`.
+ if (!tIsBool) {
+ x1600 = f1600 as dynamic;
+ l1600 = f1600 as dynamic;
+ x1600 = confuse(f1600);
+ l1600 = confuse(f1600);
+ }
+
+ Expect.isTrue(m1600 is F1600);
+ Expect.isTrue(m1600 is Function(int x0, {Function x}) Function());
+ Expect.isTrue(confuse(m1600) is F1600);
+ // In checked mode, verifies the type.
+ x1600 = m1600;
+ l1600 = m1600;
+ x1600 = confuse(m1600);
+ l1600 = confuse(m1600);
+
+ }
+
+ void testF1700() {
+ // Function([List<T> x]) Function()
+ Expect.isTrue(f1700 is F1700);
+ Expect.isTrue(confuse(f1700) is F1700);
+ // In checked mode, verifies the type.
+ Function([List<T> x]) Function() l1700;
+ // The static function f1700 sets `T` to `int`.
+ if (!tIsBool) {
+ x1700 = f1700 as dynamic;
+ l1700 = f1700 as dynamic;
+ x1700 = confuse(f1700);
+ l1700 = confuse(f1700);
+ }
+
+ Expect.isTrue(m1700 is F1700);
+ Expect.isTrue(m1700 is Function([List<T> x]) Function());
+ Expect.isTrue(confuse(m1700) is F1700);
+ // In checked mode, verifies the type.
+ x1700 = m1700;
+ l1700 = m1700;
+ x1700 = confuse(m1700);
+ l1700 = confuse(m1700);
+ if (!tIsBool) {
+ Expect.isTrue(f1700 is F1700<int>);
+ Expect.isFalse(f1700 is F1700<bool>);
+ Expect.isTrue(confuse(f1700) is F1700<int>);
+ Expect.isFalse(confuse(f1700) is F1700<bool>);
+ Expect.equals(tIsDynamic, m1700 is F1700<bool>);
+ Expect.equals(tIsDynamic, confuse(m1700) is F1700<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1700 = (f1700 as dynamic); });
+ Expect.throws(() { x1700 = confuse(f1700); });
+ Function([List<T> x]) Function() l1700;
+ Expect.throws(() { l1700 = (f1700 as dynamic); });
+ Expect.throws(() { l1700 = confuse(f1700); });
+ }
+ Function([List<T> x]) Function() l1700 = m1700;
+ // In checked mode, verifies the type.
+ x1700 = m1700;
+ x1700 = confuse(m1700);
+ }
+ }
+
+ void testF1800() {
+ // Function Function<A>(A x) Function()
+ Expect.isTrue(f1800 is F1800);
+ Expect.isTrue(confuse(f1800) is F1800);
+ // In checked mode, verifies the type.
+ Function Function<A>(A x) Function() l1800;
+ // The static function f1800 sets `T` to `int`.
+ if (!tIsBool) {
+ x1800 = f1800 as dynamic;
+ l1800 = f1800 as dynamic;
+ x1800 = confuse(f1800);
+ l1800 = confuse(f1800);
+ }
+
+ Expect.isTrue(m1800 is F1800);
+ Expect.isTrue(m1800 is Function Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1800) is F1800);
+ // In checked mode, verifies the type.
+ x1800 = m1800;
+ l1800 = m1800;
+ x1800 = confuse(m1800);
+ l1800 = confuse(m1800);
+
+ }
+
+ void testF1900() {
+ // List<T> Function<A>(List<A> x) Function()
+ Expect.isTrue(f1900 is F1900);
+ Expect.isTrue(confuse(f1900) is F1900);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<A> x) Function() l1900;
+ // The static function f1900 sets `T` to `int`.
+ if (!tIsBool) {
+ x1900 = f1900 as dynamic;
+ l1900 = f1900 as dynamic;
+ x1900 = confuse(f1900);
+ l1900 = confuse(f1900);
+ }
+
+ Expect.isTrue(m1900 is F1900);
+ Expect.isTrue(m1900 is List<T> Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1900) is F1900);
+ // In checked mode, verifies the type.
+ x1900 = m1900;
+ l1900 = m1900;
+ x1900 = confuse(m1900);
+ l1900 = confuse(m1900);
+ if (!tIsBool) {
+ Expect.isTrue(f1900 is F1900<int>);
+ Expect.isFalse(f1900 is F1900<bool>);
+ Expect.isTrue(confuse(f1900) is F1900<int>);
+ Expect.isFalse(confuse(f1900) is F1900<bool>);
+ Expect.equals(tIsDynamic, m1900 is F1900<bool>);
+ Expect.equals(tIsDynamic, confuse(m1900) is F1900<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1900 = (f1900 as dynamic); });
+ Expect.throws(() { x1900 = confuse(f1900); });
+ List<T> Function<A>(List<A> x) Function() l1900;
+ Expect.throws(() { l1900 = (f1900 as dynamic); });
+ Expect.throws(() { l1900 = confuse(f1900); });
+ }
+ List<T> Function<A>(List<A> x) Function() l1900 = m1900;
+ // In checked mode, verifies the type.
+ x1900 = m1900;
+ x1900 = confuse(m1900);
+ }
+ }
+
+ void testF2000() {
+ // int Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2000 is F2000);
+ Expect.isTrue(confuse(f2000) is F2000);
+ // In checked mode, verifies the type.
+ int Function(B x) Function<B extends core.int>() l2000;
+ // The static function f2000 sets `T` to `int`.
+ if (!tIsBool) {
+ x2000 = f2000 as dynamic;
+ l2000 = f2000 as dynamic;
+ x2000 = confuse(f2000);
+ l2000 = confuse(f2000);
+ }
+
+ Expect.isTrue(m2000 is F2000);
+ Expect.isTrue(m2000 is int Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2000) is F2000);
+ // In checked mode, verifies the type.
+ x2000 = m2000;
+ l2000 = m2000;
+ x2000 = confuse(m2000);
+ l2000 = confuse(m2000);
+
+ }
+
+
+}
+
+class C1<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([int x]) x1;
+ Function Function([List<T> x]) x101;
+ core.List<core.int> Function(core.List<core.int> x) x201;
+ Function(int y, {Function x}) x301;
+ int Function(int x) Function(int x) x401;
+ int Function(int y, [List<Function> x]) Function(int x) x501;
+ int Function(int x2, [List<T> x3]) Function(int x) x601;
+ Function Function({Function x}) Function(int x) x701;
+ Function Function(List<T> x) Function(int x) x801;
+ List<Function> Function(int x1, [Function x]) Function(int x) x901;
+ List<Function> Function([core.List<core.int> x1]) Function(int x) x1001;
+ core.List<core.int> Function(int x, [int x1]) Function(int x) x1101;
+ core.List<core.int> Function(int y, {List<Function> x}) Function(int x) x1201;
+ List<T> Function([int x]) Function(int x) x1301;
+ List<T> Function(List<Function> x1) Function(int x) x1401;
+ List<T> Function(int x, [List<T> x1]) Function(int x) x1501;
+ Function(int x1, {Function x}) Function(int x) x1601;
+ Function([List<T> x]) Function(int x) x1701;
+ Function Function<A>(A x) Function(int x) x1801;
+ List<T> Function<A>(List<A> x) Function(int x) x1901;
+ int Function(B x) Function<B extends core.int>(int x) x2001;
+
+
+ C1({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m1([int x]) => null;
+ Function m101([List<T> x]) => null;
+ core.List<core.int> m201(core.List<core.int> x) => null;
+ m301(int y, {Function x}) => null;
+ int Function(int x) m401(int x) => null;
+ int Function(int y, [List<Function> x]) m501(int x) => null;
+ int Function(int x0, [List<T> x1]) m601(int x) => null;
+ Function Function({Function x}) m701(int x) => null;
+ Function Function(List<T> x) m801(int x) => null;
+ List<Function> Function(int x0, [Function x]) m901(int x) => null;
+ List<Function> Function([core.List<core.int> x0]) m1001(int x) => null;
+ core.List<core.int> Function(int x, [int x0]) m1101(int x) => null;
+ core.List<core.int> Function(int y, {List<Function> x}) m1201(int x) => null;
+ List<T> Function([int x]) m1301(int x) => null;
+ List<T> Function(List<Function> x0) m1401(int x) => null;
+ List<T> Function(int x, [List<T> x0]) m1501(int x) => null;
+ Function(int x0, {Function x}) m1601(int x) => null;
+ Function([List<T> x]) m1701(int x) => null;
+ Function Function<A>(A x) m1801(int x) => null;
+ List<T> Function<A>(List<A> x) m1901(int x) => null;
+ int Function(B x) m2001<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF1();
+ testF101();
+ testF201();
+ testF301();
+ testF401();
+ testF501();
+ testF601();
+ testF701();
+ testF801();
+ testF901();
+ testF1001();
+ testF1101();
+ testF1201();
+ testF1301();
+ testF1401();
+ testF1501();
+ testF1601();
+ testF1701();
+ testF1801();
+ testF1901();
+ testF2001();
+ }
+
+ void testF1() {
+ // int Function([int x])
+ Expect.isTrue(f1 is F1);
+ Expect.isTrue(confuse(f1) is F1);
+ // In checked mode, verifies the type.
+ int Function([int x]) l1;
+ // The static function f1 sets `T` to `int`.
+ if (!tIsBool) {
+ x1 = f1 as dynamic;
+ l1 = f1 as dynamic;
+ x1 = confuse(f1);
+ l1 = confuse(f1);
+ }
+
+ Expect.isTrue(m1 is F1);
+ Expect.isTrue(m1 is int Function([int x]));
+ Expect.isTrue(confuse(m1) is F1);
+ // In checked mode, verifies the type.
+ x1 = m1;
+ l1 = m1;
+ x1 = confuse(m1);
+ l1 = confuse(m1);
+
+ }
+
+ void testF101() {
+ // Function Function([List<T> x])
+ Expect.isTrue(f101 is F101);
+ Expect.isTrue(confuse(f101) is F101);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x]) l101;
+ // The static function f101 sets `T` to `int`.
+ if (!tIsBool) {
+ x101 = f101 as dynamic;
+ l101 = f101 as dynamic;
+ x101 = confuse(f101);
+ l101 = confuse(f101);
+ }
+
+ Expect.isTrue(m101 is F101);
+ Expect.isTrue(m101 is Function Function([List<T> x]));
+ Expect.isTrue(confuse(m101) is F101);
+ // In checked mode, verifies the type.
+ x101 = m101;
+ l101 = m101;
+ x101 = confuse(m101);
+ l101 = confuse(m101);
+ if (!tIsBool) {
+ Expect.isTrue(f101 is F101<int>);
+ Expect.isFalse(f101 is F101<bool>);
+ Expect.isTrue(confuse(f101) is F101<int>);
+ Expect.isFalse(confuse(f101) is F101<bool>);
+ Expect.equals(tIsDynamic, m101 is F101<bool>);
+ Expect.equals(tIsDynamic, confuse(m101) is F101<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x101 = (f101 as dynamic); });
+ Expect.throws(() { x101 = confuse(f101); });
+ Function Function([List<T> x]) l101;
+ Expect.throws(() { l101 = (f101 as dynamic); });
+ Expect.throws(() { l101 = confuse(f101); });
+ }
+ Function Function([List<T> x]) l101 = m101;
+ // In checked mode, verifies the type.
+ x101 = m101;
+ x101 = confuse(m101);
+ }
+ }
+
+ void testF201() {
+ // core.List<core.int> Function(core.List<core.int> x)
+ Expect.isTrue(f201 is F201);
+ Expect.isTrue(confuse(f201) is F201);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x) l201;
+ // The static function f201 sets `T` to `int`.
+ if (!tIsBool) {
+ x201 = f201 as dynamic;
+ l201 = f201 as dynamic;
+ x201 = confuse(f201);
+ l201 = confuse(f201);
+ }
+
+ Expect.isTrue(m201 is F201);
+ Expect.isTrue(m201 is core.List<core.int> Function(core.List<core.int> x));
+ Expect.isTrue(confuse(m201) is F201);
+ // In checked mode, verifies the type.
+ x201 = m201;
+ l201 = m201;
+ x201 = confuse(m201);
+ l201 = confuse(m201);
+
+ }
+
+ void testF301() {
+ // Function(int y, {Function x})
+ Expect.isTrue(f301 is F301);
+ Expect.isTrue(confuse(f301) is F301);
+ // In checked mode, verifies the type.
+ Function(int y, {Function x}) l301;
+ // The static function f301 sets `T` to `int`.
+ if (!tIsBool) {
+ x301 = f301 as dynamic;
+ l301 = f301 as dynamic;
+ x301 = confuse(f301);
+ l301 = confuse(f301);
+ }
+
+ Expect.isTrue(m301 is F301);
+ Expect.isTrue(m301 is Function(int y, {Function x}));
+ Expect.isTrue(confuse(m301) is F301);
+ // In checked mode, verifies the type.
+ x301 = m301;
+ l301 = m301;
+ x301 = confuse(m301);
+ l301 = confuse(m301);
+
+ }
+
+ void testF401() {
+ // int Function(int x) Function(int x)
+ Expect.isTrue(f401 is F401);
+ Expect.isTrue(confuse(f401) is F401);
+ // In checked mode, verifies the type.
+ int Function(int x) Function(int x) l401;
+ // The static function f401 sets `T` to `int`.
+ if (!tIsBool) {
+ x401 = f401 as dynamic;
+ l401 = f401 as dynamic;
+ x401 = confuse(f401);
+ l401 = confuse(f401);
+ }
+
+ Expect.isTrue(m401 is F401);
+ Expect.isTrue(m401 is int Function(int x) Function(int x));
+ Expect.isTrue(confuse(m401) is F401);
+ // In checked mode, verifies the type.
+ x401 = m401;
+ l401 = m401;
+ x401 = confuse(m401);
+ l401 = confuse(m401);
+
+ }
+
+ void testF501() {
+ // int Function(int y, [List<Function> x]) Function(int x)
+ Expect.isTrue(f501 is F501);
+ Expect.isTrue(confuse(f501) is F501);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<Function> x]) Function(int x) l501;
+ // The static function f501 sets `T` to `int`.
+ if (!tIsBool) {
+ x501 = f501 as dynamic;
+ l501 = f501 as dynamic;
+ x501 = confuse(f501);
+ l501 = confuse(f501);
+ }
+
+ Expect.isTrue(m501 is F501);
+ Expect.isTrue(m501 is int Function(int y, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m501) is F501);
+ // In checked mode, verifies the type.
+ x501 = m501;
+ l501 = m501;
+ x501 = confuse(m501);
+ l501 = confuse(m501);
+
+ }
+
+ void testF601() {
+ // int Function(int x2, [List<T> x3]) Function(int x)
+ Expect.isTrue(f601 is F601);
+ Expect.isTrue(confuse(f601) is F601);
+ // In checked mode, verifies the type.
+ int Function(int x2, [List<T> x3]) Function(int x) l601;
+ // The static function f601 sets `T` to `int`.
+ if (!tIsBool) {
+ x601 = f601 as dynamic;
+ l601 = f601 as dynamic;
+ x601 = confuse(f601);
+ l601 = confuse(f601);
+ }
+
+ Expect.isTrue(m601 is F601);
+ Expect.isTrue(m601 is int Function(int x2, [List<T> x3]) Function(int x));
+ Expect.isTrue(confuse(m601) is F601);
+ // In checked mode, verifies the type.
+ x601 = m601;
+ l601 = m601;
+ x601 = confuse(m601);
+ l601 = confuse(m601);
+ if (!tIsBool) {
+ Expect.isTrue(f601 is F601<int>);
+ Expect.isFalse(f601 is F601<bool>);
+ Expect.isTrue(confuse(f601) is F601<int>);
+ Expect.isFalse(confuse(f601) is F601<bool>);
+ Expect.equals(tIsDynamic, m601 is F601<bool>);
+ Expect.equals(tIsDynamic, confuse(m601) is F601<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x601 = (f601 as dynamic); });
+ Expect.throws(() { x601 = confuse(f601); });
+ int Function(int x2, [List<T> x3]) Function(int x) l601;
+ Expect.throws(() { l601 = (f601 as dynamic); });
+ Expect.throws(() { l601 = confuse(f601); });
+ }
+ int Function(int x2, [List<T> x3]) Function(int x) l601 = m601;
+ // In checked mode, verifies the type.
+ x601 = m601;
+ x601 = confuse(m601);
+ }
+ }
+
+ void testF701() {
+ // Function Function({Function x}) Function(int x)
+ Expect.isTrue(f701 is F701);
+ Expect.isTrue(confuse(f701) is F701);
+ // In checked mode, verifies the type.
+ Function Function({Function x}) Function(int x) l701;
+ // The static function f701 sets `T` to `int`.
+ if (!tIsBool) {
+ x701 = f701 as dynamic;
+ l701 = f701 as dynamic;
+ x701 = confuse(f701);
+ l701 = confuse(f701);
+ }
+
+ Expect.isTrue(m701 is F701);
+ Expect.isTrue(m701 is Function Function({Function x}) Function(int x));
+ Expect.isTrue(confuse(m701) is F701);
+ // In checked mode, verifies the type.
+ x701 = m701;
+ l701 = m701;
+ x701 = confuse(m701);
+ l701 = confuse(m701);
+
+ }
+
+ void testF801() {
+ // Function Function(List<T> x) Function(int x)
+ Expect.isTrue(f801 is F801);
+ Expect.isTrue(confuse(f801) is F801);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x) Function(int x) l801;
+ // The static function f801 sets `T` to `int`.
+ if (!tIsBool) {
+ x801 = f801 as dynamic;
+ l801 = f801 as dynamic;
+ x801 = confuse(f801);
+ l801 = confuse(f801);
+ }
+
+ Expect.isTrue(m801 is F801);
+ Expect.isTrue(m801 is Function Function(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m801) is F801);
+ // In checked mode, verifies the type.
+ x801 = m801;
+ l801 = m801;
+ x801 = confuse(m801);
+ l801 = confuse(m801);
+ if (!tIsBool) {
+ Expect.isTrue(f801 is F801<int>);
+ Expect.isFalse(f801 is F801<bool>);
+ Expect.isTrue(confuse(f801) is F801<int>);
+ Expect.isFalse(confuse(f801) is F801<bool>);
+ Expect.equals(tIsDynamic, m801 is F801<bool>);
+ Expect.equals(tIsDynamic, confuse(m801) is F801<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x801 = (f801 as dynamic); });
+ Expect.throws(() { x801 = confuse(f801); });
+ Function Function(List<T> x) Function(int x) l801;
+ Expect.throws(() { l801 = (f801 as dynamic); });
+ Expect.throws(() { l801 = confuse(f801); });
+ }
+ Function Function(List<T> x) Function(int x) l801 = m801;
+ // In checked mode, verifies the type.
+ x801 = m801;
+ x801 = confuse(m801);
+ }
+ }
+
+ void testF901() {
+ // List<Function> Function(int x1, [Function x]) Function(int x)
+ Expect.isTrue(f901 is F901);
+ Expect.isTrue(confuse(f901) is F901);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [Function x]) Function(int x) l901;
+ // The static function f901 sets `T` to `int`.
+ if (!tIsBool) {
+ x901 = f901 as dynamic;
+ l901 = f901 as dynamic;
+ x901 = confuse(f901);
+ l901 = confuse(f901);
+ }
+
+ Expect.isTrue(m901 is F901);
+ Expect.isTrue(m901 is List<Function> Function(int x1, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m901) is F901);
+ // In checked mode, verifies the type.
+ x901 = m901;
+ l901 = m901;
+ x901 = confuse(m901);
+ l901 = confuse(m901);
+
+ }
+
+ void testF1001() {
+ // List<Function> Function([core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1001 is F1001);
+ Expect.isTrue(confuse(f1001) is F1001);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x1]) Function(int x) l1001;
+ // The static function f1001 sets `T` to `int`.
+ if (!tIsBool) {
+ x1001 = f1001 as dynamic;
+ l1001 = f1001 as dynamic;
+ x1001 = confuse(f1001);
+ l1001 = confuse(f1001);
+ }
+
+ Expect.isTrue(m1001 is F1001);
+ Expect.isTrue(m1001 is List<Function> Function([core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1001) is F1001);
+ // In checked mode, verifies the type.
+ x1001 = m1001;
+ l1001 = m1001;
+ x1001 = confuse(m1001);
+ l1001 = confuse(m1001);
+
+ }
+
+ void testF1101() {
+ // core.List<core.int> Function(int x, [int x1]) Function(int x)
+ Expect.isTrue(f1101 is F1101);
+ Expect.isTrue(confuse(f1101) is F1101);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [int x1]) Function(int x) l1101;
+ // The static function f1101 sets `T` to `int`.
+ if (!tIsBool) {
+ x1101 = f1101 as dynamic;
+ l1101 = f1101 as dynamic;
+ x1101 = confuse(f1101);
+ l1101 = confuse(f1101);
+ }
+
+ Expect.isTrue(m1101 is F1101);
+ Expect.isTrue(m1101 is core.List<core.int> Function(int x, [int x1]) Function(int x));
+ Expect.isTrue(confuse(m1101) is F1101);
+ // In checked mode, verifies the type.
+ x1101 = m1101;
+ l1101 = m1101;
+ x1101 = confuse(m1101);
+ l1101 = confuse(m1101);
+
+ }
+
+ void testF1201() {
+ // core.List<core.int> Function(int y, {List<Function> x}) Function(int x)
+ Expect.isTrue(f1201 is F1201);
+ Expect.isTrue(confuse(f1201) is F1201);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<Function> x}) Function(int x) l1201;
+ // The static function f1201 sets `T` to `int`.
+ if (!tIsBool) {
+ x1201 = f1201 as dynamic;
+ l1201 = f1201 as dynamic;
+ x1201 = confuse(f1201);
+ l1201 = confuse(f1201);
+ }
+
+ Expect.isTrue(m1201 is F1201);
+ Expect.isTrue(m1201 is core.List<core.int> Function(int y, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1201) is F1201);
+ // In checked mode, verifies the type.
+ x1201 = m1201;
+ l1201 = m1201;
+ x1201 = confuse(m1201);
+ l1201 = confuse(m1201);
+
+ }
+
+ void testF1301() {
+ // List<T> Function([int x]) Function(int x)
+ Expect.isTrue(f1301 is F1301);
+ Expect.isTrue(confuse(f1301) is F1301);
+ // In checked mode, verifies the type.
+ List<T> Function([int x]) Function(int x) l1301;
+ // The static function f1301 sets `T` to `int`.
+ if (!tIsBool) {
+ x1301 = f1301 as dynamic;
+ l1301 = f1301 as dynamic;
+ x1301 = confuse(f1301);
+ l1301 = confuse(f1301);
+ }
+
+ Expect.isTrue(m1301 is F1301);
+ Expect.isTrue(m1301 is List<T> Function([int x]) Function(int x));
+ Expect.isTrue(confuse(m1301) is F1301);
+ // In checked mode, verifies the type.
+ x1301 = m1301;
+ l1301 = m1301;
+ x1301 = confuse(m1301);
+ l1301 = confuse(m1301);
+ if (!tIsBool) {
+ Expect.isTrue(f1301 is F1301<int>);
+ Expect.isFalse(f1301 is F1301<bool>);
+ Expect.isTrue(confuse(f1301) is F1301<int>);
+ Expect.isFalse(confuse(f1301) is F1301<bool>);
+ Expect.equals(tIsDynamic, m1301 is F1301<bool>);
+ Expect.equals(tIsDynamic, confuse(m1301) is F1301<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1301 = (f1301 as dynamic); });
+ Expect.throws(() { x1301 = confuse(f1301); });
+ List<T> Function([int x]) Function(int x) l1301;
+ Expect.throws(() { l1301 = (f1301 as dynamic); });
+ Expect.throws(() { l1301 = confuse(f1301); });
+ }
+ List<T> Function([int x]) Function(int x) l1301 = m1301;
+ // In checked mode, verifies the type.
+ x1301 = m1301;
+ x1301 = confuse(m1301);
+ }
+ }
+
+ void testF1401() {
+ // List<T> Function(List<Function> x1) Function(int x)
+ Expect.isTrue(f1401 is F1401);
+ Expect.isTrue(confuse(f1401) is F1401);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x1) Function(int x) l1401;
+ // The static function f1401 sets `T` to `int`.
+ if (!tIsBool) {
+ x1401 = f1401 as dynamic;
+ l1401 = f1401 as dynamic;
+ x1401 = confuse(f1401);
+ l1401 = confuse(f1401);
+ }
+
+ Expect.isTrue(m1401 is F1401);
+ Expect.isTrue(m1401 is List<T> Function(List<Function> x1) Function(int x));
+ Expect.isTrue(confuse(m1401) is F1401);
+ // In checked mode, verifies the type.
+ x1401 = m1401;
+ l1401 = m1401;
+ x1401 = confuse(m1401);
+ l1401 = confuse(m1401);
+ if (!tIsBool) {
+ Expect.isTrue(f1401 is F1401<int>);
+ Expect.isFalse(f1401 is F1401<bool>);
+ Expect.isTrue(confuse(f1401) is F1401<int>);
+ Expect.isFalse(confuse(f1401) is F1401<bool>);
+ Expect.equals(tIsDynamic, m1401 is F1401<bool>);
+ Expect.equals(tIsDynamic, confuse(m1401) is F1401<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1401 = (f1401 as dynamic); });
+ Expect.throws(() { x1401 = confuse(f1401); });
+ List<T> Function(List<Function> x1) Function(int x) l1401;
+ Expect.throws(() { l1401 = (f1401 as dynamic); });
+ Expect.throws(() { l1401 = confuse(f1401); });
+ }
+ List<T> Function(List<Function> x1) Function(int x) l1401 = m1401;
+ // In checked mode, verifies the type.
+ x1401 = m1401;
+ x1401 = confuse(m1401);
+ }
+ }
+
+ void testF1501() {
+ // List<T> Function(int x, [List<T> x1]) Function(int x)
+ Expect.isTrue(f1501 is F1501);
+ Expect.isTrue(confuse(f1501) is F1501);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<T> x1]) Function(int x) l1501;
+ // The static function f1501 sets `T` to `int`.
+ if (!tIsBool) {
+ x1501 = f1501 as dynamic;
+ l1501 = f1501 as dynamic;
+ x1501 = confuse(f1501);
+ l1501 = confuse(f1501);
+ }
+
+ Expect.isTrue(m1501 is F1501);
+ Expect.isTrue(m1501 is List<T> Function(int x, [List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1501) is F1501);
+ // In checked mode, verifies the type.
+ x1501 = m1501;
+ l1501 = m1501;
+ x1501 = confuse(m1501);
+ l1501 = confuse(m1501);
+ if (!tIsBool) {
+ Expect.isTrue(f1501 is F1501<int>);
+ Expect.isFalse(f1501 is F1501<bool>);
+ Expect.isTrue(confuse(f1501) is F1501<int>);
+ Expect.isFalse(confuse(f1501) is F1501<bool>);
+ Expect.equals(tIsDynamic, m1501 is F1501<bool>);
+ Expect.equals(tIsDynamic, confuse(m1501) is F1501<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1501 = (f1501 as dynamic); });
+ Expect.throws(() { x1501 = confuse(f1501); });
+ List<T> Function(int x, [List<T> x1]) Function(int x) l1501;
+ Expect.throws(() { l1501 = (f1501 as dynamic); });
+ Expect.throws(() { l1501 = confuse(f1501); });
+ }
+ List<T> Function(int x, [List<T> x1]) Function(int x) l1501 = m1501;
+ // In checked mode, verifies the type.
+ x1501 = m1501;
+ x1501 = confuse(m1501);
+ }
+ }
+
+ void testF1601() {
+ // Function(int x1, {Function x}) Function(int x)
+ Expect.isTrue(f1601 is F1601);
+ Expect.isTrue(confuse(f1601) is F1601);
+ // In checked mode, verifies the type.
+ Function(int x1, {Function x}) Function(int x) l1601;
+ // The static function f1601 sets `T` to `int`.
+ if (!tIsBool) {
+ x1601 = f1601 as dynamic;
+ l1601 = f1601 as dynamic;
+ x1601 = confuse(f1601);
+ l1601 = confuse(f1601);
+ }
+
+ Expect.isTrue(m1601 is F1601);
+ Expect.isTrue(m1601 is Function(int x1, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m1601) is F1601);
+ // In checked mode, verifies the type.
+ x1601 = m1601;
+ l1601 = m1601;
+ x1601 = confuse(m1601);
+ l1601 = confuse(m1601);
+
+ }
+
+ void testF1701() {
+ // Function([List<T> x]) Function(int x)
+ Expect.isTrue(f1701 is F1701);
+ Expect.isTrue(confuse(f1701) is F1701);
+ // In checked mode, verifies the type.
+ Function([List<T> x]) Function(int x) l1701;
+ // The static function f1701 sets `T` to `int`.
+ if (!tIsBool) {
+ x1701 = f1701 as dynamic;
+ l1701 = f1701 as dynamic;
+ x1701 = confuse(f1701);
+ l1701 = confuse(f1701);
+ }
+
+ Expect.isTrue(m1701 is F1701);
+ Expect.isTrue(m1701 is Function([List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1701) is F1701);
+ // In checked mode, verifies the type.
+ x1701 = m1701;
+ l1701 = m1701;
+ x1701 = confuse(m1701);
+ l1701 = confuse(m1701);
+ if (!tIsBool) {
+ Expect.isTrue(f1701 is F1701<int>);
+ Expect.isFalse(f1701 is F1701<bool>);
+ Expect.isTrue(confuse(f1701) is F1701<int>);
+ Expect.isFalse(confuse(f1701) is F1701<bool>);
+ Expect.equals(tIsDynamic, m1701 is F1701<bool>);
+ Expect.equals(tIsDynamic, confuse(m1701) is F1701<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1701 = (f1701 as dynamic); });
+ Expect.throws(() { x1701 = confuse(f1701); });
+ Function([List<T> x]) Function(int x) l1701;
+ Expect.throws(() { l1701 = (f1701 as dynamic); });
+ Expect.throws(() { l1701 = confuse(f1701); });
+ }
+ Function([List<T> x]) Function(int x) l1701 = m1701;
+ // In checked mode, verifies the type.
+ x1701 = m1701;
+ x1701 = confuse(m1701);
+ }
+ }
+
+ void testF1801() {
+ // Function Function<A>(A x) Function(int x)
+ Expect.isTrue(f1801 is F1801);
+ Expect.isTrue(confuse(f1801) is F1801);
+ // In checked mode, verifies the type.
+ Function Function<A>(A x) Function(int x) l1801;
+ // The static function f1801 sets `T` to `int`.
+ if (!tIsBool) {
+ x1801 = f1801 as dynamic;
+ l1801 = f1801 as dynamic;
+ x1801 = confuse(f1801);
+ l1801 = confuse(f1801);
+ }
+
+ Expect.isTrue(m1801 is F1801);
+ Expect.isTrue(m1801 is Function Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1801) is F1801);
+ // In checked mode, verifies the type.
+ x1801 = m1801;
+ l1801 = m1801;
+ x1801 = confuse(m1801);
+ l1801 = confuse(m1801);
+
+ }
+
+ void testF1901() {
+ // List<T> Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1901 is F1901);
+ Expect.isTrue(confuse(f1901) is F1901);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<A> x) Function(int x) l1901;
+ // The static function f1901 sets `T` to `int`.
+ if (!tIsBool) {
+ x1901 = f1901 as dynamic;
+ l1901 = f1901 as dynamic;
+ x1901 = confuse(f1901);
+ l1901 = confuse(f1901);
+ }
+
+ Expect.isTrue(m1901 is F1901);
+ Expect.isTrue(m1901 is List<T> Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1901) is F1901);
+ // In checked mode, verifies the type.
+ x1901 = m1901;
+ l1901 = m1901;
+ x1901 = confuse(m1901);
+ l1901 = confuse(m1901);
+ if (!tIsBool) {
+ Expect.isTrue(f1901 is F1901<int>);
+ Expect.isFalse(f1901 is F1901<bool>);
+ Expect.isTrue(confuse(f1901) is F1901<int>);
+ Expect.isFalse(confuse(f1901) is F1901<bool>);
+ Expect.equals(tIsDynamic, m1901 is F1901<bool>);
+ Expect.equals(tIsDynamic, confuse(m1901) is F1901<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1901 = (f1901 as dynamic); });
+ Expect.throws(() { x1901 = confuse(f1901); });
+ List<T> Function<A>(List<A> x) Function(int x) l1901;
+ Expect.throws(() { l1901 = (f1901 as dynamic); });
+ Expect.throws(() { l1901 = confuse(f1901); });
+ }
+ List<T> Function<A>(List<A> x) Function(int x) l1901 = m1901;
+ // In checked mode, verifies the type.
+ x1901 = m1901;
+ x1901 = confuse(m1901);
+ }
+ }
+
+ void testF2001() {
+ // int Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2001 is F2001);
+ Expect.isTrue(confuse(f2001) is F2001);
+ // In checked mode, verifies the type.
+ int Function(B x) Function<B extends core.int>(int x) l2001;
+ // The static function f2001 sets `T` to `int`.
+ if (!tIsBool) {
+ x2001 = f2001 as dynamic;
+ l2001 = f2001 as dynamic;
+ x2001 = confuse(f2001);
+ l2001 = confuse(f2001);
+ }
+
+ Expect.isTrue(m2001 is F2001);
+ Expect.isTrue(m2001 is int Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2001) is F2001);
+ // In checked mode, verifies the type.
+ x2001 = m2001;
+ l2001 = m2001;
+ x2001 = confuse(m2001);
+ l2001 = confuse(m2001);
+
+ }
+
+
+}
+
+class C2<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, [int x]) x2;
+ Function Function(int x0, [List<T> x]) x102;
+ core.List<core.int> Function([core.List<core.int> x]) x202;
+ Function(List<Function> x) x302;
+ int Function(int x) Function<B extends core.int>() x402;
+ int Function(int y, [List<Function> x]) Function<B extends core.int>() x502;
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>() x602;
+ Function Function({Function x}) Function<B extends core.int>() x702;
+ Function Function(List<T> x) Function<B extends core.int>() x802;
+ List<Function> Function(int x1, [Function x]) Function<B extends core.int>() x902;
+ List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>() x1002;
+ core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>() x1102;
+ core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>() x1202;
+ List<T> Function([int x]) Function<B extends core.int>() x1302;
+ List<T> Function(List<Function> x1) Function<B extends core.int>() x1402;
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>() x1502;
+ Function(int x1, {Function x}) Function<B extends core.int>() x1602;
+ Function([List<T> x]) Function<B extends core.int>() x1702;
+ Function Function<A>(A x) Function<B extends core.int>() x1802;
+ List<T> Function<A>(List<A> x) Function<B extends core.int>() x1902;
+ Function Function(B x) Function<B extends core.int>() x2002;
+
+
+ C2({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m2(int x0, [int x]) => null;
+ Function m102(int x0, [List<T> x]) => null;
+ core.List<core.int> m202([core.List<core.int> x]) => null;
+ m302(List<Function> x) => null;
+ int Function(int x) m402<B extends core.int>() => null;
+ int Function(int y, [List<Function> x]) m502<B extends core.int>() => null;
+ int Function(int x0, [List<T> x1]) m602<B extends core.int>() => null;
+ Function Function({Function x}) m702<B extends core.int>() => null;
+ Function Function(List<T> x) m802<B extends core.int>() => null;
+ List<Function> Function(int x0, [Function x]) m902<B extends core.int>() => null;
+ List<Function> Function([core.List<core.int> x0]) m1002<B extends core.int>() => null;
+ core.List<core.int> Function(int x, [int x0]) m1102<B extends core.int>() => null;
+ core.List<core.int> Function(int y, {List<Function> x}) m1202<B extends core.int>() => null;
+ List<T> Function([int x]) m1302<B extends core.int>() => null;
+ List<T> Function(List<Function> x0) m1402<B extends core.int>() => null;
+ List<T> Function(int x, [List<T> x0]) m1502<B extends core.int>() => null;
+ Function(int x0, {Function x}) m1602<B extends core.int>() => null;
+ Function([List<T> x]) m1702<B extends core.int>() => null;
+ Function Function<A>(A x) m1802<B extends core.int>() => null;
+ List<T> Function<A>(List<A> x) m1902<B extends core.int>() => null;
+ Function Function(B x) m2002<B extends core.int>() => null;
+
+
+ runTests() {
+ testF2();
+ testF102();
+ testF202();
+ testF302();
+ testF402();
+ testF502();
+ testF602();
+ testF702();
+ testF802();
+ testF902();
+ testF1002();
+ testF1102();
+ testF1202();
+ testF1302();
+ testF1402();
+ testF1502();
+ testF1602();
+ testF1702();
+ testF1802();
+ testF1902();
+ testF2002();
+ }
+
+ void testF2() {
+ // int Function(int x0, [int x])
+ Expect.isTrue(f2 is F2);
+ Expect.isTrue(confuse(f2) is F2);
+ // In checked mode, verifies the type.
+ int Function(int x0, [int x]) l2;
+ // The static function f2 sets `T` to `int`.
+ if (!tIsBool) {
+ x2 = f2 as dynamic;
+ l2 = f2 as dynamic;
+ x2 = confuse(f2);
+ l2 = confuse(f2);
+ }
+
+ Expect.isTrue(m2 is F2);
+ Expect.isTrue(m2 is int Function(int x0, [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 testF102() {
+ // Function Function(int x0, [List<T> x])
+ Expect.isTrue(f102 is F102);
+ Expect.isTrue(confuse(f102) is F102);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [List<T> x]) l102;
+ // The static function f102 sets `T` to `int`.
+ if (!tIsBool) {
+ x102 = f102 as dynamic;
+ l102 = f102 as dynamic;
+ x102 = confuse(f102);
+ l102 = confuse(f102);
+ }
+
+ Expect.isTrue(m102 is F102);
+ Expect.isTrue(m102 is Function Function(int x0, [List<T> x]));
+ Expect.isTrue(confuse(m102) is F102);
+ // In checked mode, verifies the type.
+ x102 = m102;
+ l102 = m102;
+ x102 = confuse(m102);
+ l102 = confuse(m102);
+ if (!tIsBool) {
+ Expect.isTrue(f102 is F102<int>);
+ Expect.isFalse(f102 is F102<bool>);
+ Expect.isTrue(confuse(f102) is F102<int>);
+ Expect.isFalse(confuse(f102) is F102<bool>);
+ Expect.equals(tIsDynamic, m102 is F102<bool>);
+ Expect.equals(tIsDynamic, confuse(m102) is F102<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x102 = (f102 as dynamic); });
+ Expect.throws(() { x102 = confuse(f102); });
+ Function Function(int x0, [List<T> x]) l102;
+ Expect.throws(() { l102 = (f102 as dynamic); });
+ Expect.throws(() { l102 = confuse(f102); });
+ }
+ Function Function(int x0, [List<T> x]) l102 = m102;
+ // In checked mode, verifies the type.
+ x102 = m102;
+ x102 = confuse(m102);
+ }
+ }
+
+ void testF202() {
+ // core.List<core.int> Function([core.List<core.int> x])
+ Expect.isTrue(f202 is F202);
+ Expect.isTrue(confuse(f202) is F202);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x]) l202;
+ // The static function f202 sets `T` to `int`.
+ if (!tIsBool) {
+ x202 = f202 as dynamic;
+ l202 = f202 as dynamic;
+ x202 = confuse(f202);
+ l202 = confuse(f202);
+ }
+
+ Expect.isTrue(m202 is F202);
+ Expect.isTrue(m202 is core.List<core.int> Function([core.List<core.int> x]));
+ Expect.isTrue(confuse(m202) is F202);
+ // In checked mode, verifies the type.
+ x202 = m202;
+ l202 = m202;
+ x202 = confuse(m202);
+ l202 = confuse(m202);
+
+ }
+
+ void testF302() {
+ // Function(List<Function> x)
+ Expect.isTrue(f302 is F302);
+ Expect.isTrue(confuse(f302) is F302);
+ // In checked mode, verifies the type.
+ Function(List<Function> x) l302;
+ // The static function f302 sets `T` to `int`.
+ if (!tIsBool) {
+ x302 = f302 as dynamic;
+ l302 = f302 as dynamic;
+ x302 = confuse(f302);
+ l302 = confuse(f302);
+ }
+
+ Expect.isTrue(m302 is F302);
+ Expect.isTrue(m302 is Function(List<Function> x));
+ Expect.isTrue(confuse(m302) is F302);
+ // In checked mode, verifies the type.
+ x302 = m302;
+ l302 = m302;
+ x302 = confuse(m302);
+ l302 = confuse(m302);
+
+ }
+
+ void testF402() {
+ // int Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f402 is F402);
+ Expect.isTrue(confuse(f402) is F402);
+ // In checked mode, verifies the type.
+ int Function(int x) Function<B extends core.int>() l402;
+ // The static function f402 sets `T` to `int`.
+ if (!tIsBool) {
+ x402 = f402 as dynamic;
+ l402 = f402 as dynamic;
+ x402 = confuse(f402);
+ l402 = confuse(f402);
+ }
+
+ Expect.isTrue(m402 is F402);
+ Expect.isTrue(m402 is int Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m402) is F402);
+ // In checked mode, verifies the type.
+ x402 = m402;
+ l402 = m402;
+ x402 = confuse(m402);
+ l402 = confuse(m402);
+
+ }
+
+ void testF502() {
+ // int Function(int y, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f502 is F502);
+ Expect.isTrue(confuse(f502) is F502);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<Function> x]) Function<B extends core.int>() l502;
+ // The static function f502 sets `T` to `int`.
+ if (!tIsBool) {
+ x502 = f502 as dynamic;
+ l502 = f502 as dynamic;
+ x502 = confuse(f502);
+ l502 = confuse(f502);
+ }
+
+ Expect.isTrue(m502 is F502);
+ Expect.isTrue(m502 is int Function(int y, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m502) is F502);
+ // In checked mode, verifies the type.
+ x502 = m502;
+ l502 = m502;
+ x502 = confuse(m502);
+ l502 = confuse(m502);
+
+ }
+
+ void testF602() {
+ // int Function(int x2, [List<T> x3]) Function<B extends core.int>()
+ Expect.isTrue(f602 is F602);
+ Expect.isTrue(confuse(f602) is F602);
+ // In checked mode, verifies the type.
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>() l602;
+ // The static function f602 sets `T` to `int`.
+ if (!tIsBool) {
+ x602 = f602 as dynamic;
+ l602 = f602 as dynamic;
+ x602 = confuse(f602);
+ l602 = confuse(f602);
+ }
+
+ Expect.isTrue(m602 is F602);
+ Expect.isTrue(m602 is int Function(int x2, [List<T> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m602) is F602);
+ // In checked mode, verifies the type.
+ x602 = m602;
+ l602 = m602;
+ x602 = confuse(m602);
+ l602 = confuse(m602);
+ if (!tIsBool) {
+ Expect.isTrue(f602 is F602<int>);
+ Expect.isFalse(f602 is F602<bool>);
+ Expect.isTrue(confuse(f602) is F602<int>);
+ Expect.isFalse(confuse(f602) is F602<bool>);
+ Expect.equals(tIsDynamic, m602 is F602<bool>);
+ Expect.equals(tIsDynamic, confuse(m602) is F602<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x602 = (f602 as dynamic); });
+ Expect.throws(() { x602 = confuse(f602); });
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>() l602;
+ Expect.throws(() { l602 = (f602 as dynamic); });
+ Expect.throws(() { l602 = confuse(f602); });
+ }
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>() l602 = m602;
+ // In checked mode, verifies the type.
+ x602 = m602;
+ x602 = confuse(m602);
+ }
+ }
+
+ void testF702() {
+ // Function Function({Function x}) Function<B extends core.int>()
+ Expect.isTrue(f702 is F702);
+ Expect.isTrue(confuse(f702) is F702);
+ // In checked mode, verifies the type.
+ Function Function({Function x}) Function<B extends core.int>() l702;
+ // The static function f702 sets `T` to `int`.
+ if (!tIsBool) {
+ x702 = f702 as dynamic;
+ l702 = f702 as dynamic;
+ x702 = confuse(f702);
+ l702 = confuse(f702);
+ }
+
+ Expect.isTrue(m702 is F702);
+ Expect.isTrue(m702 is Function Function({Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m702) is F702);
+ // In checked mode, verifies the type.
+ x702 = m702;
+ l702 = m702;
+ x702 = confuse(m702);
+ l702 = confuse(m702);
+
+ }
+
+ void testF802() {
+ // Function Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f802 is F802);
+ Expect.isTrue(confuse(f802) is F802);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x) Function<B extends core.int>() l802;
+ // The static function f802 sets `T` to `int`.
+ if (!tIsBool) {
+ x802 = f802 as dynamic;
+ l802 = f802 as dynamic;
+ x802 = confuse(f802);
+ l802 = confuse(f802);
+ }
+
+ Expect.isTrue(m802 is F802);
+ Expect.isTrue(m802 is Function Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m802) is F802);
+ // In checked mode, verifies the type.
+ x802 = m802;
+ l802 = m802;
+ x802 = confuse(m802);
+ l802 = confuse(m802);
+ if (!tIsBool) {
+ Expect.isTrue(f802 is F802<int>);
+ Expect.isFalse(f802 is F802<bool>);
+ Expect.isTrue(confuse(f802) is F802<int>);
+ Expect.isFalse(confuse(f802) is F802<bool>);
+ Expect.equals(tIsDynamic, m802 is F802<bool>);
+ Expect.equals(tIsDynamic, confuse(m802) is F802<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x802 = (f802 as dynamic); });
+ Expect.throws(() { x802 = confuse(f802); });
+ Function Function(List<T> x) Function<B extends core.int>() l802;
+ Expect.throws(() { l802 = (f802 as dynamic); });
+ Expect.throws(() { l802 = confuse(f802); });
+ }
+ Function Function(List<T> x) Function<B extends core.int>() l802 = m802;
+ // In checked mode, verifies the type.
+ x802 = m802;
+ x802 = confuse(m802);
+ }
+ }
+
+ void testF902() {
+ // List<Function> Function(int x1, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f902 is F902);
+ Expect.isTrue(confuse(f902) is F902);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [Function x]) Function<B extends core.int>() l902;
+ // The static function f902 sets `T` to `int`.
+ if (!tIsBool) {
+ x902 = f902 as dynamic;
+ l902 = f902 as dynamic;
+ x902 = confuse(f902);
+ l902 = confuse(f902);
+ }
+
+ Expect.isTrue(m902 is F902);
+ Expect.isTrue(m902 is List<Function> Function(int x1, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m902) is F902);
+ // In checked mode, verifies the type.
+ x902 = m902;
+ l902 = m902;
+ x902 = confuse(m902);
+ l902 = confuse(m902);
+
+ }
+
+ void testF1002() {
+ // List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1002 is F1002);
+ Expect.isTrue(confuse(f1002) is F1002);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>() l1002;
+ // The static function f1002 sets `T` to `int`.
+ if (!tIsBool) {
+ x1002 = f1002 as dynamic;
+ l1002 = f1002 as dynamic;
+ x1002 = confuse(f1002);
+ l1002 = confuse(f1002);
+ }
+
+ Expect.isTrue(m1002 is F1002);
+ Expect.isTrue(m1002 is List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1002) is F1002);
+ // In checked mode, verifies the type.
+ x1002 = m1002;
+ l1002 = m1002;
+ x1002 = confuse(m1002);
+ l1002 = confuse(m1002);
+
+ }
+
+ void testF1102() {
+ // core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>()
+ Expect.isTrue(f1102 is F1102);
+ Expect.isTrue(confuse(f1102) is F1102);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>() l1102;
+ // The static function f1102 sets `T` to `int`.
+ if (!tIsBool) {
+ x1102 = f1102 as dynamic;
+ l1102 = f1102 as dynamic;
+ x1102 = confuse(f1102);
+ l1102 = confuse(f1102);
+ }
+
+ Expect.isTrue(m1102 is F1102);
+ Expect.isTrue(m1102 is core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1102) is F1102);
+ // In checked mode, verifies the type.
+ x1102 = m1102;
+ l1102 = m1102;
+ x1102 = confuse(m1102);
+ l1102 = confuse(m1102);
+
+ }
+
+ void testF1202() {
+ // core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1202 is F1202);
+ Expect.isTrue(confuse(f1202) is F1202);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>() l1202;
+ // The static function f1202 sets `T` to `int`.
+ if (!tIsBool) {
+ x1202 = f1202 as dynamic;
+ l1202 = f1202 as dynamic;
+ x1202 = confuse(f1202);
+ l1202 = confuse(f1202);
+ }
+
+ Expect.isTrue(m1202 is F1202);
+ Expect.isTrue(m1202 is core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1202) is F1202);
+ // In checked mode, verifies the type.
+ x1202 = m1202;
+ l1202 = m1202;
+ x1202 = confuse(m1202);
+ l1202 = confuse(m1202);
+
+ }
+
+ void testF1302() {
+ // List<T> Function([int x]) Function<B extends core.int>()
+ Expect.isTrue(f1302 is F1302);
+ Expect.isTrue(confuse(f1302) is F1302);
+ // In checked mode, verifies the type.
+ List<T> Function([int x]) Function<B extends core.int>() l1302;
+ // The static function f1302 sets `T` to `int`.
+ if (!tIsBool) {
+ x1302 = f1302 as dynamic;
+ l1302 = f1302 as dynamic;
+ x1302 = confuse(f1302);
+ l1302 = confuse(f1302);
+ }
+
+ Expect.isTrue(m1302 is F1302);
+ Expect.isTrue(m1302 is List<T> Function([int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1302) is F1302);
+ // In checked mode, verifies the type.
+ x1302 = m1302;
+ l1302 = m1302;
+ x1302 = confuse(m1302);
+ l1302 = confuse(m1302);
+ if (!tIsBool) {
+ Expect.isTrue(f1302 is F1302<int>);
+ Expect.isFalse(f1302 is F1302<bool>);
+ Expect.isTrue(confuse(f1302) is F1302<int>);
+ Expect.isFalse(confuse(f1302) is F1302<bool>);
+ Expect.equals(tIsDynamic, m1302 is F1302<bool>);
+ Expect.equals(tIsDynamic, confuse(m1302) is F1302<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1302 = (f1302 as dynamic); });
+ Expect.throws(() { x1302 = confuse(f1302); });
+ List<T> Function([int x]) Function<B extends core.int>() l1302;
+ Expect.throws(() { l1302 = (f1302 as dynamic); });
+ Expect.throws(() { l1302 = confuse(f1302); });
+ }
+ List<T> Function([int x]) Function<B extends core.int>() l1302 = m1302;
+ // In checked mode, verifies the type.
+ x1302 = m1302;
+ x1302 = confuse(m1302);
+ }
+ }
+
+ void testF1402() {
+ // List<T> Function(List<Function> x1) Function<B extends core.int>()
+ Expect.isTrue(f1402 is F1402);
+ Expect.isTrue(confuse(f1402) is F1402);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x1) Function<B extends core.int>() l1402;
+ // The static function f1402 sets `T` to `int`.
+ if (!tIsBool) {
+ x1402 = f1402 as dynamic;
+ l1402 = f1402 as dynamic;
+ x1402 = confuse(f1402);
+ l1402 = confuse(f1402);
+ }
+
+ Expect.isTrue(m1402 is F1402);
+ Expect.isTrue(m1402 is List<T> Function(List<Function> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1402) is F1402);
+ // In checked mode, verifies the type.
+ x1402 = m1402;
+ l1402 = m1402;
+ x1402 = confuse(m1402);
+ l1402 = confuse(m1402);
+ if (!tIsBool) {
+ Expect.isTrue(f1402 is F1402<int>);
+ Expect.isFalse(f1402 is F1402<bool>);
+ Expect.isTrue(confuse(f1402) is F1402<int>);
+ Expect.isFalse(confuse(f1402) is F1402<bool>);
+ Expect.equals(tIsDynamic, m1402 is F1402<bool>);
+ Expect.equals(tIsDynamic, confuse(m1402) is F1402<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1402 = (f1402 as dynamic); });
+ Expect.throws(() { x1402 = confuse(f1402); });
+ List<T> Function(List<Function> x1) Function<B extends core.int>() l1402;
+ Expect.throws(() { l1402 = (f1402 as dynamic); });
+ Expect.throws(() { l1402 = confuse(f1402); });
+ }
+ List<T> Function(List<Function> x1) Function<B extends core.int>() l1402 = m1402;
+ // In checked mode, verifies the type.
+ x1402 = m1402;
+ x1402 = confuse(m1402);
+ }
+ }
+
+ void testF1502() {
+ // List<T> Function(int x, [List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1502 is F1502);
+ Expect.isTrue(confuse(f1502) is F1502);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>() l1502;
+ // The static function f1502 sets `T` to `int`.
+ if (!tIsBool) {
+ x1502 = f1502 as dynamic;
+ l1502 = f1502 as dynamic;
+ x1502 = confuse(f1502);
+ l1502 = confuse(f1502);
+ }
+
+ Expect.isTrue(m1502 is F1502);
+ Expect.isTrue(m1502 is List<T> Function(int x, [List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1502) is F1502);
+ // In checked mode, verifies the type.
+ x1502 = m1502;
+ l1502 = m1502;
+ x1502 = confuse(m1502);
+ l1502 = confuse(m1502);
+ if (!tIsBool) {
+ Expect.isTrue(f1502 is F1502<int>);
+ Expect.isFalse(f1502 is F1502<bool>);
+ Expect.isTrue(confuse(f1502) is F1502<int>);
+ Expect.isFalse(confuse(f1502) is F1502<bool>);
+ Expect.equals(tIsDynamic, m1502 is F1502<bool>);
+ Expect.equals(tIsDynamic, confuse(m1502) is F1502<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1502 = (f1502 as dynamic); });
+ Expect.throws(() { x1502 = confuse(f1502); });
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>() l1502;
+ Expect.throws(() { l1502 = (f1502 as dynamic); });
+ Expect.throws(() { l1502 = confuse(f1502); });
+ }
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>() l1502 = m1502;
+ // In checked mode, verifies the type.
+ x1502 = m1502;
+ x1502 = confuse(m1502);
+ }
+ }
+
+ void testF1602() {
+ // Function(int x1, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1602 is F1602);
+ Expect.isTrue(confuse(f1602) is F1602);
+ // In checked mode, verifies the type.
+ Function(int x1, {Function x}) Function<B extends core.int>() l1602;
+ // The static function f1602 sets `T` to `int`.
+ if (!tIsBool) {
+ x1602 = f1602 as dynamic;
+ l1602 = f1602 as dynamic;
+ x1602 = confuse(f1602);
+ l1602 = confuse(f1602);
+ }
+
+ Expect.isTrue(m1602 is F1602);
+ Expect.isTrue(m1602 is Function(int x1, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1602) is F1602);
+ // In checked mode, verifies the type.
+ x1602 = m1602;
+ l1602 = m1602;
+ x1602 = confuse(m1602);
+ l1602 = confuse(m1602);
+
+ }
+
+ void testF1702() {
+ // Function([List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1702 is F1702);
+ Expect.isTrue(confuse(f1702) is F1702);
+ // In checked mode, verifies the type.
+ Function([List<T> x]) Function<B extends core.int>() l1702;
+ // The static function f1702 sets `T` to `int`.
+ if (!tIsBool) {
+ x1702 = f1702 as dynamic;
+ l1702 = f1702 as dynamic;
+ x1702 = confuse(f1702);
+ l1702 = confuse(f1702);
+ }
+
+ Expect.isTrue(m1702 is F1702);
+ Expect.isTrue(m1702 is Function([List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1702) is F1702);
+ // In checked mode, verifies the type.
+ x1702 = m1702;
+ l1702 = m1702;
+ x1702 = confuse(m1702);
+ l1702 = confuse(m1702);
+ if (!tIsBool) {
+ Expect.isTrue(f1702 is F1702<int>);
+ Expect.isFalse(f1702 is F1702<bool>);
+ Expect.isTrue(confuse(f1702) is F1702<int>);
+ Expect.isFalse(confuse(f1702) is F1702<bool>);
+ Expect.equals(tIsDynamic, m1702 is F1702<bool>);
+ Expect.equals(tIsDynamic, confuse(m1702) is F1702<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1702 = (f1702 as dynamic); });
+ Expect.throws(() { x1702 = confuse(f1702); });
+ Function([List<T> x]) Function<B extends core.int>() l1702;
+ Expect.throws(() { l1702 = (f1702 as dynamic); });
+ Expect.throws(() { l1702 = confuse(f1702); });
+ }
+ Function([List<T> x]) Function<B extends core.int>() l1702 = m1702;
+ // In checked mode, verifies the type.
+ x1702 = m1702;
+ x1702 = confuse(m1702);
+ }
+ }
+
+ void testF1802() {
+ // Function Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1802 is F1802);
+ Expect.isTrue(confuse(f1802) is F1802);
+ // In checked mode, verifies the type.
+ Function Function<A>(A x) Function<B extends core.int>() l1802;
+ // The static function f1802 sets `T` to `int`.
+ if (!tIsBool) {
+ x1802 = f1802 as dynamic;
+ l1802 = f1802 as dynamic;
+ x1802 = confuse(f1802);
+ l1802 = confuse(f1802);
+ }
+
+ Expect.isTrue(m1802 is F1802);
+ Expect.isTrue(m1802 is Function Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1802) is F1802);
+ // In checked mode, verifies the type.
+ x1802 = m1802;
+ l1802 = m1802;
+ x1802 = confuse(m1802);
+ l1802 = confuse(m1802);
+
+ }
+
+ void testF1902() {
+ // List<T> Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1902 is F1902);
+ Expect.isTrue(confuse(f1902) is F1902);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<A> x) Function<B extends core.int>() l1902;
+ // The static function f1902 sets `T` to `int`.
+ if (!tIsBool) {
+ x1902 = f1902 as dynamic;
+ l1902 = f1902 as dynamic;
+ x1902 = confuse(f1902);
+ l1902 = confuse(f1902);
+ }
+
+ Expect.isTrue(m1902 is F1902);
+ Expect.isTrue(m1902 is List<T> Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1902) is F1902);
+ // In checked mode, verifies the type.
+ x1902 = m1902;
+ l1902 = m1902;
+ x1902 = confuse(m1902);
+ l1902 = confuse(m1902);
+ if (!tIsBool) {
+ Expect.isTrue(f1902 is F1902<int>);
+ Expect.isFalse(f1902 is F1902<bool>);
+ Expect.isTrue(confuse(f1902) is F1902<int>);
+ Expect.isFalse(confuse(f1902) is F1902<bool>);
+ Expect.equals(tIsDynamic, m1902 is F1902<bool>);
+ Expect.equals(tIsDynamic, confuse(m1902) is F1902<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1902 = (f1902 as dynamic); });
+ Expect.throws(() { x1902 = confuse(f1902); });
+ List<T> Function<A>(List<A> x) Function<B extends core.int>() l1902;
+ Expect.throws(() { l1902 = (f1902 as dynamic); });
+ Expect.throws(() { l1902 = confuse(f1902); });
+ }
+ List<T> Function<A>(List<A> x) Function<B extends core.int>() l1902 = m1902;
+ // In checked mode, verifies the type.
+ x1902 = m1902;
+ x1902 = confuse(m1902);
+ }
+ }
+
+ void testF2002() {
+ // Function Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2002 is F2002);
+ Expect.isTrue(confuse(f2002) is F2002);
+ // In checked mode, verifies the type.
+ Function Function(B x) Function<B extends core.int>() l2002;
+ // The static function f2002 sets `T` to `int`.
+ if (!tIsBool) {
+ x2002 = f2002 as dynamic;
+ l2002 = f2002 as dynamic;
+ x2002 = confuse(f2002);
+ l2002 = confuse(f2002);
+ }
+
+ Expect.isTrue(m2002 is F2002);
+ Expect.isTrue(m2002 is Function Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2002) is F2002);
+ // In checked mode, verifies the type.
+ x2002 = m2002;
+ l2002 = m2002;
+ x2002 = confuse(m2002);
+ l2002 = confuse(m2002);
+
+ }
+
+
+}
+
+class C3<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, [int x]) x3;
+ Function Function(int y, [List<T> x]) x103;
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) x203;
+ Function([List<Function> x]) x303;
+ int Function(int x) Function<B extends core.int>(int x) x403;
+ int Function(int y, [List<Function> x]) Function<B extends core.int>(int x) x503;
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) x603;
+ Function Function({Function x}) Function<B extends core.int>(int x) x703;
+ Function Function(List<T> x) Function<B extends core.int>(int x) x803;
+ List<Function> Function(int x1, [Function x]) Function<B extends core.int>(int x) x903;
+ List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) x1003;
+ core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>(int x) x1103;
+ core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) x1203;
+ List<T> Function([int x]) Function<B extends core.int>(int x) x1303;
+ List<T> Function(List<Function> x1) Function<B extends core.int>(int x) x1403;
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) x1503;
+ Function(int x1, {Function x}) Function<B extends core.int>(int x) x1603;
+ Function([List<T> x]) Function<B extends core.int>(int x) x1703;
+ Function Function<A>(A x) Function<B extends core.int>(int x) x1803;
+ List<T> Function<A>(List<A> x) Function<B extends core.int>(int x) x1903;
+ Function Function(B x) Function<B extends core.int>(int x) x2003;
+
+
+ C3({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m3(int y, [int x]) => null;
+ Function m103(int y, [List<T> x]) => null;
+ core.List<core.int> m203(int x0, [core.List<core.int> x]) => null;
+ m303([List<Function> x]) => null;
+ int Function(int x) m403<B extends core.int>(int x) => null;
+ int Function(int y, [List<Function> x]) m503<B extends core.int>(int x) => null;
+ int Function(int x0, [List<T> x1]) m603<B extends core.int>(int x) => null;
+ Function Function({Function x}) m703<B extends core.int>(int x) => null;
+ Function Function(List<T> x) m803<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [Function x]) m903<B extends core.int>(int x) => null;
+ List<Function> Function([core.List<core.int> x0]) m1003<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x, [int x0]) m1103<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, {List<Function> x}) m1203<B extends core.int>(int x) => null;
+ List<T> Function([int x]) m1303<B extends core.int>(int x) => null;
+ List<T> Function(List<Function> x0) m1403<B extends core.int>(int x) => null;
+ List<T> Function(int x, [List<T> x0]) m1503<B extends core.int>(int x) => null;
+ Function(int x0, {Function x}) m1603<B extends core.int>(int x) => null;
+ Function([List<T> x]) m1703<B extends core.int>(int x) => null;
+ Function Function<A>(A x) m1803<B extends core.int>(int x) => null;
+ List<T> Function<A>(List<A> x) m1903<B extends core.int>(int x) => null;
+ Function Function(B x) m2003<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF3();
+ testF103();
+ testF203();
+ testF303();
+ testF403();
+ testF503();
+ testF603();
+ testF703();
+ testF803();
+ testF903();
+ testF1003();
+ testF1103();
+ testF1203();
+ testF1303();
+ testF1403();
+ testF1503();
+ testF1603();
+ testF1703();
+ testF1803();
+ testF1903();
+ testF2003();
+ }
+
+ void testF3() {
+ // int Function(int y, [int x])
+ Expect.isTrue(f3 is F3);
+ Expect.isTrue(confuse(f3) is F3);
+ // In checked mode, verifies the type.
+ int Function(int y, [int x]) l3;
+ // The static function f3 sets `T` to `int`.
+ if (!tIsBool) {
+ 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(int y, [int x]));
+ Expect.isTrue(confuse(m3) is F3);
+ // In checked mode, verifies the type.
+ x3 = m3;
+ l3 = m3;
+ x3 = confuse(m3);
+ l3 = confuse(m3);
+
+ }
+
+ void testF103() {
+ // Function Function(int y, [List<T> x])
+ Expect.isTrue(f103 is F103);
+ Expect.isTrue(confuse(f103) is F103);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<T> x]) l103;
+ // The static function f103 sets `T` to `int`.
+ if (!tIsBool) {
+ x103 = f103 as dynamic;
+ l103 = f103 as dynamic;
+ x103 = confuse(f103);
+ l103 = confuse(f103);
+ }
+
+ Expect.isTrue(m103 is F103);
+ Expect.isTrue(m103 is Function Function(int y, [List<T> x]));
+ Expect.isTrue(confuse(m103) is F103);
+ // In checked mode, verifies the type.
+ x103 = m103;
+ l103 = m103;
+ x103 = confuse(m103);
+ l103 = confuse(m103);
+ if (!tIsBool) {
+ Expect.isTrue(f103 is F103<int>);
+ Expect.isFalse(f103 is F103<bool>);
+ Expect.isTrue(confuse(f103) is F103<int>);
+ Expect.isFalse(confuse(f103) is F103<bool>);
+ Expect.equals(tIsDynamic, m103 is F103<bool>);
+ Expect.equals(tIsDynamic, confuse(m103) is F103<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x103 = (f103 as dynamic); });
+ Expect.throws(() { x103 = confuse(f103); });
+ Function Function(int y, [List<T> x]) l103;
+ Expect.throws(() { l103 = (f103 as dynamic); });
+ Expect.throws(() { l103 = confuse(f103); });
+ }
+ Function Function(int y, [List<T> x]) l103 = m103;
+ // In checked mode, verifies the type.
+ x103 = m103;
+ x103 = confuse(m103);
+ }
+ }
+
+ void testF203() {
+ // core.List<core.int> Function(int x0, [core.List<core.int> x])
+ Expect.isTrue(f203 is F203);
+ Expect.isTrue(confuse(f203) is F203);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) l203;
+ // The static function f203 sets `T` to `int`.
+ if (!tIsBool) {
+ x203 = f203 as dynamic;
+ l203 = f203 as dynamic;
+ x203 = confuse(f203);
+ l203 = confuse(f203);
+ }
+
+ Expect.isTrue(m203 is F203);
+ Expect.isTrue(m203 is core.List<core.int> Function(int x0, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m203) is F203);
+ // In checked mode, verifies the type.
+ x203 = m203;
+ l203 = m203;
+ x203 = confuse(m203);
+ l203 = confuse(m203);
+
+ }
+
+ void testF303() {
+ // Function([List<Function> x])
+ Expect.isTrue(f303 is F303);
+ Expect.isTrue(confuse(f303) is F303);
+ // In checked mode, verifies the type.
+ Function([List<Function> x]) l303;
+ // The static function f303 sets `T` to `int`.
+ if (!tIsBool) {
+ x303 = f303 as dynamic;
+ l303 = f303 as dynamic;
+ x303 = confuse(f303);
+ l303 = confuse(f303);
+ }
+
+ Expect.isTrue(m303 is F303);
+ Expect.isTrue(m303 is Function([List<Function> x]));
+ Expect.isTrue(confuse(m303) is F303);
+ // In checked mode, verifies the type.
+ x303 = m303;
+ l303 = m303;
+ x303 = confuse(m303);
+ l303 = confuse(m303);
+
+ }
+
+ void testF403() {
+ // int Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f403 is F403);
+ Expect.isTrue(confuse(f403) is F403);
+ // In checked mode, verifies the type.
+ int Function(int x) Function<B extends core.int>(int x) l403;
+ // The static function f403 sets `T` to `int`.
+ if (!tIsBool) {
+ x403 = f403 as dynamic;
+ l403 = f403 as dynamic;
+ x403 = confuse(f403);
+ l403 = confuse(f403);
+ }
+
+ Expect.isTrue(m403 is F403);
+ Expect.isTrue(m403 is int Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m403) is F403);
+ // In checked mode, verifies the type.
+ x403 = m403;
+ l403 = m403;
+ x403 = confuse(m403);
+ l403 = confuse(m403);
+
+ }
+
+ void testF503() {
+ // int Function(int y, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f503 is F503);
+ Expect.isTrue(confuse(f503) is F503);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l503;
+ // The static function f503 sets `T` to `int`.
+ if (!tIsBool) {
+ x503 = f503 as dynamic;
+ l503 = f503 as dynamic;
+ x503 = confuse(f503);
+ l503 = confuse(f503);
+ }
+
+ Expect.isTrue(m503 is F503);
+ Expect.isTrue(m503 is int Function(int y, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m503) is F503);
+ // In checked mode, verifies the type.
+ x503 = m503;
+ l503 = m503;
+ x503 = confuse(m503);
+ l503 = confuse(m503);
+
+ }
+
+ void testF603() {
+ // int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f603 is F603);
+ Expect.isTrue(confuse(f603) is F603);
+ // In checked mode, verifies the type.
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l603;
+ // The static function f603 sets `T` to `int`.
+ if (!tIsBool) {
+ x603 = f603 as dynamic;
+ l603 = f603 as dynamic;
+ x603 = confuse(f603);
+ l603 = confuse(f603);
+ }
+
+ Expect.isTrue(m603 is F603);
+ Expect.isTrue(m603 is int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m603) is F603);
+ // In checked mode, verifies the type.
+ x603 = m603;
+ l603 = m603;
+ x603 = confuse(m603);
+ l603 = confuse(m603);
+ if (!tIsBool) {
+ Expect.isTrue(f603 is F603<int>);
+ Expect.isFalse(f603 is F603<bool>);
+ Expect.isTrue(confuse(f603) is F603<int>);
+ Expect.isFalse(confuse(f603) is F603<bool>);
+ Expect.equals(tIsDynamic, m603 is F603<bool>);
+ Expect.equals(tIsDynamic, confuse(m603) is F603<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x603 = (f603 as dynamic); });
+ Expect.throws(() { x603 = confuse(f603); });
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l603;
+ Expect.throws(() { l603 = (f603 as dynamic); });
+ Expect.throws(() { l603 = confuse(f603); });
+ }
+ int Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l603 = m603;
+ // In checked mode, verifies the type.
+ x603 = m603;
+ x603 = confuse(m603);
+ }
+ }
+
+ void testF703() {
+ // Function Function({Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f703 is F703);
+ Expect.isTrue(confuse(f703) is F703);
+ // In checked mode, verifies the type.
+ Function Function({Function x}) Function<B extends core.int>(int x) l703;
+ // The static function f703 sets `T` to `int`.
+ if (!tIsBool) {
+ x703 = f703 as dynamic;
+ l703 = f703 as dynamic;
+ x703 = confuse(f703);
+ l703 = confuse(f703);
+ }
+
+ Expect.isTrue(m703 is F703);
+ Expect.isTrue(m703 is Function Function({Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m703) is F703);
+ // In checked mode, verifies the type.
+ x703 = m703;
+ l703 = m703;
+ x703 = confuse(m703);
+ l703 = confuse(m703);
+
+ }
+
+ void testF803() {
+ // Function Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f803 is F803);
+ Expect.isTrue(confuse(f803) is F803);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x) Function<B extends core.int>(int x) l803;
+ // The static function f803 sets `T` to `int`.
+ if (!tIsBool) {
+ x803 = f803 as dynamic;
+ l803 = f803 as dynamic;
+ x803 = confuse(f803);
+ l803 = confuse(f803);
+ }
+
+ Expect.isTrue(m803 is F803);
+ Expect.isTrue(m803 is Function Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m803) is F803);
+ // In checked mode, verifies the type.
+ x803 = m803;
+ l803 = m803;
+ x803 = confuse(m803);
+ l803 = confuse(m803);
+ if (!tIsBool) {
+ Expect.isTrue(f803 is F803<int>);
+ Expect.isFalse(f803 is F803<bool>);
+ Expect.isTrue(confuse(f803) is F803<int>);
+ Expect.isFalse(confuse(f803) is F803<bool>);
+ Expect.equals(tIsDynamic, m803 is F803<bool>);
+ Expect.equals(tIsDynamic, confuse(m803) is F803<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x803 = (f803 as dynamic); });
+ Expect.throws(() { x803 = confuse(f803); });
+ Function Function(List<T> x) Function<B extends core.int>(int x) l803;
+ Expect.throws(() { l803 = (f803 as dynamic); });
+ Expect.throws(() { l803 = confuse(f803); });
+ }
+ Function Function(List<T> x) Function<B extends core.int>(int x) l803 = m803;
+ // In checked mode, verifies the type.
+ x803 = m803;
+ x803 = confuse(m803);
+ }
+ }
+
+ void testF903() {
+ // List<Function> Function(int x1, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f903 is F903);
+ Expect.isTrue(confuse(f903) is F903);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [Function x]) Function<B extends core.int>(int x) l903;
+ // The static function f903 sets `T` to `int`.
+ if (!tIsBool) {
+ x903 = f903 as dynamic;
+ l903 = f903 as dynamic;
+ x903 = confuse(f903);
+ l903 = confuse(f903);
+ }
+
+ Expect.isTrue(m903 is F903);
+ Expect.isTrue(m903 is List<Function> Function(int x1, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m903) is F903);
+ // In checked mode, verifies the type.
+ x903 = m903;
+ l903 = m903;
+ x903 = confuse(m903);
+ l903 = confuse(m903);
+
+ }
+
+ void testF1003() {
+ // List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1003 is F1003);
+ Expect.isTrue(confuse(f1003) is F1003);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l1003;
+ // The static function f1003 sets `T` to `int`.
+ if (!tIsBool) {
+ x1003 = f1003 as dynamic;
+ l1003 = f1003 as dynamic;
+ x1003 = confuse(f1003);
+ l1003 = confuse(f1003);
+ }
+
+ Expect.isTrue(m1003 is F1003);
+ Expect.isTrue(m1003 is List<Function> Function([core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1003) is F1003);
+ // In checked mode, verifies the type.
+ x1003 = m1003;
+ l1003 = m1003;
+ x1003 = confuse(m1003);
+ l1003 = confuse(m1003);
+
+ }
+
+ void testF1103() {
+ // core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1103 is F1103);
+ Expect.isTrue(confuse(f1103) is F1103);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>(int x) l1103;
+ // The static function f1103 sets `T` to `int`.
+ if (!tIsBool) {
+ x1103 = f1103 as dynamic;
+ l1103 = f1103 as dynamic;
+ x1103 = confuse(f1103);
+ l1103 = confuse(f1103);
+ }
+
+ Expect.isTrue(m1103 is F1103);
+ Expect.isTrue(m1103 is core.List<core.int> Function(int x, [int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1103) is F1103);
+ // In checked mode, verifies the type.
+ x1103 = m1103;
+ l1103 = m1103;
+ x1103 = confuse(m1103);
+ l1103 = confuse(m1103);
+
+ }
+
+ void testF1203() {
+ // core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1203 is F1203);
+ Expect.isTrue(confuse(f1203) is F1203);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l1203;
+ // The static function f1203 sets `T` to `int`.
+ if (!tIsBool) {
+ x1203 = f1203 as dynamic;
+ l1203 = f1203 as dynamic;
+ x1203 = confuse(f1203);
+ l1203 = confuse(f1203);
+ }
+
+ Expect.isTrue(m1203 is F1203);
+ Expect.isTrue(m1203 is core.List<core.int> Function(int y, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1203) is F1203);
+ // In checked mode, verifies the type.
+ x1203 = m1203;
+ l1203 = m1203;
+ x1203 = confuse(m1203);
+ l1203 = confuse(m1203);
+
+ }
+
+ void testF1303() {
+ // List<T> Function([int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1303 is F1303);
+ Expect.isTrue(confuse(f1303) is F1303);
+ // In checked mode, verifies the type.
+ List<T> Function([int x]) Function<B extends core.int>(int x) l1303;
+ // The static function f1303 sets `T` to `int`.
+ if (!tIsBool) {
+ x1303 = f1303 as dynamic;
+ l1303 = f1303 as dynamic;
+ x1303 = confuse(f1303);
+ l1303 = confuse(f1303);
+ }
+
+ Expect.isTrue(m1303 is F1303);
+ Expect.isTrue(m1303 is List<T> Function([int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1303) is F1303);
+ // In checked mode, verifies the type.
+ x1303 = m1303;
+ l1303 = m1303;
+ x1303 = confuse(m1303);
+ l1303 = confuse(m1303);
+ if (!tIsBool) {
+ Expect.isTrue(f1303 is F1303<int>);
+ Expect.isFalse(f1303 is F1303<bool>);
+ Expect.isTrue(confuse(f1303) is F1303<int>);
+ Expect.isFalse(confuse(f1303) is F1303<bool>);
+ Expect.equals(tIsDynamic, m1303 is F1303<bool>);
+ Expect.equals(tIsDynamic, confuse(m1303) is F1303<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1303 = (f1303 as dynamic); });
+ Expect.throws(() { x1303 = confuse(f1303); });
+ List<T> Function([int x]) Function<B extends core.int>(int x) l1303;
+ Expect.throws(() { l1303 = (f1303 as dynamic); });
+ Expect.throws(() { l1303 = confuse(f1303); });
+ }
+ List<T> Function([int x]) Function<B extends core.int>(int x) l1303 = m1303;
+ // In checked mode, verifies the type.
+ x1303 = m1303;
+ x1303 = confuse(m1303);
+ }
+ }
+
+ void testF1403() {
+ // List<T> Function(List<Function> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1403 is F1403);
+ Expect.isTrue(confuse(f1403) is F1403);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x1) Function<B extends core.int>(int x) l1403;
+ // The static function f1403 sets `T` to `int`.
+ if (!tIsBool) {
+ x1403 = f1403 as dynamic;
+ l1403 = f1403 as dynamic;
+ x1403 = confuse(f1403);
+ l1403 = confuse(f1403);
+ }
+
+ Expect.isTrue(m1403 is F1403);
+ Expect.isTrue(m1403 is List<T> Function(List<Function> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1403) is F1403);
+ // In checked mode, verifies the type.
+ x1403 = m1403;
+ l1403 = m1403;
+ x1403 = confuse(m1403);
+ l1403 = confuse(m1403);
+ if (!tIsBool) {
+ Expect.isTrue(f1403 is F1403<int>);
+ Expect.isFalse(f1403 is F1403<bool>);
+ Expect.isTrue(confuse(f1403) is F1403<int>);
+ Expect.isFalse(confuse(f1403) is F1403<bool>);
+ Expect.equals(tIsDynamic, m1403 is F1403<bool>);
+ Expect.equals(tIsDynamic, confuse(m1403) is F1403<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1403 = (f1403 as dynamic); });
+ Expect.throws(() { x1403 = confuse(f1403); });
+ List<T> Function(List<Function> x1) Function<B extends core.int>(int x) l1403;
+ Expect.throws(() { l1403 = (f1403 as dynamic); });
+ Expect.throws(() { l1403 = confuse(f1403); });
+ }
+ List<T> Function(List<Function> x1) Function<B extends core.int>(int x) l1403 = m1403;
+ // In checked mode, verifies the type.
+ x1403 = m1403;
+ x1403 = confuse(m1403);
+ }
+ }
+
+ void testF1503() {
+ // List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1503 is F1503);
+ Expect.isTrue(confuse(f1503) is F1503);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1503;
+ // The static function f1503 sets `T` to `int`.
+ if (!tIsBool) {
+ x1503 = f1503 as dynamic;
+ l1503 = f1503 as dynamic;
+ x1503 = confuse(f1503);
+ l1503 = confuse(f1503);
+ }
+
+ Expect.isTrue(m1503 is F1503);
+ Expect.isTrue(m1503 is List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1503) is F1503);
+ // In checked mode, verifies the type.
+ x1503 = m1503;
+ l1503 = m1503;
+ x1503 = confuse(m1503);
+ l1503 = confuse(m1503);
+ if (!tIsBool) {
+ Expect.isTrue(f1503 is F1503<int>);
+ Expect.isFalse(f1503 is F1503<bool>);
+ Expect.isTrue(confuse(f1503) is F1503<int>);
+ Expect.isFalse(confuse(f1503) is F1503<bool>);
+ Expect.equals(tIsDynamic, m1503 is F1503<bool>);
+ Expect.equals(tIsDynamic, confuse(m1503) is F1503<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1503 = (f1503 as dynamic); });
+ Expect.throws(() { x1503 = confuse(f1503); });
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1503;
+ Expect.throws(() { l1503 = (f1503 as dynamic); });
+ Expect.throws(() { l1503 = confuse(f1503); });
+ }
+ List<T> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1503 = m1503;
+ // In checked mode, verifies the type.
+ x1503 = m1503;
+ x1503 = confuse(m1503);
+ }
+ }
+
+ void testF1603() {
+ // Function(int x1, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1603 is F1603);
+ Expect.isTrue(confuse(f1603) is F1603);
+ // In checked mode, verifies the type.
+ Function(int x1, {Function x}) Function<B extends core.int>(int x) l1603;
+ // The static function f1603 sets `T` to `int`.
+ if (!tIsBool) {
+ x1603 = f1603 as dynamic;
+ l1603 = f1603 as dynamic;
+ x1603 = confuse(f1603);
+ l1603 = confuse(f1603);
+ }
+
+ Expect.isTrue(m1603 is F1603);
+ Expect.isTrue(m1603 is Function(int x1, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1603) is F1603);
+ // In checked mode, verifies the type.
+ x1603 = m1603;
+ l1603 = m1603;
+ x1603 = confuse(m1603);
+ l1603 = confuse(m1603);
+
+ }
+
+ void testF1703() {
+ // Function([List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1703 is F1703);
+ Expect.isTrue(confuse(f1703) is F1703);
+ // In checked mode, verifies the type.
+ Function([List<T> x]) Function<B extends core.int>(int x) l1703;
+ // The static function f1703 sets `T` to `int`.
+ if (!tIsBool) {
+ x1703 = f1703 as dynamic;
+ l1703 = f1703 as dynamic;
+ x1703 = confuse(f1703);
+ l1703 = confuse(f1703);
+ }
+
+ Expect.isTrue(m1703 is F1703);
+ Expect.isTrue(m1703 is Function([List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1703) is F1703);
+ // In checked mode, verifies the type.
+ x1703 = m1703;
+ l1703 = m1703;
+ x1703 = confuse(m1703);
+ l1703 = confuse(m1703);
+ if (!tIsBool) {
+ Expect.isTrue(f1703 is F1703<int>);
+ Expect.isFalse(f1703 is F1703<bool>);
+ Expect.isTrue(confuse(f1703) is F1703<int>);
+ Expect.isFalse(confuse(f1703) is F1703<bool>);
+ Expect.equals(tIsDynamic, m1703 is F1703<bool>);
+ Expect.equals(tIsDynamic, confuse(m1703) is F1703<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1703 = (f1703 as dynamic); });
+ Expect.throws(() { x1703 = confuse(f1703); });
+ Function([List<T> x]) Function<B extends core.int>(int x) l1703;
+ Expect.throws(() { l1703 = (f1703 as dynamic); });
+ Expect.throws(() { l1703 = confuse(f1703); });
+ }
+ Function([List<T> x]) Function<B extends core.int>(int x) l1703 = m1703;
+ // In checked mode, verifies the type.
+ x1703 = m1703;
+ x1703 = confuse(m1703);
+ }
+ }
+
+ void testF1803() {
+ // Function Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1803 is F1803);
+ Expect.isTrue(confuse(f1803) is F1803);
+ // In checked mode, verifies the type.
+ Function Function<A>(A x) Function<B extends core.int>(int x) l1803;
+ // The static function f1803 sets `T` to `int`.
+ if (!tIsBool) {
+ x1803 = f1803 as dynamic;
+ l1803 = f1803 as dynamic;
+ x1803 = confuse(f1803);
+ l1803 = confuse(f1803);
+ }
+
+ Expect.isTrue(m1803 is F1803);
+ Expect.isTrue(m1803 is Function Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1803) is F1803);
+ // In checked mode, verifies the type.
+ x1803 = m1803;
+ l1803 = m1803;
+ x1803 = confuse(m1803);
+ l1803 = confuse(m1803);
+
+ }
+
+ void testF1903() {
+ // List<T> Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1903 is F1903);
+ Expect.isTrue(confuse(f1903) is F1903);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<A> x) Function<B extends core.int>(int x) l1903;
+ // The static function f1903 sets `T` to `int`.
+ if (!tIsBool) {
+ x1903 = f1903 as dynamic;
+ l1903 = f1903 as dynamic;
+ x1903 = confuse(f1903);
+ l1903 = confuse(f1903);
+ }
+
+ Expect.isTrue(m1903 is F1903);
+ Expect.isTrue(m1903 is List<T> Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1903) is F1903);
+ // In checked mode, verifies the type.
+ x1903 = m1903;
+ l1903 = m1903;
+ x1903 = confuse(m1903);
+ l1903 = confuse(m1903);
+ if (!tIsBool) {
+ Expect.isTrue(f1903 is F1903<int>);
+ Expect.isFalse(f1903 is F1903<bool>);
+ Expect.isTrue(confuse(f1903) is F1903<int>);
+ Expect.isFalse(confuse(f1903) is F1903<bool>);
+ Expect.equals(tIsDynamic, m1903 is F1903<bool>);
+ Expect.equals(tIsDynamic, confuse(m1903) is F1903<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1903 = (f1903 as dynamic); });
+ Expect.throws(() { x1903 = confuse(f1903); });
+ List<T> Function<A>(List<A> x) Function<B extends core.int>(int x) l1903;
+ Expect.throws(() { l1903 = (f1903 as dynamic); });
+ Expect.throws(() { l1903 = confuse(f1903); });
+ }
+ List<T> Function<A>(List<A> x) Function<B extends core.int>(int x) l1903 = m1903;
+ // In checked mode, verifies the type.
+ x1903 = m1903;
+ x1903 = confuse(m1903);
+ }
+ }
+
+ void testF2003() {
+ // Function Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2003 is F2003);
+ Expect.isTrue(confuse(f2003) is F2003);
+ // In checked mode, verifies the type.
+ Function Function(B x) Function<B extends core.int>(int x) l2003;
+ // The static function f2003 sets `T` to `int`.
+ if (!tIsBool) {
+ x2003 = f2003 as dynamic;
+ l2003 = f2003 as dynamic;
+ x2003 = confuse(f2003);
+ l2003 = confuse(f2003);
+ }
+
+ Expect.isTrue(m2003 is F2003);
+ Expect.isTrue(m2003 is Function Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2003) is F2003);
+ // In checked mode, verifies the type.
+ x2003 = m2003;
+ l2003 = m2003;
+ x2003 = confuse(m2003);
+ l2003 = confuse(m2003);
+
+ }
+
+
+}
+
+class C4<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0) x4;
+ Function Function(List<T> x0) x104;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) x204;
+ Function(int x0, [List<Function> x]) x304;
+ int Function([int x]) Function() x404;
+ int Function(List<Function> x0) Function() x504;
+ int Function(int x, [List<T> x2]) Function() x604;
+ Function Function(int x0, {Function x}) Function() x704;
+ Function Function([List<T> x]) Function() x804;
+ List<Function> Function(int y, [Function x]) Function() x904;
+ List<Function> Function(int x1, [core.List<core.int> x2]) Function() x1004;
+ core.List<core.int> Function({int x}) Function() x1104;
+ core.List<core.int> Function(core.List<core.int> x) Function() x1204;
+ List<T> Function(int x0, [int x]) Function() x1304;
+ List<T> Function([List<Function> x1]) Function() x1404;
+ List<T> Function({List<T> x}) Function() x1504;
+ Function(int y, {Function x}) Function() x1604;
+ Function(int x0, [List<T> x]) Function() x1704;
+ Function Function<A>(List<A> x) Function() x1804;
+ Function<A>(int x) Function() x1904;
+ List<Function> Function(B x) Function<B extends core.int>() x2004;
+
+
+ C4({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m4(int x0) => null;
+ Function m104(List<T> x0) => null;
+ core.List<core.int> m204(int y, [core.List<core.int> x]) => null;
+ m304(int x0, [List<Function> x]) => null;
+ int Function([int x]) m404() => null;
+ int Function(List<Function> x0) m504() => null;
+ int Function(int x, [List<T> x0]) m604() => null;
+ Function Function(int x0, {Function x}) m704() => null;
+ Function Function([List<T> x]) m804() => null;
+ List<Function> Function(int y, [Function x]) m904() => null;
+ List<Function> Function(int x0, [core.List<core.int> x1]) m1004() => null;
+ core.List<core.int> Function({int x}) m1104() => null;
+ core.List<core.int> Function(core.List<core.int> x) m1204() => null;
+ List<T> Function(int x0, [int x]) m1304() => null;
+ List<T> Function([List<Function> x0]) m1404() => null;
+ List<T> Function({List<T> x}) m1504() => null;
+ Function(int y, {Function x}) m1604() => null;
+ Function(int x0, [List<T> x]) m1704() => null;
+ Function Function<A>(List<A> x) m1804() => null;
+ Function<A>(int x) m1904() => null;
+ List<Function> Function(B x) m2004<B extends core.int>() => null;
+
+
+ runTests() {
+ testF4();
+ testF104();
+ testF204();
+ testF304();
+ testF404();
+ testF504();
+ testF604();
+ testF704();
+ testF804();
+ testF904();
+ testF1004();
+ testF1104();
+ testF1204();
+ testF1304();
+ testF1404();
+ testF1504();
+ testF1604();
+ testF1704();
+ testF1804();
+ testF1904();
+ testF2004();
+ }
+
+ void testF4() {
+ // int Function(int x0)
+ Expect.isTrue(f4 is F4);
+ Expect.isTrue(confuse(f4) is F4);
+ // In checked mode, verifies the type.
+ int Function(int x0) l4;
+ // The static function f4 sets `T` to `int`.
+ if (!tIsBool) {
+ 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 x0));
+ Expect.isTrue(confuse(m4) is F4);
+ // In checked mode, verifies the type.
+ x4 = m4;
+ l4 = m4;
+ x4 = confuse(m4);
+ l4 = confuse(m4);
+
+ }
+
+ void testF104() {
+ // Function Function(List<T> x0)
+ Expect.isTrue(f104 is F104);
+ Expect.isTrue(confuse(f104) is F104);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x0) l104;
+ // The static function f104 sets `T` to `int`.
+ if (!tIsBool) {
+ x104 = f104 as dynamic;
+ l104 = f104 as dynamic;
+ x104 = confuse(f104);
+ l104 = confuse(f104);
+ }
+
+ Expect.isTrue(m104 is F104);
+ Expect.isTrue(m104 is Function Function(List<T> x0));
+ Expect.isTrue(confuse(m104) is F104);
+ // In checked mode, verifies the type.
+ x104 = m104;
+ l104 = m104;
+ x104 = confuse(m104);
+ l104 = confuse(m104);
+ if (!tIsBool) {
+ Expect.isTrue(f104 is F104<int>);
+ Expect.isFalse(f104 is F104<bool>);
+ Expect.isTrue(confuse(f104) is F104<int>);
+ Expect.isFalse(confuse(f104) is F104<bool>);
+ Expect.equals(tIsDynamic, m104 is F104<bool>);
+ Expect.equals(tIsDynamic, confuse(m104) is F104<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x104 = (f104 as dynamic); });
+ Expect.throws(() { x104 = confuse(f104); });
+ Function Function(List<T> x0) l104;
+ Expect.throws(() { l104 = (f104 as dynamic); });
+ Expect.throws(() { l104 = confuse(f104); });
+ }
+ Function Function(List<T> x0) l104 = m104;
+ // In checked mode, verifies the type.
+ x104 = m104;
+ x104 = confuse(m104);
+ }
+ }
+
+ void testF204() {
+ // core.List<core.int> Function(int y, [core.List<core.int> x])
+ Expect.isTrue(f204 is F204);
+ Expect.isTrue(confuse(f204) is F204);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [core.List<core.int> x]) l204;
+ // The static function f204 sets `T` to `int`.
+ if (!tIsBool) {
+ x204 = f204 as dynamic;
+ l204 = f204 as dynamic;
+ x204 = confuse(f204);
+ l204 = confuse(f204);
+ }
+
+ Expect.isTrue(m204 is F204);
+ Expect.isTrue(m204 is core.List<core.int> Function(int y, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m204) is F204);
+ // In checked mode, verifies the type.
+ x204 = m204;
+ l204 = m204;
+ x204 = confuse(m204);
+ l204 = confuse(m204);
+
+ }
+
+ void testF304() {
+ // Function(int x0, [List<Function> x])
+ Expect.isTrue(f304 is F304);
+ Expect.isTrue(confuse(f304) is F304);
+ // In checked mode, verifies the type.
+ Function(int x0, [List<Function> x]) l304;
+ // The static function f304 sets `T` to `int`.
+ if (!tIsBool) {
+ x304 = f304 as dynamic;
+ l304 = f304 as dynamic;
+ x304 = confuse(f304);
+ l304 = confuse(f304);
+ }
+
+ Expect.isTrue(m304 is F304);
+ Expect.isTrue(m304 is Function(int x0, [List<Function> x]));
+ Expect.isTrue(confuse(m304) is F304);
+ // In checked mode, verifies the type.
+ x304 = m304;
+ l304 = m304;
+ x304 = confuse(m304);
+ l304 = confuse(m304);
+
+ }
+
+ void testF404() {
+ // int Function([int x]) Function()
+ Expect.isTrue(f404 is F404);
+ Expect.isTrue(confuse(f404) is F404);
+ // In checked mode, verifies the type.
+ int Function([int x]) Function() l404;
+ // The static function f404 sets `T` to `int`.
+ if (!tIsBool) {
+ x404 = f404 as dynamic;
+ l404 = f404 as dynamic;
+ x404 = confuse(f404);
+ l404 = confuse(f404);
+ }
+
+ Expect.isTrue(m404 is F404);
+ Expect.isTrue(m404 is int Function([int x]) Function());
+ Expect.isTrue(confuse(m404) is F404);
+ // In checked mode, verifies the type.
+ x404 = m404;
+ l404 = m404;
+ x404 = confuse(m404);
+ l404 = confuse(m404);
+
+ }
+
+ void testF504() {
+ // int Function(List<Function> x0) Function()
+ Expect.isTrue(f504 is F504);
+ Expect.isTrue(confuse(f504) is F504);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x0) Function() l504;
+ // The static function f504 sets `T` to `int`.
+ if (!tIsBool) {
+ x504 = f504 as dynamic;
+ l504 = f504 as dynamic;
+ x504 = confuse(f504);
+ l504 = confuse(f504);
+ }
+
+ Expect.isTrue(m504 is F504);
+ Expect.isTrue(m504 is int Function(List<Function> x0) Function());
+ Expect.isTrue(confuse(m504) is F504);
+ // In checked mode, verifies the type.
+ x504 = m504;
+ l504 = m504;
+ x504 = confuse(m504);
+ l504 = confuse(m504);
+
+ }
+
+ void testF604() {
+ // int Function(int x, [List<T> x2]) Function()
+ Expect.isTrue(f604 is F604);
+ Expect.isTrue(confuse(f604) is F604);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<T> x2]) Function() l604;
+ // The static function f604 sets `T` to `int`.
+ if (!tIsBool) {
+ x604 = f604 as dynamic;
+ l604 = f604 as dynamic;
+ x604 = confuse(f604);
+ l604 = confuse(f604);
+ }
+
+ Expect.isTrue(m604 is F604);
+ Expect.isTrue(m604 is int Function(int x, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m604) is F604);
+ // In checked mode, verifies the type.
+ x604 = m604;
+ l604 = m604;
+ x604 = confuse(m604);
+ l604 = confuse(m604);
+ if (!tIsBool) {
+ Expect.isTrue(f604 is F604<int>);
+ Expect.isFalse(f604 is F604<bool>);
+ Expect.isTrue(confuse(f604) is F604<int>);
+ Expect.isFalse(confuse(f604) is F604<bool>);
+ Expect.equals(tIsDynamic, m604 is F604<bool>);
+ Expect.equals(tIsDynamic, confuse(m604) is F604<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x604 = (f604 as dynamic); });
+ Expect.throws(() { x604 = confuse(f604); });
+ int Function(int x, [List<T> x2]) Function() l604;
+ Expect.throws(() { l604 = (f604 as dynamic); });
+ Expect.throws(() { l604 = confuse(f604); });
+ }
+ int Function(int x, [List<T> x2]) Function() l604 = m604;
+ // In checked mode, verifies the type.
+ x604 = m604;
+ x604 = confuse(m604);
+ }
+ }
+
+ void testF704() {
+ // Function Function(int x0, {Function x}) Function()
+ Expect.isTrue(f704 is F704);
+ Expect.isTrue(confuse(f704) is F704);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {Function x}) Function() l704;
+ // The static function f704 sets `T` to `int`.
+ if (!tIsBool) {
+ x704 = f704 as dynamic;
+ l704 = f704 as dynamic;
+ x704 = confuse(f704);
+ l704 = confuse(f704);
+ }
+
+ Expect.isTrue(m704 is F704);
+ Expect.isTrue(m704 is Function Function(int x0, {Function x}) Function());
+ Expect.isTrue(confuse(m704) is F704);
+ // In checked mode, verifies the type.
+ x704 = m704;
+ l704 = m704;
+ x704 = confuse(m704);
+ l704 = confuse(m704);
+
+ }
+
+ void testF804() {
+ // Function Function([List<T> x]) Function()
+ Expect.isTrue(f804 is F804);
+ Expect.isTrue(confuse(f804) is F804);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x]) Function() l804;
+ // The static function f804 sets `T` to `int`.
+ if (!tIsBool) {
+ x804 = f804 as dynamic;
+ l804 = f804 as dynamic;
+ x804 = confuse(f804);
+ l804 = confuse(f804);
+ }
+
+ Expect.isTrue(m804 is F804);
+ Expect.isTrue(m804 is Function Function([List<T> x]) Function());
+ Expect.isTrue(confuse(m804) is F804);
+ // In checked mode, verifies the type.
+ x804 = m804;
+ l804 = m804;
+ x804 = confuse(m804);
+ l804 = confuse(m804);
+ if (!tIsBool) {
+ Expect.isTrue(f804 is F804<int>);
+ Expect.isFalse(f804 is F804<bool>);
+ Expect.isTrue(confuse(f804) is F804<int>);
+ Expect.isFalse(confuse(f804) is F804<bool>);
+ Expect.equals(tIsDynamic, m804 is F804<bool>);
+ Expect.equals(tIsDynamic, confuse(m804) is F804<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x804 = (f804 as dynamic); });
+ Expect.throws(() { x804 = confuse(f804); });
+ Function Function([List<T> x]) Function() l804;
+ Expect.throws(() { l804 = (f804 as dynamic); });
+ Expect.throws(() { l804 = confuse(f804); });
+ }
+ Function Function([List<T> x]) Function() l804 = m804;
+ // In checked mode, verifies the type.
+ x804 = m804;
+ x804 = confuse(m804);
+ }
+ }
+
+ void testF904() {
+ // List<Function> Function(int y, [Function x]) Function()
+ Expect.isTrue(f904 is F904);
+ Expect.isTrue(confuse(f904) is F904);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [Function x]) Function() l904;
+ // The static function f904 sets `T` to `int`.
+ if (!tIsBool) {
+ x904 = f904 as dynamic;
+ l904 = f904 as dynamic;
+ x904 = confuse(f904);
+ l904 = confuse(f904);
+ }
+
+ Expect.isTrue(m904 is F904);
+ Expect.isTrue(m904 is List<Function> Function(int y, [Function x]) Function());
+ Expect.isTrue(confuse(m904) is F904);
+ // In checked mode, verifies the type.
+ x904 = m904;
+ l904 = m904;
+ x904 = confuse(m904);
+ l904 = confuse(m904);
+
+ }
+
+ void testF1004() {
+ // List<Function> Function(int x1, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1004 is F1004);
+ Expect.isTrue(confuse(f1004) is F1004);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [core.List<core.int> x2]) Function() l1004;
+ // The static function f1004 sets `T` to `int`.
+ if (!tIsBool) {
+ x1004 = f1004 as dynamic;
+ l1004 = f1004 as dynamic;
+ x1004 = confuse(f1004);
+ l1004 = confuse(f1004);
+ }
+
+ Expect.isTrue(m1004 is F1004);
+ Expect.isTrue(m1004 is List<Function> Function(int x1, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1004) is F1004);
+ // In checked mode, verifies the type.
+ x1004 = m1004;
+ l1004 = m1004;
+ x1004 = confuse(m1004);
+ l1004 = confuse(m1004);
+
+ }
+
+ void testF1104() {
+ // core.List<core.int> Function({int x}) Function()
+ Expect.isTrue(f1104 is F1104);
+ Expect.isTrue(confuse(f1104) is F1104);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({int x}) Function() l1104;
+ // The static function f1104 sets `T` to `int`.
+ if (!tIsBool) {
+ x1104 = f1104 as dynamic;
+ l1104 = f1104 as dynamic;
+ x1104 = confuse(f1104);
+ l1104 = confuse(f1104);
+ }
+
+ Expect.isTrue(m1104 is F1104);
+ Expect.isTrue(m1104 is core.List<core.int> Function({int x}) Function());
+ Expect.isTrue(confuse(m1104) is F1104);
+ // In checked mode, verifies the type.
+ x1104 = m1104;
+ l1104 = m1104;
+ x1104 = confuse(m1104);
+ l1104 = confuse(m1104);
+
+ }
+
+ void testF1204() {
+ // core.List<core.int> Function(core.List<core.int> x) Function()
+ Expect.isTrue(f1204 is F1204);
+ Expect.isTrue(confuse(f1204) is F1204);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x) Function() l1204;
+ // The static function f1204 sets `T` to `int`.
+ if (!tIsBool) {
+ x1204 = f1204 as dynamic;
+ l1204 = f1204 as dynamic;
+ x1204 = confuse(f1204);
+ l1204 = confuse(f1204);
+ }
+
+ Expect.isTrue(m1204 is F1204);
+ Expect.isTrue(m1204 is core.List<core.int> Function(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1204) is F1204);
+ // In checked mode, verifies the type.
+ x1204 = m1204;
+ l1204 = m1204;
+ x1204 = confuse(m1204);
+ l1204 = confuse(m1204);
+
+ }
+
+ void testF1304() {
+ // List<T> Function(int x0, [int x]) Function()
+ Expect.isTrue(f1304 is F1304);
+ Expect.isTrue(confuse(f1304) is F1304);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [int x]) Function() l1304;
+ // The static function f1304 sets `T` to `int`.
+ if (!tIsBool) {
+ x1304 = f1304 as dynamic;
+ l1304 = f1304 as dynamic;
+ x1304 = confuse(f1304);
+ l1304 = confuse(f1304);
+ }
+
+ Expect.isTrue(m1304 is F1304);
+ Expect.isTrue(m1304 is List<T> Function(int x0, [int x]) Function());
+ Expect.isTrue(confuse(m1304) is F1304);
+ // In checked mode, verifies the type.
+ x1304 = m1304;
+ l1304 = m1304;
+ x1304 = confuse(m1304);
+ l1304 = confuse(m1304);
+ if (!tIsBool) {
+ Expect.isTrue(f1304 is F1304<int>);
+ Expect.isFalse(f1304 is F1304<bool>);
+ Expect.isTrue(confuse(f1304) is F1304<int>);
+ Expect.isFalse(confuse(f1304) is F1304<bool>);
+ Expect.equals(tIsDynamic, m1304 is F1304<bool>);
+ Expect.equals(tIsDynamic, confuse(m1304) is F1304<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1304 = (f1304 as dynamic); });
+ Expect.throws(() { x1304 = confuse(f1304); });
+ List<T> Function(int x0, [int x]) Function() l1304;
+ Expect.throws(() { l1304 = (f1304 as dynamic); });
+ Expect.throws(() { l1304 = confuse(f1304); });
+ }
+ List<T> Function(int x0, [int x]) Function() l1304 = m1304;
+ // In checked mode, verifies the type.
+ x1304 = m1304;
+ x1304 = confuse(m1304);
+ }
+ }
+
+ void testF1404() {
+ // List<T> Function([List<Function> x1]) Function()
+ Expect.isTrue(f1404 is F1404);
+ Expect.isTrue(confuse(f1404) is F1404);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x1]) Function() l1404;
+ // The static function f1404 sets `T` to `int`.
+ if (!tIsBool) {
+ x1404 = f1404 as dynamic;
+ l1404 = f1404 as dynamic;
+ x1404 = confuse(f1404);
+ l1404 = confuse(f1404);
+ }
+
+ Expect.isTrue(m1404 is F1404);
+ Expect.isTrue(m1404 is List<T> Function([List<Function> x1]) Function());
+ Expect.isTrue(confuse(m1404) is F1404);
+ // In checked mode, verifies the type.
+ x1404 = m1404;
+ l1404 = m1404;
+ x1404 = confuse(m1404);
+ l1404 = confuse(m1404);
+ if (!tIsBool) {
+ Expect.isTrue(f1404 is F1404<int>);
+ Expect.isFalse(f1404 is F1404<bool>);
+ Expect.isTrue(confuse(f1404) is F1404<int>);
+ Expect.isFalse(confuse(f1404) is F1404<bool>);
+ Expect.equals(tIsDynamic, m1404 is F1404<bool>);
+ Expect.equals(tIsDynamic, confuse(m1404) is F1404<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1404 = (f1404 as dynamic); });
+ Expect.throws(() { x1404 = confuse(f1404); });
+ List<T> Function([List<Function> x1]) Function() l1404;
+ Expect.throws(() { l1404 = (f1404 as dynamic); });
+ Expect.throws(() { l1404 = confuse(f1404); });
+ }
+ List<T> Function([List<Function> x1]) Function() l1404 = m1404;
+ // In checked mode, verifies the type.
+ x1404 = m1404;
+ x1404 = confuse(m1404);
+ }
+ }
+
+ void testF1504() {
+ // List<T> Function({List<T> x}) Function()
+ Expect.isTrue(f1504 is F1504);
+ Expect.isTrue(confuse(f1504) is F1504);
+ // In checked mode, verifies the type.
+ List<T> Function({List<T> x}) Function() l1504;
+ // The static function f1504 sets `T` to `int`.
+ if (!tIsBool) {
+ x1504 = f1504 as dynamic;
+ l1504 = f1504 as dynamic;
+ x1504 = confuse(f1504);
+ l1504 = confuse(f1504);
+ }
+
+ Expect.isTrue(m1504 is F1504);
+ Expect.isTrue(m1504 is List<T> Function({List<T> x}) Function());
+ Expect.isTrue(confuse(m1504) is F1504);
+ // In checked mode, verifies the type.
+ x1504 = m1504;
+ l1504 = m1504;
+ x1504 = confuse(m1504);
+ l1504 = confuse(m1504);
+ if (!tIsBool) {
+ Expect.isTrue(f1504 is F1504<int>);
+ Expect.isFalse(f1504 is F1504<bool>);
+ Expect.isTrue(confuse(f1504) is F1504<int>);
+ Expect.isFalse(confuse(f1504) is F1504<bool>);
+ Expect.equals(tIsDynamic, m1504 is F1504<bool>);
+ Expect.equals(tIsDynamic, confuse(m1504) is F1504<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1504 = (f1504 as dynamic); });
+ Expect.throws(() { x1504 = confuse(f1504); });
+ List<T> Function({List<T> x}) Function() l1504;
+ Expect.throws(() { l1504 = (f1504 as dynamic); });
+ Expect.throws(() { l1504 = confuse(f1504); });
+ }
+ List<T> Function({List<T> x}) Function() l1504 = m1504;
+ // In checked mode, verifies the type.
+ x1504 = m1504;
+ x1504 = confuse(m1504);
+ }
+ }
+
+ void testF1604() {
+ // Function(int y, {Function x}) Function()
+ Expect.isTrue(f1604 is F1604);
+ Expect.isTrue(confuse(f1604) is F1604);
+ // In checked mode, verifies the type.
+ Function(int y, {Function x}) Function() l1604;
+ // The static function f1604 sets `T` to `int`.
+ if (!tIsBool) {
+ x1604 = f1604 as dynamic;
+ l1604 = f1604 as dynamic;
+ x1604 = confuse(f1604);
+ l1604 = confuse(f1604);
+ }
+
+ Expect.isTrue(m1604 is F1604);
+ Expect.isTrue(m1604 is Function(int y, {Function x}) Function());
+ Expect.isTrue(confuse(m1604) is F1604);
+ // In checked mode, verifies the type.
+ x1604 = m1604;
+ l1604 = m1604;
+ x1604 = confuse(m1604);
+ l1604 = confuse(m1604);
+
+ }
+
+ void testF1704() {
+ // Function(int x0, [List<T> x]) Function()
+ Expect.isTrue(f1704 is F1704);
+ Expect.isTrue(confuse(f1704) is F1704);
+ // In checked mode, verifies the type.
+ Function(int x0, [List<T> x]) Function() l1704;
+ // The static function f1704 sets `T` to `int`.
+ if (!tIsBool) {
+ x1704 = f1704 as dynamic;
+ l1704 = f1704 as dynamic;
+ x1704 = confuse(f1704);
+ l1704 = confuse(f1704);
+ }
+
+ Expect.isTrue(m1704 is F1704);
+ Expect.isTrue(m1704 is Function(int x0, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1704) is F1704);
+ // In checked mode, verifies the type.
+ x1704 = m1704;
+ l1704 = m1704;
+ x1704 = confuse(m1704);
+ l1704 = confuse(m1704);
+ if (!tIsBool) {
+ Expect.isTrue(f1704 is F1704<int>);
+ Expect.isFalse(f1704 is F1704<bool>);
+ Expect.isTrue(confuse(f1704) is F1704<int>);
+ Expect.isFalse(confuse(f1704) is F1704<bool>);
+ Expect.equals(tIsDynamic, m1704 is F1704<bool>);
+ Expect.equals(tIsDynamic, confuse(m1704) is F1704<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1704 = (f1704 as dynamic); });
+ Expect.throws(() { x1704 = confuse(f1704); });
+ Function(int x0, [List<T> x]) Function() l1704;
+ Expect.throws(() { l1704 = (f1704 as dynamic); });
+ Expect.throws(() { l1704 = confuse(f1704); });
+ }
+ Function(int x0, [List<T> x]) Function() l1704 = m1704;
+ // In checked mode, verifies the type.
+ x1704 = m1704;
+ x1704 = confuse(m1704);
+ }
+ }
+
+ void testF1804() {
+ // Function Function<A>(List<A> x) Function()
+ Expect.isTrue(f1804 is F1804);
+ Expect.isTrue(confuse(f1804) is F1804);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<A> x) Function() l1804;
+ // The static function f1804 sets `T` to `int`.
+ if (!tIsBool) {
+ x1804 = f1804 as dynamic;
+ l1804 = f1804 as dynamic;
+ x1804 = confuse(f1804);
+ l1804 = confuse(f1804);
+ }
+
+ Expect.isTrue(m1804 is F1804);
+ Expect.isTrue(m1804 is Function Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1804) is F1804);
+ // In checked mode, verifies the type.
+ x1804 = m1804;
+ l1804 = m1804;
+ x1804 = confuse(m1804);
+ l1804 = confuse(m1804);
+
+ }
+
+ void testF1904() {
+ // Function<A>(int x) Function()
+ Expect.isTrue(f1904 is F1904);
+ Expect.isTrue(confuse(f1904) is F1904);
+ // In checked mode, verifies the type.
+ Function<A>(int x) Function() l1904;
+ // The static function f1904 sets `T` to `int`.
+ if (!tIsBool) {
+ x1904 = f1904 as dynamic;
+ l1904 = f1904 as dynamic;
+ x1904 = confuse(f1904);
+ l1904 = confuse(f1904);
+ }
+
+ Expect.isTrue(m1904 is F1904);
+ Expect.isTrue(m1904 is Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1904) is F1904);
+ // In checked mode, verifies the type.
+ x1904 = m1904;
+ l1904 = m1904;
+ x1904 = confuse(m1904);
+ l1904 = confuse(m1904);
+
+ }
+
+ void testF2004() {
+ // List<Function> Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2004 is F2004);
+ Expect.isTrue(confuse(f2004) is F2004);
+ // In checked mode, verifies the type.
+ List<Function> Function(B x) Function<B extends core.int>() l2004;
+ // The static function f2004 sets `T` to `int`.
+ if (!tIsBool) {
+ x2004 = f2004 as dynamic;
+ l2004 = f2004 as dynamic;
+ x2004 = confuse(f2004);
+ l2004 = confuse(f2004);
+ }
+
+ Expect.isTrue(m2004 is F2004);
+ Expect.isTrue(m2004 is List<Function> Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2004) is F2004);
+ // In checked mode, verifies the type.
+ x2004 = m2004;
+ l2004 = m2004;
+ x2004 = confuse(m2004);
+ l2004 = confuse(m2004);
+
+ }
+
+
+}
+
+class C5<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([int x1]) x5;
+ Function Function([List<T> x1]) x105;
+ core.List<core.int> Function(core.List<core.int> x0) x205;
+ Function(int y, [List<Function> x]) x305;
+ int Function([int x]) Function(int x) x405;
+ int Function(List<Function> x1) Function(int x) x505;
+ int Function(int x, [List<T> x1]) Function(int x) x605;
+ Function Function(int x1, {Function x}) Function(int x) x705;
+ Function Function([List<T> x]) Function(int x) x805;
+ List<Function> Function(int y, [Function x]) Function(int x) x905;
+ List<Function> Function(int x2, [core.List<core.int> x3]) Function(int x) x1005;
+ core.List<core.int> Function({int x}) Function(int x) x1105;
+ core.List<core.int> Function(core.List<core.int> x) Function(int x) x1205;
+ List<T> Function(int x1, [int x]) Function(int x) x1305;
+ List<T> Function([List<Function> x1]) Function(int x) x1405;
+ List<T> Function({List<T> x}) Function(int x) x1505;
+ Function(int y, {Function x}) Function(int x) x1605;
+ Function(int x1, [List<T> x]) Function(int x) x1705;
+ Function Function<A>(List<A> x) Function(int x) x1805;
+ Function<A>(int x) Function(int x) x1905;
+ List<Function> Function(B x) Function<B extends core.int>(int x) x2005;
+
+
+ C5({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m5([int x0]) => null;
+ Function m105([List<T> x0]) => null;
+ core.List<core.int> m205(core.List<core.int> x0) => null;
+ m305(int y, [List<Function> x]) => null;
+ int Function([int x]) m405(int x) => null;
+ int Function(List<Function> x0) m505(int x) => null;
+ int Function(int x, [List<T> x0]) m605(int x) => null;
+ Function Function(int x0, {Function x}) m705(int x) => null;
+ Function Function([List<T> x]) m805(int x) => null;
+ List<Function> Function(int y, [Function x]) m905(int x) => null;
+ List<Function> Function(int x0, [core.List<core.int> x1]) m1005(int x) => null;
+ core.List<core.int> Function({int x}) m1105(int x) => null;
+ core.List<core.int> Function(core.List<core.int> x) m1205(int x) => null;
+ List<T> Function(int x0, [int x]) m1305(int x) => null;
+ List<T> Function([List<Function> x0]) m1405(int x) => null;
+ List<T> Function({List<T> x}) m1505(int x) => null;
+ Function(int y, {Function x}) m1605(int x) => null;
+ Function(int x0, [List<T> x]) m1705(int x) => null;
+ Function Function<A>(List<A> x) m1805(int x) => null;
+ Function<A>(int x) m1905(int x) => null;
+ List<Function> Function(B x) m2005<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF5();
+ testF105();
+ testF205();
+ testF305();
+ testF405();
+ testF505();
+ testF605();
+ testF705();
+ testF805();
+ testF905();
+ testF1005();
+ testF1105();
+ testF1205();
+ testF1305();
+ testF1405();
+ testF1505();
+ testF1605();
+ testF1705();
+ testF1805();
+ testF1905();
+ testF2005();
+ }
+
+ void testF5() {
+ // int Function([int x1])
+ Expect.isTrue(f5 is F5);
+ Expect.isTrue(confuse(f5) is F5);
+ // In checked mode, verifies the type.
+ int Function([int x1]) l5;
+ // The static function f5 sets `T` to `int`.
+ if (!tIsBool) {
+ 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]));
+ Expect.isTrue(confuse(m5) is F5);
+ // In checked mode, verifies the type.
+ x5 = m5;
+ l5 = m5;
+ x5 = confuse(m5);
+ l5 = confuse(m5);
+
+ }
+
+ void testF105() {
+ // Function Function([List<T> x1])
+ Expect.isTrue(f105 is F105);
+ Expect.isTrue(confuse(f105) is F105);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x1]) l105;
+ // The static function f105 sets `T` to `int`.
+ if (!tIsBool) {
+ x105 = f105 as dynamic;
+ l105 = f105 as dynamic;
+ x105 = confuse(f105);
+ l105 = confuse(f105);
+ }
+
+ Expect.isTrue(m105 is F105);
+ Expect.isTrue(m105 is Function Function([List<T> x1]));
+ Expect.isTrue(confuse(m105) is F105);
+ // In checked mode, verifies the type.
+ x105 = m105;
+ l105 = m105;
+ x105 = confuse(m105);
+ l105 = confuse(m105);
+ if (!tIsBool) {
+ Expect.isTrue(f105 is F105<int>);
+ Expect.isFalse(f105 is F105<bool>);
+ Expect.isTrue(confuse(f105) is F105<int>);
+ Expect.isFalse(confuse(f105) is F105<bool>);
+ Expect.equals(tIsDynamic, m105 is F105<bool>);
+ Expect.equals(tIsDynamic, confuse(m105) is F105<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x105 = (f105 as dynamic); });
+ Expect.throws(() { x105 = confuse(f105); });
+ Function Function([List<T> x1]) l105;
+ Expect.throws(() { l105 = (f105 as dynamic); });
+ Expect.throws(() { l105 = confuse(f105); });
+ }
+ Function Function([List<T> x1]) l105 = m105;
+ // In checked mode, verifies the type.
+ x105 = m105;
+ x105 = confuse(m105);
+ }
+ }
+
+ void testF205() {
+ // core.List<core.int> Function(core.List<core.int> x0)
+ Expect.isTrue(f205 is F205);
+ Expect.isTrue(confuse(f205) is F205);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x0) l205;
+ // The static function f205 sets `T` to `int`.
+ if (!tIsBool) {
+ x205 = f205 as dynamic;
+ l205 = f205 as dynamic;
+ x205 = confuse(f205);
+ l205 = confuse(f205);
+ }
+
+ Expect.isTrue(m205 is F205);
+ Expect.isTrue(m205 is core.List<core.int> Function(core.List<core.int> x0));
+ Expect.isTrue(confuse(m205) is F205);
+ // In checked mode, verifies the type.
+ x205 = m205;
+ l205 = m205;
+ x205 = confuse(m205);
+ l205 = confuse(m205);
+
+ }
+
+ void testF305() {
+ // Function(int y, [List<Function> x])
+ Expect.isTrue(f305 is F305);
+ Expect.isTrue(confuse(f305) is F305);
+ // In checked mode, verifies the type.
+ Function(int y, [List<Function> x]) l305;
+ // The static function f305 sets `T` to `int`.
+ if (!tIsBool) {
+ x305 = f305 as dynamic;
+ l305 = f305 as dynamic;
+ x305 = confuse(f305);
+ l305 = confuse(f305);
+ }
+
+ Expect.isTrue(m305 is F305);
+ Expect.isTrue(m305 is Function(int y, [List<Function> x]));
+ Expect.isTrue(confuse(m305) is F305);
+ // In checked mode, verifies the type.
+ x305 = m305;
+ l305 = m305;
+ x305 = confuse(m305);
+ l305 = confuse(m305);
+
+ }
+
+ void testF405() {
+ // int Function([int x]) Function(int x)
+ Expect.isTrue(f405 is F405);
+ Expect.isTrue(confuse(f405) is F405);
+ // In checked mode, verifies the type.
+ int Function([int x]) Function(int x) l405;
+ // The static function f405 sets `T` to `int`.
+ if (!tIsBool) {
+ x405 = f405 as dynamic;
+ l405 = f405 as dynamic;
+ x405 = confuse(f405);
+ l405 = confuse(f405);
+ }
+
+ Expect.isTrue(m405 is F405);
+ Expect.isTrue(m405 is int Function([int x]) Function(int x));
+ Expect.isTrue(confuse(m405) is F405);
+ // In checked mode, verifies the type.
+ x405 = m405;
+ l405 = m405;
+ x405 = confuse(m405);
+ l405 = confuse(m405);
+
+ }
+
+ void testF505() {
+ // int Function(List<Function> x1) Function(int x)
+ Expect.isTrue(f505 is F505);
+ Expect.isTrue(confuse(f505) is F505);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x1) Function(int x) l505;
+ // The static function f505 sets `T` to `int`.
+ if (!tIsBool) {
+ x505 = f505 as dynamic;
+ l505 = f505 as dynamic;
+ x505 = confuse(f505);
+ l505 = confuse(f505);
+ }
+
+ Expect.isTrue(m505 is F505);
+ Expect.isTrue(m505 is int Function(List<Function> x1) Function(int x));
+ Expect.isTrue(confuse(m505) is F505);
+ // In checked mode, verifies the type.
+ x505 = m505;
+ l505 = m505;
+ x505 = confuse(m505);
+ l505 = confuse(m505);
+
+ }
+
+ void testF605() {
+ // int Function(int x, [List<T> x1]) Function(int x)
+ Expect.isTrue(f605 is F605);
+ Expect.isTrue(confuse(f605) is F605);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<T> x1]) Function(int x) l605;
+ // The static function f605 sets `T` to `int`.
+ if (!tIsBool) {
+ x605 = f605 as dynamic;
+ l605 = f605 as dynamic;
+ x605 = confuse(f605);
+ l605 = confuse(f605);
+ }
+
+ Expect.isTrue(m605 is F605);
+ Expect.isTrue(m605 is int Function(int x, [List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m605) is F605);
+ // In checked mode, verifies the type.
+ x605 = m605;
+ l605 = m605;
+ x605 = confuse(m605);
+ l605 = confuse(m605);
+ if (!tIsBool) {
+ Expect.isTrue(f605 is F605<int>);
+ Expect.isFalse(f605 is F605<bool>);
+ Expect.isTrue(confuse(f605) is F605<int>);
+ Expect.isFalse(confuse(f605) is F605<bool>);
+ Expect.equals(tIsDynamic, m605 is F605<bool>);
+ Expect.equals(tIsDynamic, confuse(m605) is F605<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x605 = (f605 as dynamic); });
+ Expect.throws(() { x605 = confuse(f605); });
+ int Function(int x, [List<T> x1]) Function(int x) l605;
+ Expect.throws(() { l605 = (f605 as dynamic); });
+ Expect.throws(() { l605 = confuse(f605); });
+ }
+ int Function(int x, [List<T> x1]) Function(int x) l605 = m605;
+ // In checked mode, verifies the type.
+ x605 = m605;
+ x605 = confuse(m605);
+ }
+ }
+
+ void testF705() {
+ // Function Function(int x1, {Function x}) Function(int x)
+ Expect.isTrue(f705 is F705);
+ Expect.isTrue(confuse(f705) is F705);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {Function x}) Function(int x) l705;
+ // The static function f705 sets `T` to `int`.
+ if (!tIsBool) {
+ x705 = f705 as dynamic;
+ l705 = f705 as dynamic;
+ x705 = confuse(f705);
+ l705 = confuse(f705);
+ }
+
+ Expect.isTrue(m705 is F705);
+ Expect.isTrue(m705 is Function Function(int x1, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m705) is F705);
+ // In checked mode, verifies the type.
+ x705 = m705;
+ l705 = m705;
+ x705 = confuse(m705);
+ l705 = confuse(m705);
+
+ }
+
+ void testF805() {
+ // Function Function([List<T> x]) Function(int x)
+ Expect.isTrue(f805 is F805);
+ Expect.isTrue(confuse(f805) is F805);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x]) Function(int x) l805;
+ // The static function f805 sets `T` to `int`.
+ if (!tIsBool) {
+ x805 = f805 as dynamic;
+ l805 = f805 as dynamic;
+ x805 = confuse(f805);
+ l805 = confuse(f805);
+ }
+
+ Expect.isTrue(m805 is F805);
+ Expect.isTrue(m805 is Function Function([List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m805) is F805);
+ // In checked mode, verifies the type.
+ x805 = m805;
+ l805 = m805;
+ x805 = confuse(m805);
+ l805 = confuse(m805);
+ if (!tIsBool) {
+ Expect.isTrue(f805 is F805<int>);
+ Expect.isFalse(f805 is F805<bool>);
+ Expect.isTrue(confuse(f805) is F805<int>);
+ Expect.isFalse(confuse(f805) is F805<bool>);
+ Expect.equals(tIsDynamic, m805 is F805<bool>);
+ Expect.equals(tIsDynamic, confuse(m805) is F805<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x805 = (f805 as dynamic); });
+ Expect.throws(() { x805 = confuse(f805); });
+ Function Function([List<T> x]) Function(int x) l805;
+ Expect.throws(() { l805 = (f805 as dynamic); });
+ Expect.throws(() { l805 = confuse(f805); });
+ }
+ Function Function([List<T> x]) Function(int x) l805 = m805;
+ // In checked mode, verifies the type.
+ x805 = m805;
+ x805 = confuse(m805);
+ }
+ }
+
+ void testF905() {
+ // List<Function> Function(int y, [Function x]) Function(int x)
+ Expect.isTrue(f905 is F905);
+ Expect.isTrue(confuse(f905) is F905);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [Function x]) Function(int x) l905;
+ // The static function f905 sets `T` to `int`.
+ if (!tIsBool) {
+ x905 = f905 as dynamic;
+ l905 = f905 as dynamic;
+ x905 = confuse(f905);
+ l905 = confuse(f905);
+ }
+
+ Expect.isTrue(m905 is F905);
+ Expect.isTrue(m905 is List<Function> Function(int y, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m905) is F905);
+ // In checked mode, verifies the type.
+ x905 = m905;
+ l905 = m905;
+ x905 = confuse(m905);
+ l905 = confuse(m905);
+
+ }
+
+ void testF1005() {
+ // List<Function> Function(int x2, [core.List<core.int> x3]) Function(int x)
+ Expect.isTrue(f1005 is F1005);
+ Expect.isTrue(confuse(f1005) is F1005);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [core.List<core.int> x3]) Function(int x) l1005;
+ // The static function f1005 sets `T` to `int`.
+ if (!tIsBool) {
+ x1005 = f1005 as dynamic;
+ l1005 = f1005 as dynamic;
+ x1005 = confuse(f1005);
+ l1005 = confuse(f1005);
+ }
+
+ Expect.isTrue(m1005 is F1005);
+ Expect.isTrue(m1005 is List<Function> Function(int x2, [core.List<core.int> x3]) Function(int x));
+ Expect.isTrue(confuse(m1005) is F1005);
+ // In checked mode, verifies the type.
+ x1005 = m1005;
+ l1005 = m1005;
+ x1005 = confuse(m1005);
+ l1005 = confuse(m1005);
+
+ }
+
+ void testF1105() {
+ // core.List<core.int> Function({int x}) Function(int x)
+ Expect.isTrue(f1105 is F1105);
+ Expect.isTrue(confuse(f1105) is F1105);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({int x}) Function(int x) l1105;
+ // The static function f1105 sets `T` to `int`.
+ if (!tIsBool) {
+ x1105 = f1105 as dynamic;
+ l1105 = f1105 as dynamic;
+ x1105 = confuse(f1105);
+ l1105 = confuse(f1105);
+ }
+
+ Expect.isTrue(m1105 is F1105);
+ Expect.isTrue(m1105 is core.List<core.int> Function({int x}) Function(int x));
+ Expect.isTrue(confuse(m1105) is F1105);
+ // In checked mode, verifies the type.
+ x1105 = m1105;
+ l1105 = m1105;
+ x1105 = confuse(m1105);
+ l1105 = confuse(m1105);
+
+ }
+
+ void testF1205() {
+ // core.List<core.int> Function(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1205 is F1205);
+ Expect.isTrue(confuse(f1205) is F1205);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x) Function(int x) l1205;
+ // The static function f1205 sets `T` to `int`.
+ if (!tIsBool) {
+ x1205 = f1205 as dynamic;
+ l1205 = f1205 as dynamic;
+ x1205 = confuse(f1205);
+ l1205 = confuse(f1205);
+ }
+
+ Expect.isTrue(m1205 is F1205);
+ Expect.isTrue(m1205 is core.List<core.int> Function(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1205) is F1205);
+ // In checked mode, verifies the type.
+ x1205 = m1205;
+ l1205 = m1205;
+ x1205 = confuse(m1205);
+ l1205 = confuse(m1205);
+
+ }
+
+ void testF1305() {
+ // List<T> Function(int x1, [int x]) Function(int x)
+ Expect.isTrue(f1305 is F1305);
+ Expect.isTrue(confuse(f1305) is F1305);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [int x]) Function(int x) l1305;
+ // The static function f1305 sets `T` to `int`.
+ if (!tIsBool) {
+ x1305 = f1305 as dynamic;
+ l1305 = f1305 as dynamic;
+ x1305 = confuse(f1305);
+ l1305 = confuse(f1305);
+ }
+
+ Expect.isTrue(m1305 is F1305);
+ Expect.isTrue(m1305 is List<T> Function(int x1, [int x]) Function(int x));
+ Expect.isTrue(confuse(m1305) is F1305);
+ // In checked mode, verifies the type.
+ x1305 = m1305;
+ l1305 = m1305;
+ x1305 = confuse(m1305);
+ l1305 = confuse(m1305);
+ if (!tIsBool) {
+ Expect.isTrue(f1305 is F1305<int>);
+ Expect.isFalse(f1305 is F1305<bool>);
+ Expect.isTrue(confuse(f1305) is F1305<int>);
+ Expect.isFalse(confuse(f1305) is F1305<bool>);
+ Expect.equals(tIsDynamic, m1305 is F1305<bool>);
+ Expect.equals(tIsDynamic, confuse(m1305) is F1305<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1305 = (f1305 as dynamic); });
+ Expect.throws(() { x1305 = confuse(f1305); });
+ List<T> Function(int x1, [int x]) Function(int x) l1305;
+ Expect.throws(() { l1305 = (f1305 as dynamic); });
+ Expect.throws(() { l1305 = confuse(f1305); });
+ }
+ List<T> Function(int x1, [int x]) Function(int x) l1305 = m1305;
+ // In checked mode, verifies the type.
+ x1305 = m1305;
+ x1305 = confuse(m1305);
+ }
+ }
+
+ void testF1405() {
+ // List<T> Function([List<Function> x1]) Function(int x)
+ Expect.isTrue(f1405 is F1405);
+ Expect.isTrue(confuse(f1405) is F1405);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x1]) Function(int x) l1405;
+ // The static function f1405 sets `T` to `int`.
+ if (!tIsBool) {
+ x1405 = f1405 as dynamic;
+ l1405 = f1405 as dynamic;
+ x1405 = confuse(f1405);
+ l1405 = confuse(f1405);
+ }
+
+ Expect.isTrue(m1405 is F1405);
+ Expect.isTrue(m1405 is List<T> Function([List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m1405) is F1405);
+ // In checked mode, verifies the type.
+ x1405 = m1405;
+ l1405 = m1405;
+ x1405 = confuse(m1405);
+ l1405 = confuse(m1405);
+ if (!tIsBool) {
+ Expect.isTrue(f1405 is F1405<int>);
+ Expect.isFalse(f1405 is F1405<bool>);
+ Expect.isTrue(confuse(f1405) is F1405<int>);
+ Expect.isFalse(confuse(f1405) is F1405<bool>);
+ Expect.equals(tIsDynamic, m1405 is F1405<bool>);
+ Expect.equals(tIsDynamic, confuse(m1405) is F1405<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1405 = (f1405 as dynamic); });
+ Expect.throws(() { x1405 = confuse(f1405); });
+ List<T> Function([List<Function> x1]) Function(int x) l1405;
+ Expect.throws(() { l1405 = (f1405 as dynamic); });
+ Expect.throws(() { l1405 = confuse(f1405); });
+ }
+ List<T> Function([List<Function> x1]) Function(int x) l1405 = m1405;
+ // In checked mode, verifies the type.
+ x1405 = m1405;
+ x1405 = confuse(m1405);
+ }
+ }
+
+ void testF1505() {
+ // List<T> Function({List<T> x}) Function(int x)
+ Expect.isTrue(f1505 is F1505);
+ Expect.isTrue(confuse(f1505) is F1505);
+ // In checked mode, verifies the type.
+ List<T> Function({List<T> x}) Function(int x) l1505;
+ // The static function f1505 sets `T` to `int`.
+ if (!tIsBool) {
+ x1505 = f1505 as dynamic;
+ l1505 = f1505 as dynamic;
+ x1505 = confuse(f1505);
+ l1505 = confuse(f1505);
+ }
+
+ Expect.isTrue(m1505 is F1505);
+ Expect.isTrue(m1505 is List<T> Function({List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1505) is F1505);
+ // In checked mode, verifies the type.
+ x1505 = m1505;
+ l1505 = m1505;
+ x1505 = confuse(m1505);
+ l1505 = confuse(m1505);
+ if (!tIsBool) {
+ Expect.isTrue(f1505 is F1505<int>);
+ Expect.isFalse(f1505 is F1505<bool>);
+ Expect.isTrue(confuse(f1505) is F1505<int>);
+ Expect.isFalse(confuse(f1505) is F1505<bool>);
+ Expect.equals(tIsDynamic, m1505 is F1505<bool>);
+ Expect.equals(tIsDynamic, confuse(m1505) is F1505<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1505 = (f1505 as dynamic); });
+ Expect.throws(() { x1505 = confuse(f1505); });
+ List<T> Function({List<T> x}) Function(int x) l1505;
+ Expect.throws(() { l1505 = (f1505 as dynamic); });
+ Expect.throws(() { l1505 = confuse(f1505); });
+ }
+ List<T> Function({List<T> x}) Function(int x) l1505 = m1505;
+ // In checked mode, verifies the type.
+ x1505 = m1505;
+ x1505 = confuse(m1505);
+ }
+ }
+
+ void testF1605() {
+ // Function(int y, {Function x}) Function(int x)
+ Expect.isTrue(f1605 is F1605);
+ Expect.isTrue(confuse(f1605) is F1605);
+ // In checked mode, verifies the type.
+ Function(int y, {Function x}) Function(int x) l1605;
+ // The static function f1605 sets `T` to `int`.
+ if (!tIsBool) {
+ x1605 = f1605 as dynamic;
+ l1605 = f1605 as dynamic;
+ x1605 = confuse(f1605);
+ l1605 = confuse(f1605);
+ }
+
+ Expect.isTrue(m1605 is F1605);
+ Expect.isTrue(m1605 is Function(int y, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m1605) is F1605);
+ // In checked mode, verifies the type.
+ x1605 = m1605;
+ l1605 = m1605;
+ x1605 = confuse(m1605);
+ l1605 = confuse(m1605);
+
+ }
+
+ void testF1705() {
+ // Function(int x1, [List<T> x]) Function(int x)
+ Expect.isTrue(f1705 is F1705);
+ Expect.isTrue(confuse(f1705) is F1705);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<T> x]) Function(int x) l1705;
+ // The static function f1705 sets `T` to `int`.
+ if (!tIsBool) {
+ x1705 = f1705 as dynamic;
+ l1705 = f1705 as dynamic;
+ x1705 = confuse(f1705);
+ l1705 = confuse(f1705);
+ }
+
+ Expect.isTrue(m1705 is F1705);
+ Expect.isTrue(m1705 is Function(int x1, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1705) is F1705);
+ // In checked mode, verifies the type.
+ x1705 = m1705;
+ l1705 = m1705;
+ x1705 = confuse(m1705);
+ l1705 = confuse(m1705);
+ if (!tIsBool) {
+ Expect.isTrue(f1705 is F1705<int>);
+ Expect.isFalse(f1705 is F1705<bool>);
+ Expect.isTrue(confuse(f1705) is F1705<int>);
+ Expect.isFalse(confuse(f1705) is F1705<bool>);
+ Expect.equals(tIsDynamic, m1705 is F1705<bool>);
+ Expect.equals(tIsDynamic, confuse(m1705) is F1705<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1705 = (f1705 as dynamic); });
+ Expect.throws(() { x1705 = confuse(f1705); });
+ Function(int x1, [List<T> x]) Function(int x) l1705;
+ Expect.throws(() { l1705 = (f1705 as dynamic); });
+ Expect.throws(() { l1705 = confuse(f1705); });
+ }
+ Function(int x1, [List<T> x]) Function(int x) l1705 = m1705;
+ // In checked mode, verifies the type.
+ x1705 = m1705;
+ x1705 = confuse(m1705);
+ }
+ }
+
+ void testF1805() {
+ // Function Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1805 is F1805);
+ Expect.isTrue(confuse(f1805) is F1805);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<A> x) Function(int x) l1805;
+ // The static function f1805 sets `T` to `int`.
+ if (!tIsBool) {
+ x1805 = f1805 as dynamic;
+ l1805 = f1805 as dynamic;
+ x1805 = confuse(f1805);
+ l1805 = confuse(f1805);
+ }
+
+ Expect.isTrue(m1805 is F1805);
+ Expect.isTrue(m1805 is Function Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1805) is F1805);
+ // In checked mode, verifies the type.
+ x1805 = m1805;
+ l1805 = m1805;
+ x1805 = confuse(m1805);
+ l1805 = confuse(m1805);
+
+ }
+
+ void testF1905() {
+ // Function<A>(int x) Function(int x)
+ Expect.isTrue(f1905 is F1905);
+ Expect.isTrue(confuse(f1905) is F1905);
+ // In checked mode, verifies the type.
+ Function<A>(int x) Function(int x) l1905;
+ // The static function f1905 sets `T` to `int`.
+ if (!tIsBool) {
+ x1905 = f1905 as dynamic;
+ l1905 = f1905 as dynamic;
+ x1905 = confuse(f1905);
+ l1905 = confuse(f1905);
+ }
+
+ Expect.isTrue(m1905 is F1905);
+ Expect.isTrue(m1905 is Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1905) is F1905);
+ // In checked mode, verifies the type.
+ x1905 = m1905;
+ l1905 = m1905;
+ x1905 = confuse(m1905);
+ l1905 = confuse(m1905);
+
+ }
+
+ void testF2005() {
+ // List<Function> Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2005 is F2005);
+ Expect.isTrue(confuse(f2005) is F2005);
+ // In checked mode, verifies the type.
+ List<Function> Function(B x) Function<B extends core.int>(int x) l2005;
+ // The static function f2005 sets `T` to `int`.
+ if (!tIsBool) {
+ x2005 = f2005 as dynamic;
+ l2005 = f2005 as dynamic;
+ x2005 = confuse(f2005);
+ l2005 = confuse(f2005);
+ }
+
+ Expect.isTrue(m2005 is F2005);
+ Expect.isTrue(m2005 is List<Function> Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2005) is F2005);
+ // In checked mode, verifies the type.
+ x2005 = m2005;
+ l2005 = m2005;
+ x2005 = confuse(m2005);
+ l2005 = confuse(m2005);
+
+ }
+
+
+}
+
+class C6<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x1, [int x2]) x6;
+ Function Function(int x1, [List<T> x2]) x106;
+ core.List<core.int> Function([core.List<core.int> x1]) x206;
+ Function(List<Function> x0) x306;
+ int Function([int x]) Function<B extends core.int>() x406;
+ int Function(List<Function> x1) Function<B extends core.int>() x506;
+ int Function(int x, [List<T> x1]) Function<B extends core.int>() x606;
+ Function Function(int x1, {Function x}) Function<B extends core.int>() x706;
+ Function Function([List<T> x]) Function<B extends core.int>() x806;
+ List<Function> Function(int y, [Function x]) Function<B extends core.int>() x906;
+ List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() x1006;
+ core.List<core.int> Function({int x}) Function<B extends core.int>() x1106;
+ core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>() x1206;
+ List<T> Function(int x1, [int x]) Function<B extends core.int>() x1306;
+ List<T> Function([List<Function> x1]) Function<B extends core.int>() x1406;
+ List<T> Function({List<T> x}) Function<B extends core.int>() x1506;
+ Function(int y, {Function x}) Function<B extends core.int>() x1606;
+ Function(int x1, [List<T> x]) Function<B extends core.int>() x1706;
+ Function Function<A>(List<A> x) Function<B extends core.int>() x1806;
+ Function<A>(int x) Function<B extends core.int>() x1906;
+ core.List<core.int> Function(B x) Function<B extends core.int>() x2006;
+
+
+ C6({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m6(int x0, [int x1]) => null;
+ Function m106(int x0, [List<T> x1]) => null;
+ core.List<core.int> m206([core.List<core.int> x0]) => null;
+ m306(List<Function> x0) => null;
+ int Function([int x]) m406<B extends core.int>() => null;
+ int Function(List<Function> x0) m506<B extends core.int>() => null;
+ int Function(int x, [List<T> x0]) m606<B extends core.int>() => null;
+ Function Function(int x0, {Function x}) m706<B extends core.int>() => null;
+ Function Function([List<T> x]) m806<B extends core.int>() => null;
+ List<Function> Function(int y, [Function x]) m906<B extends core.int>() => null;
+ List<Function> Function(int x0, [core.List<core.int> x1]) m1006<B extends core.int>() => null;
+ core.List<core.int> Function({int x}) m1106<B extends core.int>() => null;
+ core.List<core.int> Function(core.List<core.int> x) m1206<B extends core.int>() => null;
+ List<T> Function(int x0, [int x]) m1306<B extends core.int>() => null;
+ List<T> Function([List<Function> x0]) m1406<B extends core.int>() => null;
+ List<T> Function({List<T> x}) m1506<B extends core.int>() => null;
+ Function(int y, {Function x}) m1606<B extends core.int>() => null;
+ Function(int x0, [List<T> x]) m1706<B extends core.int>() => null;
+ Function Function<A>(List<A> x) m1806<B extends core.int>() => null;
+ Function<A>(int x) m1906<B extends core.int>() => null;
+ core.List<core.int> Function(B x) m2006<B extends core.int>() => null;
+
+
+ runTests() {
+ testF6();
+ testF106();
+ testF206();
+ testF306();
+ testF406();
+ testF506();
+ testF606();
+ testF706();
+ testF806();
+ testF906();
+ testF1006();
+ testF1106();
+ testF1206();
+ testF1306();
+ testF1406();
+ testF1506();
+ testF1606();
+ testF1706();
+ testF1806();
+ testF1906();
+ testF2006();
+ }
+
+ void testF6() {
+ // int Function(int x1, [int x2])
+ Expect.isTrue(f6 is F6);
+ Expect.isTrue(confuse(f6) is F6);
+ // In checked mode, verifies the type.
+ int Function(int x1, [int x2]) l6;
+ // The static function f6 sets `T` to `int`.
+ if (!tIsBool) {
+ 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 x1, [int x2]));
+ Expect.isTrue(confuse(m6) is F6);
+ // In checked mode, verifies the type.
+ x6 = m6;
+ l6 = m6;
+ x6 = confuse(m6);
+ l6 = confuse(m6);
+
+ }
+
+ void testF106() {
+ // Function Function(int x1, [List<T> x2])
+ Expect.isTrue(f106 is F106);
+ Expect.isTrue(confuse(f106) is F106);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<T> x2]) l106;
+ // The static function f106 sets `T` to `int`.
+ if (!tIsBool) {
+ x106 = f106 as dynamic;
+ l106 = f106 as dynamic;
+ x106 = confuse(f106);
+ l106 = confuse(f106);
+ }
+
+ Expect.isTrue(m106 is F106);
+ Expect.isTrue(m106 is Function Function(int x1, [List<T> x2]));
+ Expect.isTrue(confuse(m106) is F106);
+ // In checked mode, verifies the type.
+ x106 = m106;
+ l106 = m106;
+ x106 = confuse(m106);
+ l106 = confuse(m106);
+ if (!tIsBool) {
+ Expect.isTrue(f106 is F106<int>);
+ Expect.isFalse(f106 is F106<bool>);
+ Expect.isTrue(confuse(f106) is F106<int>);
+ Expect.isFalse(confuse(f106) is F106<bool>);
+ Expect.equals(tIsDynamic, m106 is F106<bool>);
+ Expect.equals(tIsDynamic, confuse(m106) is F106<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x106 = (f106 as dynamic); });
+ Expect.throws(() { x106 = confuse(f106); });
+ Function Function(int x1, [List<T> x2]) l106;
+ Expect.throws(() { l106 = (f106 as dynamic); });
+ Expect.throws(() { l106 = confuse(f106); });
+ }
+ Function Function(int x1, [List<T> x2]) l106 = m106;
+ // In checked mode, verifies the type.
+ x106 = m106;
+ x106 = confuse(m106);
+ }
+ }
+
+ void testF206() {
+ // core.List<core.int> Function([core.List<core.int> x1])
+ Expect.isTrue(f206 is F206);
+ Expect.isTrue(confuse(f206) is F206);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x1]) l206;
+ // The static function f206 sets `T` to `int`.
+ if (!tIsBool) {
+ x206 = f206 as dynamic;
+ l206 = f206 as dynamic;
+ x206 = confuse(f206);
+ l206 = confuse(f206);
+ }
+
+ Expect.isTrue(m206 is F206);
+ Expect.isTrue(m206 is core.List<core.int> Function([core.List<core.int> x1]));
+ Expect.isTrue(confuse(m206) is F206);
+ // In checked mode, verifies the type.
+ x206 = m206;
+ l206 = m206;
+ x206 = confuse(m206);
+ l206 = confuse(m206);
+
+ }
+
+ void testF306() {
+ // Function(List<Function> x0)
+ Expect.isTrue(f306 is F306);
+ Expect.isTrue(confuse(f306) is F306);
+ // In checked mode, verifies the type.
+ Function(List<Function> x0) l306;
+ // The static function f306 sets `T` to `int`.
+ if (!tIsBool) {
+ x306 = f306 as dynamic;
+ l306 = f306 as dynamic;
+ x306 = confuse(f306);
+ l306 = confuse(f306);
+ }
+
+ Expect.isTrue(m306 is F306);
+ Expect.isTrue(m306 is Function(List<Function> x0));
+ Expect.isTrue(confuse(m306) is F306);
+ // In checked mode, verifies the type.
+ x306 = m306;
+ l306 = m306;
+ x306 = confuse(m306);
+ l306 = confuse(m306);
+
+ }
+
+ void testF406() {
+ // int Function([int x]) Function<B extends core.int>()
+ Expect.isTrue(f406 is F406);
+ Expect.isTrue(confuse(f406) is F406);
+ // In checked mode, verifies the type.
+ int Function([int x]) Function<B extends core.int>() l406;
+ // The static function f406 sets `T` to `int`.
+ if (!tIsBool) {
+ x406 = f406 as dynamic;
+ l406 = f406 as dynamic;
+ x406 = confuse(f406);
+ l406 = confuse(f406);
+ }
+
+ Expect.isTrue(m406 is F406);
+ Expect.isTrue(m406 is int Function([int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m406) is F406);
+ // In checked mode, verifies the type.
+ x406 = m406;
+ l406 = m406;
+ x406 = confuse(m406);
+ l406 = confuse(m406);
+
+ }
+
+ void testF506() {
+ // int Function(List<Function> x1) Function<B extends core.int>()
+ Expect.isTrue(f506 is F506);
+ Expect.isTrue(confuse(f506) is F506);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x1) Function<B extends core.int>() l506;
+ // The static function f506 sets `T` to `int`.
+ if (!tIsBool) {
+ x506 = f506 as dynamic;
+ l506 = f506 as dynamic;
+ x506 = confuse(f506);
+ l506 = confuse(f506);
+ }
+
+ Expect.isTrue(m506 is F506);
+ Expect.isTrue(m506 is int Function(List<Function> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m506) is F506);
+ // In checked mode, verifies the type.
+ x506 = m506;
+ l506 = m506;
+ x506 = confuse(m506);
+ l506 = confuse(m506);
+
+ }
+
+ void testF606() {
+ // int Function(int x, [List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f606 is F606);
+ Expect.isTrue(confuse(f606) is F606);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<T> x1]) Function<B extends core.int>() l606;
+ // The static function f606 sets `T` to `int`.
+ if (!tIsBool) {
+ x606 = f606 as dynamic;
+ l606 = f606 as dynamic;
+ x606 = confuse(f606);
+ l606 = confuse(f606);
+ }
+
+ Expect.isTrue(m606 is F606);
+ Expect.isTrue(m606 is int Function(int x, [List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m606) is F606);
+ // In checked mode, verifies the type.
+ x606 = m606;
+ l606 = m606;
+ x606 = confuse(m606);
+ l606 = confuse(m606);
+ if (!tIsBool) {
+ Expect.isTrue(f606 is F606<int>);
+ Expect.isFalse(f606 is F606<bool>);
+ Expect.isTrue(confuse(f606) is F606<int>);
+ Expect.isFalse(confuse(f606) is F606<bool>);
+ Expect.equals(tIsDynamic, m606 is F606<bool>);
+ Expect.equals(tIsDynamic, confuse(m606) is F606<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x606 = (f606 as dynamic); });
+ Expect.throws(() { x606 = confuse(f606); });
+ int Function(int x, [List<T> x1]) Function<B extends core.int>() l606;
+ Expect.throws(() { l606 = (f606 as dynamic); });
+ Expect.throws(() { l606 = confuse(f606); });
+ }
+ int Function(int x, [List<T> x1]) Function<B extends core.int>() l606 = m606;
+ // In checked mode, verifies the type.
+ x606 = m606;
+ x606 = confuse(m606);
+ }
+ }
+
+ void testF706() {
+ // Function Function(int x1, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f706 is F706);
+ Expect.isTrue(confuse(f706) is F706);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {Function x}) Function<B extends core.int>() l706;
+ // The static function f706 sets `T` to `int`.
+ if (!tIsBool) {
+ x706 = f706 as dynamic;
+ l706 = f706 as dynamic;
+ x706 = confuse(f706);
+ l706 = confuse(f706);
+ }
+
+ Expect.isTrue(m706 is F706);
+ Expect.isTrue(m706 is Function Function(int x1, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m706) is F706);
+ // In checked mode, verifies the type.
+ x706 = m706;
+ l706 = m706;
+ x706 = confuse(m706);
+ l706 = confuse(m706);
+
+ }
+
+ void testF806() {
+ // Function Function([List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f806 is F806);
+ Expect.isTrue(confuse(f806) is F806);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x]) Function<B extends core.int>() l806;
+ // The static function f806 sets `T` to `int`.
+ if (!tIsBool) {
+ x806 = f806 as dynamic;
+ l806 = f806 as dynamic;
+ x806 = confuse(f806);
+ l806 = confuse(f806);
+ }
+
+ Expect.isTrue(m806 is F806);
+ Expect.isTrue(m806 is Function Function([List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m806) is F806);
+ // In checked mode, verifies the type.
+ x806 = m806;
+ l806 = m806;
+ x806 = confuse(m806);
+ l806 = confuse(m806);
+ if (!tIsBool) {
+ Expect.isTrue(f806 is F806<int>);
+ Expect.isFalse(f806 is F806<bool>);
+ Expect.isTrue(confuse(f806) is F806<int>);
+ Expect.isFalse(confuse(f806) is F806<bool>);
+ Expect.equals(tIsDynamic, m806 is F806<bool>);
+ Expect.equals(tIsDynamic, confuse(m806) is F806<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x806 = (f806 as dynamic); });
+ Expect.throws(() { x806 = confuse(f806); });
+ Function Function([List<T> x]) Function<B extends core.int>() l806;
+ Expect.throws(() { l806 = (f806 as dynamic); });
+ Expect.throws(() { l806 = confuse(f806); });
+ }
+ Function Function([List<T> x]) Function<B extends core.int>() l806 = m806;
+ // In checked mode, verifies the type.
+ x806 = m806;
+ x806 = confuse(m806);
+ }
+ }
+
+ void testF906() {
+ // List<Function> Function(int y, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f906 is F906);
+ Expect.isTrue(confuse(f906) is F906);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [Function x]) Function<B extends core.int>() l906;
+ // The static function f906 sets `T` to `int`.
+ if (!tIsBool) {
+ x906 = f906 as dynamic;
+ l906 = f906 as dynamic;
+ x906 = confuse(f906);
+ l906 = confuse(f906);
+ }
+
+ Expect.isTrue(m906 is F906);
+ Expect.isTrue(m906 is List<Function> Function(int y, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m906) is F906);
+ // In checked mode, verifies the type.
+ x906 = m906;
+ l906 = m906;
+ x906 = confuse(m906);
+ l906 = confuse(m906);
+
+ }
+
+ void testF1006() {
+ // List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1006 is F1006);
+ Expect.isTrue(confuse(f1006) is F1006);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l1006;
+ // The static function f1006 sets `T` to `int`.
+ if (!tIsBool) {
+ x1006 = f1006 as dynamic;
+ l1006 = f1006 as dynamic;
+ x1006 = confuse(f1006);
+ l1006 = confuse(f1006);
+ }
+
+ Expect.isTrue(m1006 is F1006);
+ Expect.isTrue(m1006 is List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1006) is F1006);
+ // In checked mode, verifies the type.
+ x1006 = m1006;
+ l1006 = m1006;
+ x1006 = confuse(m1006);
+ l1006 = confuse(m1006);
+
+ }
+
+ void testF1106() {
+ // core.List<core.int> Function({int x}) Function<B extends core.int>()
+ Expect.isTrue(f1106 is F1106);
+ Expect.isTrue(confuse(f1106) is F1106);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({int x}) Function<B extends core.int>() l1106;
+ // The static function f1106 sets `T` to `int`.
+ if (!tIsBool) {
+ x1106 = f1106 as dynamic;
+ l1106 = f1106 as dynamic;
+ x1106 = confuse(f1106);
+ l1106 = confuse(f1106);
+ }
+
+ Expect.isTrue(m1106 is F1106);
+ Expect.isTrue(m1106 is core.List<core.int> Function({int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1106) is F1106);
+ // In checked mode, verifies the type.
+ x1106 = m1106;
+ l1106 = m1106;
+ x1106 = confuse(m1106);
+ l1106 = confuse(m1106);
+
+ }
+
+ void testF1206() {
+ // core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1206 is F1206);
+ Expect.isTrue(confuse(f1206) is F1206);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>() l1206;
+ // The static function f1206 sets `T` to `int`.
+ if (!tIsBool) {
+ x1206 = f1206 as dynamic;
+ l1206 = f1206 as dynamic;
+ x1206 = confuse(f1206);
+ l1206 = confuse(f1206);
+ }
+
+ Expect.isTrue(m1206 is F1206);
+ Expect.isTrue(m1206 is core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1206) is F1206);
+ // In checked mode, verifies the type.
+ x1206 = m1206;
+ l1206 = m1206;
+ x1206 = confuse(m1206);
+ l1206 = confuse(m1206);
+
+ }
+
+ void testF1306() {
+ // List<T> Function(int x1, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f1306 is F1306);
+ Expect.isTrue(confuse(f1306) is F1306);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [int x]) Function<B extends core.int>() l1306;
+ // The static function f1306 sets `T` to `int`.
+ if (!tIsBool) {
+ x1306 = f1306 as dynamic;
+ l1306 = f1306 as dynamic;
+ x1306 = confuse(f1306);
+ l1306 = confuse(f1306);
+ }
+
+ Expect.isTrue(m1306 is F1306);
+ Expect.isTrue(m1306 is List<T> Function(int x1, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1306) is F1306);
+ // In checked mode, verifies the type.
+ x1306 = m1306;
+ l1306 = m1306;
+ x1306 = confuse(m1306);
+ l1306 = confuse(m1306);
+ if (!tIsBool) {
+ Expect.isTrue(f1306 is F1306<int>);
+ Expect.isFalse(f1306 is F1306<bool>);
+ Expect.isTrue(confuse(f1306) is F1306<int>);
+ Expect.isFalse(confuse(f1306) is F1306<bool>);
+ Expect.equals(tIsDynamic, m1306 is F1306<bool>);
+ Expect.equals(tIsDynamic, confuse(m1306) is F1306<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1306 = (f1306 as dynamic); });
+ Expect.throws(() { x1306 = confuse(f1306); });
+ List<T> Function(int x1, [int x]) Function<B extends core.int>() l1306;
+ Expect.throws(() { l1306 = (f1306 as dynamic); });
+ Expect.throws(() { l1306 = confuse(f1306); });
+ }
+ List<T> Function(int x1, [int x]) Function<B extends core.int>() l1306 = m1306;
+ // In checked mode, verifies the type.
+ x1306 = m1306;
+ x1306 = confuse(m1306);
+ }
+ }
+
+ void testF1406() {
+ // List<T> Function([List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1406 is F1406);
+ Expect.isTrue(confuse(f1406) is F1406);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x1]) Function<B extends core.int>() l1406;
+ // The static function f1406 sets `T` to `int`.
+ if (!tIsBool) {
+ x1406 = f1406 as dynamic;
+ l1406 = f1406 as dynamic;
+ x1406 = confuse(f1406);
+ l1406 = confuse(f1406);
+ }
+
+ Expect.isTrue(m1406 is F1406);
+ Expect.isTrue(m1406 is List<T> Function([List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1406) is F1406);
+ // In checked mode, verifies the type.
+ x1406 = m1406;
+ l1406 = m1406;
+ x1406 = confuse(m1406);
+ l1406 = confuse(m1406);
+ if (!tIsBool) {
+ Expect.isTrue(f1406 is F1406<int>);
+ Expect.isFalse(f1406 is F1406<bool>);
+ Expect.isTrue(confuse(f1406) is F1406<int>);
+ Expect.isFalse(confuse(f1406) is F1406<bool>);
+ Expect.equals(tIsDynamic, m1406 is F1406<bool>);
+ Expect.equals(tIsDynamic, confuse(m1406) is F1406<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1406 = (f1406 as dynamic); });
+ Expect.throws(() { x1406 = confuse(f1406); });
+ List<T> Function([List<Function> x1]) Function<B extends core.int>() l1406;
+ Expect.throws(() { l1406 = (f1406 as dynamic); });
+ Expect.throws(() { l1406 = confuse(f1406); });
+ }
+ List<T> Function([List<Function> x1]) Function<B extends core.int>() l1406 = m1406;
+ // In checked mode, verifies the type.
+ x1406 = m1406;
+ x1406 = confuse(m1406);
+ }
+ }
+
+ void testF1506() {
+ // List<T> Function({List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1506 is F1506);
+ Expect.isTrue(confuse(f1506) is F1506);
+ // In checked mode, verifies the type.
+ List<T> Function({List<T> x}) Function<B extends core.int>() l1506;
+ // The static function f1506 sets `T` to `int`.
+ if (!tIsBool) {
+ x1506 = f1506 as dynamic;
+ l1506 = f1506 as dynamic;
+ x1506 = confuse(f1506);
+ l1506 = confuse(f1506);
+ }
+
+ Expect.isTrue(m1506 is F1506);
+ Expect.isTrue(m1506 is List<T> Function({List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1506) is F1506);
+ // In checked mode, verifies the type.
+ x1506 = m1506;
+ l1506 = m1506;
+ x1506 = confuse(m1506);
+ l1506 = confuse(m1506);
+ if (!tIsBool) {
+ Expect.isTrue(f1506 is F1506<int>);
+ Expect.isFalse(f1506 is F1506<bool>);
+ Expect.isTrue(confuse(f1506) is F1506<int>);
+ Expect.isFalse(confuse(f1506) is F1506<bool>);
+ Expect.equals(tIsDynamic, m1506 is F1506<bool>);
+ Expect.equals(tIsDynamic, confuse(m1506) is F1506<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1506 = (f1506 as dynamic); });
+ Expect.throws(() { x1506 = confuse(f1506); });
+ List<T> Function({List<T> x}) Function<B extends core.int>() l1506;
+ Expect.throws(() { l1506 = (f1506 as dynamic); });
+ Expect.throws(() { l1506 = confuse(f1506); });
+ }
+ List<T> Function({List<T> x}) Function<B extends core.int>() l1506 = m1506;
+ // In checked mode, verifies the type.
+ x1506 = m1506;
+ x1506 = confuse(m1506);
+ }
+ }
+
+ void testF1606() {
+ // Function(int y, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1606 is F1606);
+ Expect.isTrue(confuse(f1606) is F1606);
+ // In checked mode, verifies the type.
+ Function(int y, {Function x}) Function<B extends core.int>() l1606;
+ // The static function f1606 sets `T` to `int`.
+ if (!tIsBool) {
+ x1606 = f1606 as dynamic;
+ l1606 = f1606 as dynamic;
+ x1606 = confuse(f1606);
+ l1606 = confuse(f1606);
+ }
+
+ Expect.isTrue(m1606 is F1606);
+ Expect.isTrue(m1606 is Function(int y, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1606) is F1606);
+ // In checked mode, verifies the type.
+ x1606 = m1606;
+ l1606 = m1606;
+ x1606 = confuse(m1606);
+ l1606 = confuse(m1606);
+
+ }
+
+ void testF1706() {
+ // Function(int x1, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1706 is F1706);
+ Expect.isTrue(confuse(f1706) is F1706);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<T> x]) Function<B extends core.int>() l1706;
+ // The static function f1706 sets `T` to `int`.
+ if (!tIsBool) {
+ x1706 = f1706 as dynamic;
+ l1706 = f1706 as dynamic;
+ x1706 = confuse(f1706);
+ l1706 = confuse(f1706);
+ }
+
+ Expect.isTrue(m1706 is F1706);
+ Expect.isTrue(m1706 is Function(int x1, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1706) is F1706);
+ // In checked mode, verifies the type.
+ x1706 = m1706;
+ l1706 = m1706;
+ x1706 = confuse(m1706);
+ l1706 = confuse(m1706);
+ if (!tIsBool) {
+ Expect.isTrue(f1706 is F1706<int>);
+ Expect.isFalse(f1706 is F1706<bool>);
+ Expect.isTrue(confuse(f1706) is F1706<int>);
+ Expect.isFalse(confuse(f1706) is F1706<bool>);
+ Expect.equals(tIsDynamic, m1706 is F1706<bool>);
+ Expect.equals(tIsDynamic, confuse(m1706) is F1706<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1706 = (f1706 as dynamic); });
+ Expect.throws(() { x1706 = confuse(f1706); });
+ Function(int x1, [List<T> x]) Function<B extends core.int>() l1706;
+ Expect.throws(() { l1706 = (f1706 as dynamic); });
+ Expect.throws(() { l1706 = confuse(f1706); });
+ }
+ Function(int x1, [List<T> x]) Function<B extends core.int>() l1706 = m1706;
+ // In checked mode, verifies the type.
+ x1706 = m1706;
+ x1706 = confuse(m1706);
+ }
+ }
+
+ void testF1806() {
+ // Function Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1806 is F1806);
+ Expect.isTrue(confuse(f1806) is F1806);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<A> x) Function<B extends core.int>() l1806;
+ // The static function f1806 sets `T` to `int`.
+ if (!tIsBool) {
+ x1806 = f1806 as dynamic;
+ l1806 = f1806 as dynamic;
+ x1806 = confuse(f1806);
+ l1806 = confuse(f1806);
+ }
+
+ Expect.isTrue(m1806 is F1806);
+ Expect.isTrue(m1806 is Function Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1806) is F1806);
+ // In checked mode, verifies the type.
+ x1806 = m1806;
+ l1806 = m1806;
+ x1806 = confuse(m1806);
+ l1806 = confuse(m1806);
+
+ }
+
+ void testF1906() {
+ // Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1906 is F1906);
+ Expect.isTrue(confuse(f1906) is F1906);
+ // In checked mode, verifies the type.
+ Function<A>(int x) Function<B extends core.int>() l1906;
+ // The static function f1906 sets `T` to `int`.
+ if (!tIsBool) {
+ x1906 = f1906 as dynamic;
+ l1906 = f1906 as dynamic;
+ x1906 = confuse(f1906);
+ l1906 = confuse(f1906);
+ }
+
+ Expect.isTrue(m1906 is F1906);
+ Expect.isTrue(m1906 is Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1906) is F1906);
+ // In checked mode, verifies the type.
+ x1906 = m1906;
+ l1906 = m1906;
+ x1906 = confuse(m1906);
+ l1906 = confuse(m1906);
+
+ }
+
+ void testF2006() {
+ // core.List<core.int> Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2006 is F2006);
+ Expect.isTrue(confuse(f2006) is F2006);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(B x) Function<B extends core.int>() l2006;
+ // The static function f2006 sets `T` to `int`.
+ if (!tIsBool) {
+ x2006 = f2006 as dynamic;
+ l2006 = f2006 as dynamic;
+ x2006 = confuse(f2006);
+ l2006 = confuse(f2006);
+ }
+
+ Expect.isTrue(m2006 is F2006);
+ Expect.isTrue(m2006 is core.List<core.int> Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2006) is F2006);
+ // In checked mode, verifies the type.
+ x2006 = m2006;
+ l2006 = m2006;
+ x2006 = confuse(m2006);
+ l2006 = confuse(m2006);
+
+ }
+
+
+}
+
+class C7<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x, [int x2]) x7;
+ Function Function(int x, [List<T> x2]) x107;
+ core.List<core.int> Function(int x1, [core.List<core.int> x2]) x207;
+ Function([List<Function> x1]) x307;
+ int Function([int x]) Function<B extends core.int>(int x) x407;
+ int Function(List<Function> x1) Function<B extends core.int>(int x) x507;
+ int Function(int x, [List<T> x1]) Function<B extends core.int>(int x) x607;
+ Function Function(int x1, {Function x}) Function<B extends core.int>(int x) x707;
+ Function Function([List<T> x]) Function<B extends core.int>(int x) x807;
+ List<Function> Function(int y, [Function x]) Function<B extends core.int>(int x) x907;
+ List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) x1007;
+ core.List<core.int> Function({int x}) Function<B extends core.int>(int x) x1107;
+ core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>(int x) x1207;
+ List<T> Function(int x1, [int x]) Function<B extends core.int>(int x) x1307;
+ List<T> Function([List<Function> x1]) Function<B extends core.int>(int x) x1407;
+ List<T> Function({List<T> x}) Function<B extends core.int>(int x) x1507;
+ Function(int y, {Function x}) Function<B extends core.int>(int x) x1607;
+ Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x1707;
+ Function Function<A>(List<A> x) Function<B extends core.int>(int x) x1807;
+ Function<A>(int x) Function<B extends core.int>(int x) x1907;
+ core.List<core.int> Function(B x) Function<B extends core.int>(int x) x2007;
+
+
+ C7({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m7(int x, [int x0]) => null;
+ Function m107(int x, [List<T> x0]) => null;
+ core.List<core.int> m207(int x0, [core.List<core.int> x1]) => null;
+ m307([List<Function> x0]) => null;
+ int Function([int x]) m407<B extends core.int>(int x) => null;
+ int Function(List<Function> x0) m507<B extends core.int>(int x) => null;
+ int Function(int x, [List<T> x0]) m607<B extends core.int>(int x) => null;
+ Function Function(int x0, {Function x}) m707<B extends core.int>(int x) => null;
+ Function Function([List<T> x]) m807<B extends core.int>(int x) => null;
+ List<Function> Function(int y, [Function x]) m907<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [core.List<core.int> x1]) m1007<B extends core.int>(int x) => null;
+ core.List<core.int> Function({int x}) m1107<B extends core.int>(int x) => null;
+ core.List<core.int> Function(core.List<core.int> x) m1207<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [int x]) m1307<B extends core.int>(int x) => null;
+ List<T> Function([List<Function> x0]) m1407<B extends core.int>(int x) => null;
+ List<T> Function({List<T> x}) m1507<B extends core.int>(int x) => null;
+ Function(int y, {Function x}) m1607<B extends core.int>(int x) => null;
+ Function(int x0, [List<T> x]) m1707<B extends core.int>(int x) => null;
+ Function Function<A>(List<A> x) m1807<B extends core.int>(int x) => null;
+ Function<A>(int x) m1907<B extends core.int>(int x) => null;
+ core.List<core.int> Function(B x) m2007<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF7();
+ testF107();
+ testF207();
+ testF307();
+ testF407();
+ testF507();
+ testF607();
+ testF707();
+ testF807();
+ testF907();
+ testF1007();
+ testF1107();
+ testF1207();
+ testF1307();
+ testF1407();
+ testF1507();
+ testF1607();
+ testF1707();
+ testF1807();
+ testF1907();
+ testF2007();
+ }
+
+ void testF7() {
+ // int Function(int x, [int x2])
+ Expect.isTrue(f7 is F7);
+ Expect.isTrue(confuse(f7) is F7);
+ // In checked mode, verifies the type.
+ int Function(int x, [int x2]) l7;
+ // The static function f7 sets `T` to `int`.
+ if (!tIsBool) {
+ x7 = f7 as dynamic;
+ l7 = f7 as dynamic;
+ x7 = confuse(f7);
+ l7 = confuse(f7);
+ }
+
+ Expect.isTrue(m7 is F7);
+ Expect.isTrue(m7 is int Function(int x, [int x2]));
+ Expect.isTrue(confuse(m7) is F7);
+ // In checked mode, verifies the type.
+ x7 = m7;
+ l7 = m7;
+ x7 = confuse(m7);
+ l7 = confuse(m7);
+
+ }
+
+ void testF107() {
+ // Function Function(int x, [List<T> x2])
+ Expect.isTrue(f107 is F107);
+ Expect.isTrue(confuse(f107) is F107);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<T> x2]) l107;
+ // The static function f107 sets `T` to `int`.
+ if (!tIsBool) {
+ x107 = f107 as dynamic;
+ l107 = f107 as dynamic;
+ x107 = confuse(f107);
+ l107 = confuse(f107);
+ }
+
+ Expect.isTrue(m107 is F107);
+ Expect.isTrue(m107 is Function Function(int x, [List<T> x2]));
+ Expect.isTrue(confuse(m107) is F107);
+ // In checked mode, verifies the type.
+ x107 = m107;
+ l107 = m107;
+ x107 = confuse(m107);
+ l107 = confuse(m107);
+ if (!tIsBool) {
+ Expect.isTrue(f107 is F107<int>);
+ Expect.isFalse(f107 is F107<bool>);
+ Expect.isTrue(confuse(f107) is F107<int>);
+ Expect.isFalse(confuse(f107) is F107<bool>);
+ Expect.equals(tIsDynamic, m107 is F107<bool>);
+ Expect.equals(tIsDynamic, confuse(m107) is F107<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x107 = (f107 as dynamic); });
+ Expect.throws(() { x107 = confuse(f107); });
+ Function Function(int x, [List<T> x2]) l107;
+ Expect.throws(() { l107 = (f107 as dynamic); });
+ Expect.throws(() { l107 = confuse(f107); });
+ }
+ Function Function(int x, [List<T> x2]) l107 = m107;
+ // In checked mode, verifies the type.
+ x107 = m107;
+ x107 = confuse(m107);
+ }
+ }
+
+ void testF207() {
+ // core.List<core.int> Function(int x1, [core.List<core.int> x2])
+ Expect.isTrue(f207 is F207);
+ Expect.isTrue(confuse(f207) is F207);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [core.List<core.int> x2]) l207;
+ // The static function f207 sets `T` to `int`.
+ if (!tIsBool) {
+ x207 = f207 as dynamic;
+ l207 = f207 as dynamic;
+ x207 = confuse(f207);
+ l207 = confuse(f207);
+ }
+
+ Expect.isTrue(m207 is F207);
+ Expect.isTrue(m207 is core.List<core.int> Function(int x1, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m207) is F207);
+ // In checked mode, verifies the type.
+ x207 = m207;
+ l207 = m207;
+ x207 = confuse(m207);
+ l207 = confuse(m207);
+
+ }
+
+ void testF307() {
+ // Function([List<Function> x1])
+ Expect.isTrue(f307 is F307);
+ Expect.isTrue(confuse(f307) is F307);
+ // In checked mode, verifies the type.
+ Function([List<Function> x1]) l307;
+ // The static function f307 sets `T` to `int`.
+ if (!tIsBool) {
+ x307 = f307 as dynamic;
+ l307 = f307 as dynamic;
+ x307 = confuse(f307);
+ l307 = confuse(f307);
+ }
+
+ Expect.isTrue(m307 is F307);
+ Expect.isTrue(m307 is Function([List<Function> x1]));
+ Expect.isTrue(confuse(m307) is F307);
+ // In checked mode, verifies the type.
+ x307 = m307;
+ l307 = m307;
+ x307 = confuse(m307);
+ l307 = confuse(m307);
+
+ }
+
+ void testF407() {
+ // int Function([int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f407 is F407);
+ Expect.isTrue(confuse(f407) is F407);
+ // In checked mode, verifies the type.
+ int Function([int x]) Function<B extends core.int>(int x) l407;
+ // The static function f407 sets `T` to `int`.
+ if (!tIsBool) {
+ x407 = f407 as dynamic;
+ l407 = f407 as dynamic;
+ x407 = confuse(f407);
+ l407 = confuse(f407);
+ }
+
+ Expect.isTrue(m407 is F407);
+ Expect.isTrue(m407 is int Function([int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m407) is F407);
+ // In checked mode, verifies the type.
+ x407 = m407;
+ l407 = m407;
+ x407 = confuse(m407);
+ l407 = confuse(m407);
+
+ }
+
+ void testF507() {
+ // int Function(List<Function> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f507 is F507);
+ Expect.isTrue(confuse(f507) is F507);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x1) Function<B extends core.int>(int x) l507;
+ // The static function f507 sets `T` to `int`.
+ if (!tIsBool) {
+ x507 = f507 as dynamic;
+ l507 = f507 as dynamic;
+ x507 = confuse(f507);
+ l507 = confuse(f507);
+ }
+
+ Expect.isTrue(m507 is F507);
+ Expect.isTrue(m507 is int Function(List<Function> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m507) is F507);
+ // In checked mode, verifies the type.
+ x507 = m507;
+ l507 = m507;
+ x507 = confuse(m507);
+ l507 = confuse(m507);
+
+ }
+
+ void testF607() {
+ // int Function(int x, [List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f607 is F607);
+ Expect.isTrue(confuse(f607) is F607);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l607;
+ // The static function f607 sets `T` to `int`.
+ if (!tIsBool) {
+ x607 = f607 as dynamic;
+ l607 = f607 as dynamic;
+ x607 = confuse(f607);
+ l607 = confuse(f607);
+ }
+
+ Expect.isTrue(m607 is F607);
+ Expect.isTrue(m607 is int Function(int x, [List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m607) is F607);
+ // In checked mode, verifies the type.
+ x607 = m607;
+ l607 = m607;
+ x607 = confuse(m607);
+ l607 = confuse(m607);
+ if (!tIsBool) {
+ Expect.isTrue(f607 is F607<int>);
+ Expect.isFalse(f607 is F607<bool>);
+ Expect.isTrue(confuse(f607) is F607<int>);
+ Expect.isFalse(confuse(f607) is F607<bool>);
+ Expect.equals(tIsDynamic, m607 is F607<bool>);
+ Expect.equals(tIsDynamic, confuse(m607) is F607<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x607 = (f607 as dynamic); });
+ Expect.throws(() { x607 = confuse(f607); });
+ int Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l607;
+ Expect.throws(() { l607 = (f607 as dynamic); });
+ Expect.throws(() { l607 = confuse(f607); });
+ }
+ int Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l607 = m607;
+ // In checked mode, verifies the type.
+ x607 = m607;
+ x607 = confuse(m607);
+ }
+ }
+
+ void testF707() {
+ // Function Function(int x1, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f707 is F707);
+ Expect.isTrue(confuse(f707) is F707);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {Function x}) Function<B extends core.int>(int x) l707;
+ // The static function f707 sets `T` to `int`.
+ if (!tIsBool) {
+ x707 = f707 as dynamic;
+ l707 = f707 as dynamic;
+ x707 = confuse(f707);
+ l707 = confuse(f707);
+ }
+
+ Expect.isTrue(m707 is F707);
+ Expect.isTrue(m707 is Function Function(int x1, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m707) is F707);
+ // In checked mode, verifies the type.
+ x707 = m707;
+ l707 = m707;
+ x707 = confuse(m707);
+ l707 = confuse(m707);
+
+ }
+
+ void testF807() {
+ // Function Function([List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f807 is F807);
+ Expect.isTrue(confuse(f807) is F807);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x]) Function<B extends core.int>(int x) l807;
+ // The static function f807 sets `T` to `int`.
+ if (!tIsBool) {
+ x807 = f807 as dynamic;
+ l807 = f807 as dynamic;
+ x807 = confuse(f807);
+ l807 = confuse(f807);
+ }
+
+ Expect.isTrue(m807 is F807);
+ Expect.isTrue(m807 is Function Function([List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m807) is F807);
+ // In checked mode, verifies the type.
+ x807 = m807;
+ l807 = m807;
+ x807 = confuse(m807);
+ l807 = confuse(m807);
+ if (!tIsBool) {
+ Expect.isTrue(f807 is F807<int>);
+ Expect.isFalse(f807 is F807<bool>);
+ Expect.isTrue(confuse(f807) is F807<int>);
+ Expect.isFalse(confuse(f807) is F807<bool>);
+ Expect.equals(tIsDynamic, m807 is F807<bool>);
+ Expect.equals(tIsDynamic, confuse(m807) is F807<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x807 = (f807 as dynamic); });
+ Expect.throws(() { x807 = confuse(f807); });
+ Function Function([List<T> x]) Function<B extends core.int>(int x) l807;
+ Expect.throws(() { l807 = (f807 as dynamic); });
+ Expect.throws(() { l807 = confuse(f807); });
+ }
+ Function Function([List<T> x]) Function<B extends core.int>(int x) l807 = m807;
+ // In checked mode, verifies the type.
+ x807 = m807;
+ x807 = confuse(m807);
+ }
+ }
+
+ void testF907() {
+ // List<Function> Function(int y, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f907 is F907);
+ Expect.isTrue(confuse(f907) is F907);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [Function x]) Function<B extends core.int>(int x) l907;
+ // The static function f907 sets `T` to `int`.
+ if (!tIsBool) {
+ x907 = f907 as dynamic;
+ l907 = f907 as dynamic;
+ x907 = confuse(f907);
+ l907 = confuse(f907);
+ }
+
+ Expect.isTrue(m907 is F907);
+ Expect.isTrue(m907 is List<Function> Function(int y, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m907) is F907);
+ // In checked mode, verifies the type.
+ x907 = m907;
+ l907 = m907;
+ x907 = confuse(m907);
+ l907 = confuse(m907);
+
+ }
+
+ void testF1007() {
+ // List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1007 is F1007);
+ Expect.isTrue(confuse(f1007) is F1007);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l1007;
+ // The static function f1007 sets `T` to `int`.
+ if (!tIsBool) {
+ x1007 = f1007 as dynamic;
+ l1007 = f1007 as dynamic;
+ x1007 = confuse(f1007);
+ l1007 = confuse(f1007);
+ }
+
+ Expect.isTrue(m1007 is F1007);
+ Expect.isTrue(m1007 is List<Function> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1007) is F1007);
+ // In checked mode, verifies the type.
+ x1007 = m1007;
+ l1007 = m1007;
+ x1007 = confuse(m1007);
+ l1007 = confuse(m1007);
+
+ }
+
+ void testF1107() {
+ // core.List<core.int> Function({int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1107 is F1107);
+ Expect.isTrue(confuse(f1107) is F1107);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({int x}) Function<B extends core.int>(int x) l1107;
+ // The static function f1107 sets `T` to `int`.
+ if (!tIsBool) {
+ x1107 = f1107 as dynamic;
+ l1107 = f1107 as dynamic;
+ x1107 = confuse(f1107);
+ l1107 = confuse(f1107);
+ }
+
+ Expect.isTrue(m1107 is F1107);
+ Expect.isTrue(m1107 is core.List<core.int> Function({int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1107) is F1107);
+ // In checked mode, verifies the type.
+ x1107 = m1107;
+ l1107 = m1107;
+ x1107 = confuse(m1107);
+ l1107 = confuse(m1107);
+
+ }
+
+ void testF1207() {
+ // core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1207 is F1207);
+ Expect.isTrue(confuse(f1207) is F1207);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>(int x) l1207;
+ // The static function f1207 sets `T` to `int`.
+ if (!tIsBool) {
+ x1207 = f1207 as dynamic;
+ l1207 = f1207 as dynamic;
+ x1207 = confuse(f1207);
+ l1207 = confuse(f1207);
+ }
+
+ Expect.isTrue(m1207 is F1207);
+ Expect.isTrue(m1207 is core.List<core.int> Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1207) is F1207);
+ // In checked mode, verifies the type.
+ x1207 = m1207;
+ l1207 = m1207;
+ x1207 = confuse(m1207);
+ l1207 = confuse(m1207);
+
+ }
+
+ void testF1307() {
+ // List<T> Function(int x1, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1307 is F1307);
+ Expect.isTrue(confuse(f1307) is F1307);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [int x]) Function<B extends core.int>(int x) l1307;
+ // The static function f1307 sets `T` to `int`.
+ if (!tIsBool) {
+ x1307 = f1307 as dynamic;
+ l1307 = f1307 as dynamic;
+ x1307 = confuse(f1307);
+ l1307 = confuse(f1307);
+ }
+
+ Expect.isTrue(m1307 is F1307);
+ Expect.isTrue(m1307 is List<T> Function(int x1, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1307) is F1307);
+ // In checked mode, verifies the type.
+ x1307 = m1307;
+ l1307 = m1307;
+ x1307 = confuse(m1307);
+ l1307 = confuse(m1307);
+ if (!tIsBool) {
+ Expect.isTrue(f1307 is F1307<int>);
+ Expect.isFalse(f1307 is F1307<bool>);
+ Expect.isTrue(confuse(f1307) is F1307<int>);
+ Expect.isFalse(confuse(f1307) is F1307<bool>);
+ Expect.equals(tIsDynamic, m1307 is F1307<bool>);
+ Expect.equals(tIsDynamic, confuse(m1307) is F1307<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1307 = (f1307 as dynamic); });
+ Expect.throws(() { x1307 = confuse(f1307); });
+ List<T> Function(int x1, [int x]) Function<B extends core.int>(int x) l1307;
+ Expect.throws(() { l1307 = (f1307 as dynamic); });
+ Expect.throws(() { l1307 = confuse(f1307); });
+ }
+ List<T> Function(int x1, [int x]) Function<B extends core.int>(int x) l1307 = m1307;
+ // In checked mode, verifies the type.
+ x1307 = m1307;
+ x1307 = confuse(m1307);
+ }
+ }
+
+ void testF1407() {
+ // List<T> Function([List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1407 is F1407);
+ Expect.isTrue(confuse(f1407) is F1407);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x1]) Function<B extends core.int>(int x) l1407;
+ // The static function f1407 sets `T` to `int`.
+ if (!tIsBool) {
+ x1407 = f1407 as dynamic;
+ l1407 = f1407 as dynamic;
+ x1407 = confuse(f1407);
+ l1407 = confuse(f1407);
+ }
+
+ Expect.isTrue(m1407 is F1407);
+ Expect.isTrue(m1407 is List<T> Function([List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1407) is F1407);
+ // In checked mode, verifies the type.
+ x1407 = m1407;
+ l1407 = m1407;
+ x1407 = confuse(m1407);
+ l1407 = confuse(m1407);
+ if (!tIsBool) {
+ Expect.isTrue(f1407 is F1407<int>);
+ Expect.isFalse(f1407 is F1407<bool>);
+ Expect.isTrue(confuse(f1407) is F1407<int>);
+ Expect.isFalse(confuse(f1407) is F1407<bool>);
+ Expect.equals(tIsDynamic, m1407 is F1407<bool>);
+ Expect.equals(tIsDynamic, confuse(m1407) is F1407<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1407 = (f1407 as dynamic); });
+ Expect.throws(() { x1407 = confuse(f1407); });
+ List<T> Function([List<Function> x1]) Function<B extends core.int>(int x) l1407;
+ Expect.throws(() { l1407 = (f1407 as dynamic); });
+ Expect.throws(() { l1407 = confuse(f1407); });
+ }
+ List<T> Function([List<Function> x1]) Function<B extends core.int>(int x) l1407 = m1407;
+ // In checked mode, verifies the type.
+ x1407 = m1407;
+ x1407 = confuse(m1407);
+ }
+ }
+
+ void testF1507() {
+ // List<T> Function({List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1507 is F1507);
+ Expect.isTrue(confuse(f1507) is F1507);
+ // In checked mode, verifies the type.
+ List<T> Function({List<T> x}) Function<B extends core.int>(int x) l1507;
+ // The static function f1507 sets `T` to `int`.
+ if (!tIsBool) {
+ x1507 = f1507 as dynamic;
+ l1507 = f1507 as dynamic;
+ x1507 = confuse(f1507);
+ l1507 = confuse(f1507);
+ }
+
+ Expect.isTrue(m1507 is F1507);
+ Expect.isTrue(m1507 is List<T> Function({List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1507) is F1507);
+ // In checked mode, verifies the type.
+ x1507 = m1507;
+ l1507 = m1507;
+ x1507 = confuse(m1507);
+ l1507 = confuse(m1507);
+ if (!tIsBool) {
+ Expect.isTrue(f1507 is F1507<int>);
+ Expect.isFalse(f1507 is F1507<bool>);
+ Expect.isTrue(confuse(f1507) is F1507<int>);
+ Expect.isFalse(confuse(f1507) is F1507<bool>);
+ Expect.equals(tIsDynamic, m1507 is F1507<bool>);
+ Expect.equals(tIsDynamic, confuse(m1507) is F1507<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1507 = (f1507 as dynamic); });
+ Expect.throws(() { x1507 = confuse(f1507); });
+ List<T> Function({List<T> x}) Function<B extends core.int>(int x) l1507;
+ Expect.throws(() { l1507 = (f1507 as dynamic); });
+ Expect.throws(() { l1507 = confuse(f1507); });
+ }
+ List<T> Function({List<T> x}) Function<B extends core.int>(int x) l1507 = m1507;
+ // In checked mode, verifies the type.
+ x1507 = m1507;
+ x1507 = confuse(m1507);
+ }
+ }
+
+ void testF1607() {
+ // Function(int y, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1607 is F1607);
+ Expect.isTrue(confuse(f1607) is F1607);
+ // In checked mode, verifies the type.
+ Function(int y, {Function x}) Function<B extends core.int>(int x) l1607;
+ // The static function f1607 sets `T` to `int`.
+ if (!tIsBool) {
+ x1607 = f1607 as dynamic;
+ l1607 = f1607 as dynamic;
+ x1607 = confuse(f1607);
+ l1607 = confuse(f1607);
+ }
+
+ Expect.isTrue(m1607 is F1607);
+ Expect.isTrue(m1607 is Function(int y, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1607) is F1607);
+ // In checked mode, verifies the type.
+ x1607 = m1607;
+ l1607 = m1607;
+ x1607 = confuse(m1607);
+ l1607 = confuse(m1607);
+
+ }
+
+ void testF1707() {
+ // Function(int x1, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1707 is F1707);
+ Expect.isTrue(confuse(f1707) is F1707);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1707;
+ // The static function f1707 sets `T` to `int`.
+ if (!tIsBool) {
+ x1707 = f1707 as dynamic;
+ l1707 = f1707 as dynamic;
+ x1707 = confuse(f1707);
+ l1707 = confuse(f1707);
+ }
+
+ Expect.isTrue(m1707 is F1707);
+ Expect.isTrue(m1707 is Function(int x1, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1707) is F1707);
+ // In checked mode, verifies the type.
+ x1707 = m1707;
+ l1707 = m1707;
+ x1707 = confuse(m1707);
+ l1707 = confuse(m1707);
+ if (!tIsBool) {
+ Expect.isTrue(f1707 is F1707<int>);
+ Expect.isFalse(f1707 is F1707<bool>);
+ Expect.isTrue(confuse(f1707) is F1707<int>);
+ Expect.isFalse(confuse(f1707) is F1707<bool>);
+ Expect.equals(tIsDynamic, m1707 is F1707<bool>);
+ Expect.equals(tIsDynamic, confuse(m1707) is F1707<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1707 = (f1707 as dynamic); });
+ Expect.throws(() { x1707 = confuse(f1707); });
+ Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1707;
+ Expect.throws(() { l1707 = (f1707 as dynamic); });
+ Expect.throws(() { l1707 = confuse(f1707); });
+ }
+ Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1707 = m1707;
+ // In checked mode, verifies the type.
+ x1707 = m1707;
+ x1707 = confuse(m1707);
+ }
+ }
+
+ void testF1807() {
+ // Function Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1807 is F1807);
+ Expect.isTrue(confuse(f1807) is F1807);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<A> x) Function<B extends core.int>(int x) l1807;
+ // The static function f1807 sets `T` to `int`.
+ if (!tIsBool) {
+ x1807 = f1807 as dynamic;
+ l1807 = f1807 as dynamic;
+ x1807 = confuse(f1807);
+ l1807 = confuse(f1807);
+ }
+
+ Expect.isTrue(m1807 is F1807);
+ Expect.isTrue(m1807 is Function Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1807) is F1807);
+ // In checked mode, verifies the type.
+ x1807 = m1807;
+ l1807 = m1807;
+ x1807 = confuse(m1807);
+ l1807 = confuse(m1807);
+
+ }
+
+ void testF1907() {
+ // Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1907 is F1907);
+ Expect.isTrue(confuse(f1907) is F1907);
+ // In checked mode, verifies the type.
+ Function<A>(int x) Function<B extends core.int>(int x) l1907;
+ // The static function f1907 sets `T` to `int`.
+ if (!tIsBool) {
+ x1907 = f1907 as dynamic;
+ l1907 = f1907 as dynamic;
+ x1907 = confuse(f1907);
+ l1907 = confuse(f1907);
+ }
+
+ Expect.isTrue(m1907 is F1907);
+ Expect.isTrue(m1907 is Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1907) is F1907);
+ // In checked mode, verifies the type.
+ x1907 = m1907;
+ l1907 = m1907;
+ x1907 = confuse(m1907);
+ l1907 = confuse(m1907);
+
+ }
+
+ void testF2007() {
+ // core.List<core.int> Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2007 is F2007);
+ Expect.isTrue(confuse(f2007) is F2007);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(B x) Function<B extends core.int>(int x) l2007;
+ // The static function f2007 sets `T` to `int`.
+ if (!tIsBool) {
+ x2007 = f2007 as dynamic;
+ l2007 = f2007 as dynamic;
+ x2007 = confuse(f2007);
+ l2007 = confuse(f2007);
+ }
+
+ Expect.isTrue(m2007 is F2007);
+ Expect.isTrue(m2007 is core.List<core.int> Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2007) is F2007);
+ // In checked mode, verifies the type.
+ x2007 = m2007;
+ l2007 = m2007;
+ x2007 = confuse(m2007);
+ l2007 = confuse(m2007);
+
+ }
+
+
+}
+
+class C8<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function({int x}) x8;
+ Function Function({List<T> x}) x108;
+ core.List<core.int> Function(int x, [core.List<core.int> x2]) x208;
+ Function(int x1, [List<Function> x2]) x308;
+ int Function(int x0, [int x]) Function() x408;
+ int Function([List<Function> x1]) Function() x508;
+ int Function({List<T> x}) Function() x608;
+ Function Function(int y, {Function x}) Function() x708;
+ Function Function(int x0, [List<T> x]) Function() x808;
+ List<Function> Function(Function x0) Function() x908;
+ List<Function> Function(int x, [core.List<core.int> x2]) Function() x1008;
+ core.List<core.int> Function(int x0, {int x}) Function() x1108;
+ core.List<core.int> Function([core.List<core.int> x]) Function() x1208;
+ List<T> Function(int y, [int x]) Function() x1308;
+ List<T> Function(int x1, [List<Function> x2]) Function() x1408;
+ List<T> Function(int x0, {List<T> x}) Function() x1508;
+ Function(List<Function> x) Function() x1608;
+ Function(int y, [List<T> x]) Function() x1708;
+ List<Function> Function<A>(int x) Function() x1808;
+ Function<A>(Function x) Function() x1908;
+ List<T> Function(B x) Function<B extends core.int>() x2008;
+
+
+ C8({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m8({int x}) => null;
+ Function m108({List<T> x}) => null;
+ core.List<core.int> m208(int x, [core.List<core.int> x0]) => null;
+ m308(int x0, [List<Function> x1]) => null;
+ int Function(int x0, [int x]) m408() => null;
+ int Function([List<Function> x0]) m508() => null;
+ int Function({List<T> x}) m608() => null;
+ Function Function(int y, {Function x}) m708() => null;
+ Function Function(int x0, [List<T> x]) m808() => null;
+ List<Function> Function(Function x0) m908() => null;
+ List<Function> Function(int x, [core.List<core.int> x0]) m1008() => null;
+ core.List<core.int> Function(int x0, {int x}) m1108() => null;
+ core.List<core.int> Function([core.List<core.int> x]) m1208() => null;
+ List<T> Function(int y, [int x]) m1308() => null;
+ List<T> Function(int x0, [List<Function> x1]) m1408() => null;
+ List<T> Function(int x0, {List<T> x}) m1508() => null;
+ Function(List<Function> x) m1608() => null;
+ Function(int y, [List<T> x]) m1708() => null;
+ List<Function> Function<A>(int x) m1808() => null;
+ Function<A>(Function x) m1908() => null;
+ List<T> Function(B x) m2008<B extends core.int>() => null;
+
+
+ runTests() {
+ testF8();
+ testF108();
+ testF208();
+ testF308();
+ testF408();
+ testF508();
+ testF608();
+ testF708();
+ testF808();
+ testF908();
+ testF1008();
+ testF1108();
+ testF1208();
+ testF1308();
+ testF1408();
+ testF1508();
+ testF1608();
+ testF1708();
+ testF1808();
+ testF1908();
+ testF2008();
+ }
+
+ void testF8() {
+ // int Function({int x})
+ Expect.isTrue(f8 is F8);
+ Expect.isTrue(confuse(f8) is F8);
+ // In checked mode, verifies the type.
+ int Function({int x}) l8;
+ // The static function f8 sets `T` to `int`.
+ if (!tIsBool) {
+ x8 = f8 as dynamic;
+ l8 = f8 as dynamic;
+ x8 = confuse(f8);
+ l8 = confuse(f8);
+ }
+
+ Expect.isTrue(m8 is F8);
+ Expect.isTrue(m8 is int 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);
+
+ }
+
+ void testF108() {
+ // Function Function({List<T> x})
+ Expect.isTrue(f108 is F108);
+ Expect.isTrue(confuse(f108) is F108);
+ // In checked mode, verifies the type.
+ Function Function({List<T> x}) l108;
+ // The static function f108 sets `T` to `int`.
+ if (!tIsBool) {
+ x108 = f108 as dynamic;
+ l108 = f108 as dynamic;
+ x108 = confuse(f108);
+ l108 = confuse(f108);
+ }
+
+ Expect.isTrue(m108 is F108);
+ Expect.isTrue(m108 is Function Function({List<T> x}));
+ Expect.isTrue(confuse(m108) is F108);
+ // In checked mode, verifies the type.
+ x108 = m108;
+ l108 = m108;
+ x108 = confuse(m108);
+ l108 = confuse(m108);
+ if (!tIsBool) {
+ Expect.isTrue(f108 is F108<int>);
+ Expect.isFalse(f108 is F108<bool>);
+ Expect.isTrue(confuse(f108) is F108<int>);
+ Expect.isFalse(confuse(f108) is F108<bool>);
+ Expect.equals(tIsDynamic, m108 is F108<bool>);
+ Expect.equals(tIsDynamic, confuse(m108) is F108<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x108 = (f108 as dynamic); });
+ Expect.throws(() { x108 = confuse(f108); });
+ Function Function({List<T> x}) l108;
+ Expect.throws(() { l108 = (f108 as dynamic); });
+ Expect.throws(() { l108 = confuse(f108); });
+ }
+ Function Function({List<T> x}) l108 = m108;
+ // In checked mode, verifies the type.
+ x108 = m108;
+ x108 = confuse(m108);
+ }
+ }
+
+ void testF208() {
+ // core.List<core.int> Function(int x, [core.List<core.int> x2])
+ Expect.isTrue(f208 is F208);
+ Expect.isTrue(confuse(f208) is F208);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [core.List<core.int> x2]) l208;
+ // The static function f208 sets `T` to `int`.
+ if (!tIsBool) {
+ x208 = f208 as dynamic;
+ l208 = f208 as dynamic;
+ x208 = confuse(f208);
+ l208 = confuse(f208);
+ }
+
+ Expect.isTrue(m208 is F208);
+ Expect.isTrue(m208 is core.List<core.int> Function(int x, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m208) is F208);
+ // In checked mode, verifies the type.
+ x208 = m208;
+ l208 = m208;
+ x208 = confuse(m208);
+ l208 = confuse(m208);
+
+ }
+
+ void testF308() {
+ // Function(int x1, [List<Function> x2])
+ Expect.isTrue(f308 is F308);
+ Expect.isTrue(confuse(f308) is F308);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<Function> x2]) l308;
+ // The static function f308 sets `T` to `int`.
+ if (!tIsBool) {
+ x308 = f308 as dynamic;
+ l308 = f308 as dynamic;
+ x308 = confuse(f308);
+ l308 = confuse(f308);
+ }
+
+ Expect.isTrue(m308 is F308);
+ Expect.isTrue(m308 is Function(int x1, [List<Function> x2]));
+ Expect.isTrue(confuse(m308) is F308);
+ // In checked mode, verifies the type.
+ x308 = m308;
+ l308 = m308;
+ x308 = confuse(m308);
+ l308 = confuse(m308);
+
+ }
+
+ void testF408() {
+ // int Function(int x0, [int x]) Function()
+ Expect.isTrue(f408 is F408);
+ Expect.isTrue(confuse(f408) is F408);
+ // In checked mode, verifies the type.
+ int Function(int x0, [int x]) Function() l408;
+ // The static function f408 sets `T` to `int`.
+ if (!tIsBool) {
+ x408 = f408 as dynamic;
+ l408 = f408 as dynamic;
+ x408 = confuse(f408);
+ l408 = confuse(f408);
+ }
+
+ Expect.isTrue(m408 is F408);
+ Expect.isTrue(m408 is int Function(int x0, [int x]) Function());
+ Expect.isTrue(confuse(m408) is F408);
+ // In checked mode, verifies the type.
+ x408 = m408;
+ l408 = m408;
+ x408 = confuse(m408);
+ l408 = confuse(m408);
+
+ }
+
+ void testF508() {
+ // int Function([List<Function> x1]) Function()
+ Expect.isTrue(f508 is F508);
+ Expect.isTrue(confuse(f508) is F508);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x1]) Function() l508;
+ // The static function f508 sets `T` to `int`.
+ if (!tIsBool) {
+ x508 = f508 as dynamic;
+ l508 = f508 as dynamic;
+ x508 = confuse(f508);
+ l508 = confuse(f508);
+ }
+
+ Expect.isTrue(m508 is F508);
+ Expect.isTrue(m508 is int Function([List<Function> x1]) Function());
+ Expect.isTrue(confuse(m508) is F508);
+ // In checked mode, verifies the type.
+ x508 = m508;
+ l508 = m508;
+ x508 = confuse(m508);
+ l508 = confuse(m508);
+
+ }
+
+ void testF608() {
+ // int Function({List<T> x}) Function()
+ Expect.isTrue(f608 is F608);
+ Expect.isTrue(confuse(f608) is F608);
+ // In checked mode, verifies the type.
+ int Function({List<T> x}) Function() l608;
+ // The static function f608 sets `T` to `int`.
+ if (!tIsBool) {
+ x608 = f608 as dynamic;
+ l608 = f608 as dynamic;
+ x608 = confuse(f608);
+ l608 = confuse(f608);
+ }
+
+ Expect.isTrue(m608 is F608);
+ Expect.isTrue(m608 is int Function({List<T> x}) Function());
+ Expect.isTrue(confuse(m608) is F608);
+ // In checked mode, verifies the type.
+ x608 = m608;
+ l608 = m608;
+ x608 = confuse(m608);
+ l608 = confuse(m608);
+ if (!tIsBool) {
+ Expect.isTrue(f608 is F608<int>);
+ Expect.isFalse(f608 is F608<bool>);
+ Expect.isTrue(confuse(f608) is F608<int>);
+ Expect.isFalse(confuse(f608) is F608<bool>);
+ Expect.equals(tIsDynamic, m608 is F608<bool>);
+ Expect.equals(tIsDynamic, confuse(m608) is F608<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x608 = (f608 as dynamic); });
+ Expect.throws(() { x608 = confuse(f608); });
+ int Function({List<T> x}) Function() l608;
+ Expect.throws(() { l608 = (f608 as dynamic); });
+ Expect.throws(() { l608 = confuse(f608); });
+ }
+ int Function({List<T> x}) Function() l608 = m608;
+ // In checked mode, verifies the type.
+ x608 = m608;
+ x608 = confuse(m608);
+ }
+ }
+
+ void testF708() {
+ // Function Function(int y, {Function x}) Function()
+ Expect.isTrue(f708 is F708);
+ Expect.isTrue(confuse(f708) is F708);
+ // In checked mode, verifies the type.
+ Function Function(int y, {Function x}) Function() l708;
+ // The static function f708 sets `T` to `int`.
+ if (!tIsBool) {
+ x708 = f708 as dynamic;
+ l708 = f708 as dynamic;
+ x708 = confuse(f708);
+ l708 = confuse(f708);
+ }
+
+ Expect.isTrue(m708 is F708);
+ Expect.isTrue(m708 is Function Function(int y, {Function x}) Function());
+ Expect.isTrue(confuse(m708) is F708);
+ // In checked mode, verifies the type.
+ x708 = m708;
+ l708 = m708;
+ x708 = confuse(m708);
+ l708 = confuse(m708);
+
+ }
+
+ void testF808() {
+ // Function Function(int x0, [List<T> x]) Function()
+ Expect.isTrue(f808 is F808);
+ Expect.isTrue(confuse(f808) is F808);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [List<T> x]) Function() l808;
+ // The static function f808 sets `T` to `int`.
+ if (!tIsBool) {
+ x808 = f808 as dynamic;
+ l808 = f808 as dynamic;
+ x808 = confuse(f808);
+ l808 = confuse(f808);
+ }
+
+ Expect.isTrue(m808 is F808);
+ Expect.isTrue(m808 is Function Function(int x0, [List<T> x]) Function());
+ Expect.isTrue(confuse(m808) is F808);
+ // In checked mode, verifies the type.
+ x808 = m808;
+ l808 = m808;
+ x808 = confuse(m808);
+ l808 = confuse(m808);
+ if (!tIsBool) {
+ Expect.isTrue(f808 is F808<int>);
+ Expect.isFalse(f808 is F808<bool>);
+ Expect.isTrue(confuse(f808) is F808<int>);
+ Expect.isFalse(confuse(f808) is F808<bool>);
+ Expect.equals(tIsDynamic, m808 is F808<bool>);
+ Expect.equals(tIsDynamic, confuse(m808) is F808<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x808 = (f808 as dynamic); });
+ Expect.throws(() { x808 = confuse(f808); });
+ Function Function(int x0, [List<T> x]) Function() l808;
+ Expect.throws(() { l808 = (f808 as dynamic); });
+ Expect.throws(() { l808 = confuse(f808); });
+ }
+ Function Function(int x0, [List<T> x]) Function() l808 = m808;
+ // In checked mode, verifies the type.
+ x808 = m808;
+ x808 = confuse(m808);
+ }
+ }
+
+ void testF908() {
+ // List<Function> Function(Function x0) Function()
+ Expect.isTrue(f908 is F908);
+ Expect.isTrue(confuse(f908) is F908);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x0) Function() l908;
+ // The static function f908 sets `T` to `int`.
+ if (!tIsBool) {
+ x908 = f908 as dynamic;
+ l908 = f908 as dynamic;
+ x908 = confuse(f908);
+ l908 = confuse(f908);
+ }
+
+ Expect.isTrue(m908 is F908);
+ Expect.isTrue(m908 is List<Function> Function(Function x0) Function());
+ Expect.isTrue(confuse(m908) is F908);
+ // In checked mode, verifies the type.
+ x908 = m908;
+ l908 = m908;
+ x908 = confuse(m908);
+ l908 = confuse(m908);
+
+ }
+
+ void testF1008() {
+ // List<Function> Function(int x, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1008 is F1008);
+ Expect.isTrue(confuse(f1008) is F1008);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [core.List<core.int> x2]) Function() l1008;
+ // The static function f1008 sets `T` to `int`.
+ if (!tIsBool) {
+ x1008 = f1008 as dynamic;
+ l1008 = f1008 as dynamic;
+ x1008 = confuse(f1008);
+ l1008 = confuse(f1008);
+ }
+
+ Expect.isTrue(m1008 is F1008);
+ Expect.isTrue(m1008 is List<Function> Function(int x, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1008) is F1008);
+ // In checked mode, verifies the type.
+ x1008 = m1008;
+ l1008 = m1008;
+ x1008 = confuse(m1008);
+ l1008 = confuse(m1008);
+
+ }
+
+ void testF1108() {
+ // core.List<core.int> Function(int x0, {int x}) Function()
+ Expect.isTrue(f1108 is F1108);
+ Expect.isTrue(confuse(f1108) is F1108);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {int x}) Function() l1108;
+ // The static function f1108 sets `T` to `int`.
+ if (!tIsBool) {
+ x1108 = f1108 as dynamic;
+ l1108 = f1108 as dynamic;
+ x1108 = confuse(f1108);
+ l1108 = confuse(f1108);
+ }
+
+ Expect.isTrue(m1108 is F1108);
+ Expect.isTrue(m1108 is core.List<core.int> Function(int x0, {int x}) Function());
+ Expect.isTrue(confuse(m1108) is F1108);
+ // In checked mode, verifies the type.
+ x1108 = m1108;
+ l1108 = m1108;
+ x1108 = confuse(m1108);
+ l1108 = confuse(m1108);
+
+ }
+
+ void testF1208() {
+ // core.List<core.int> Function([core.List<core.int> x]) Function()
+ Expect.isTrue(f1208 is F1208);
+ Expect.isTrue(confuse(f1208) is F1208);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x]) Function() l1208;
+ // The static function f1208 sets `T` to `int`.
+ if (!tIsBool) {
+ x1208 = f1208 as dynamic;
+ l1208 = f1208 as dynamic;
+ x1208 = confuse(f1208);
+ l1208 = confuse(f1208);
+ }
+
+ Expect.isTrue(m1208 is F1208);
+ Expect.isTrue(m1208 is core.List<core.int> Function([core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1208) is F1208);
+ // In checked mode, verifies the type.
+ x1208 = m1208;
+ l1208 = m1208;
+ x1208 = confuse(m1208);
+ l1208 = confuse(m1208);
+
+ }
+
+ void testF1308() {
+ // List<T> Function(int y, [int x]) Function()
+ Expect.isTrue(f1308 is F1308);
+ Expect.isTrue(confuse(f1308) is F1308);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [int x]) Function() l1308;
+ // The static function f1308 sets `T` to `int`.
+ if (!tIsBool) {
+ x1308 = f1308 as dynamic;
+ l1308 = f1308 as dynamic;
+ x1308 = confuse(f1308);
+ l1308 = confuse(f1308);
+ }
+
+ Expect.isTrue(m1308 is F1308);
+ Expect.isTrue(m1308 is List<T> Function(int y, [int x]) Function());
+ Expect.isTrue(confuse(m1308) is F1308);
+ // In checked mode, verifies the type.
+ x1308 = m1308;
+ l1308 = m1308;
+ x1308 = confuse(m1308);
+ l1308 = confuse(m1308);
+ if (!tIsBool) {
+ Expect.isTrue(f1308 is F1308<int>);
+ Expect.isFalse(f1308 is F1308<bool>);
+ Expect.isTrue(confuse(f1308) is F1308<int>);
+ Expect.isFalse(confuse(f1308) is F1308<bool>);
+ Expect.equals(tIsDynamic, m1308 is F1308<bool>);
+ Expect.equals(tIsDynamic, confuse(m1308) is F1308<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1308 = (f1308 as dynamic); });
+ Expect.throws(() { x1308 = confuse(f1308); });
+ List<T> Function(int y, [int x]) Function() l1308;
+ Expect.throws(() { l1308 = (f1308 as dynamic); });
+ Expect.throws(() { l1308 = confuse(f1308); });
+ }
+ List<T> Function(int y, [int x]) Function() l1308 = m1308;
+ // In checked mode, verifies the type.
+ x1308 = m1308;
+ x1308 = confuse(m1308);
+ }
+ }
+
+ void testF1408() {
+ // List<T> Function(int x1, [List<Function> x2]) Function()
+ Expect.isTrue(f1408 is F1408);
+ Expect.isTrue(confuse(f1408) is F1408);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<Function> x2]) Function() l1408;
+ // The static function f1408 sets `T` to `int`.
+ if (!tIsBool) {
+ x1408 = f1408 as dynamic;
+ l1408 = f1408 as dynamic;
+ x1408 = confuse(f1408);
+ l1408 = confuse(f1408);
+ }
+
+ Expect.isTrue(m1408 is F1408);
+ Expect.isTrue(m1408 is List<T> Function(int x1, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m1408) is F1408);
+ // In checked mode, verifies the type.
+ x1408 = m1408;
+ l1408 = m1408;
+ x1408 = confuse(m1408);
+ l1408 = confuse(m1408);
+ if (!tIsBool) {
+ Expect.isTrue(f1408 is F1408<int>);
+ Expect.isFalse(f1408 is F1408<bool>);
+ Expect.isTrue(confuse(f1408) is F1408<int>);
+ Expect.isFalse(confuse(f1408) is F1408<bool>);
+ Expect.equals(tIsDynamic, m1408 is F1408<bool>);
+ Expect.equals(tIsDynamic, confuse(m1408) is F1408<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1408 = (f1408 as dynamic); });
+ Expect.throws(() { x1408 = confuse(f1408); });
+ List<T> Function(int x1, [List<Function> x2]) Function() l1408;
+ Expect.throws(() { l1408 = (f1408 as dynamic); });
+ Expect.throws(() { l1408 = confuse(f1408); });
+ }
+ List<T> Function(int x1, [List<Function> x2]) Function() l1408 = m1408;
+ // In checked mode, verifies the type.
+ x1408 = m1408;
+ x1408 = confuse(m1408);
+ }
+ }
+
+ void testF1508() {
+ // List<T> Function(int x0, {List<T> x}) Function()
+ Expect.isTrue(f1508 is F1508);
+ Expect.isTrue(confuse(f1508) is F1508);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {List<T> x}) Function() l1508;
+ // The static function f1508 sets `T` to `int`.
+ if (!tIsBool) {
+ x1508 = f1508 as dynamic;
+ l1508 = f1508 as dynamic;
+ x1508 = confuse(f1508);
+ l1508 = confuse(f1508);
+ }
+
+ Expect.isTrue(m1508 is F1508);
+ Expect.isTrue(m1508 is List<T> Function(int x0, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1508) is F1508);
+ // In checked mode, verifies the type.
+ x1508 = m1508;
+ l1508 = m1508;
+ x1508 = confuse(m1508);
+ l1508 = confuse(m1508);
+ if (!tIsBool) {
+ Expect.isTrue(f1508 is F1508<int>);
+ Expect.isFalse(f1508 is F1508<bool>);
+ Expect.isTrue(confuse(f1508) is F1508<int>);
+ Expect.isFalse(confuse(f1508) is F1508<bool>);
+ Expect.equals(tIsDynamic, m1508 is F1508<bool>);
+ Expect.equals(tIsDynamic, confuse(m1508) is F1508<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1508 = (f1508 as dynamic); });
+ Expect.throws(() { x1508 = confuse(f1508); });
+ List<T> Function(int x0, {List<T> x}) Function() l1508;
+ Expect.throws(() { l1508 = (f1508 as dynamic); });
+ Expect.throws(() { l1508 = confuse(f1508); });
+ }
+ List<T> Function(int x0, {List<T> x}) Function() l1508 = m1508;
+ // In checked mode, verifies the type.
+ x1508 = m1508;
+ x1508 = confuse(m1508);
+ }
+ }
+
+ void testF1608() {
+ // Function(List<Function> x) Function()
+ Expect.isTrue(f1608 is F1608);
+ Expect.isTrue(confuse(f1608) is F1608);
+ // In checked mode, verifies the type.
+ Function(List<Function> x) Function() l1608;
+ // The static function f1608 sets `T` to `int`.
+ if (!tIsBool) {
+ x1608 = f1608 as dynamic;
+ l1608 = f1608 as dynamic;
+ x1608 = confuse(f1608);
+ l1608 = confuse(f1608);
+ }
+
+ Expect.isTrue(m1608 is F1608);
+ Expect.isTrue(m1608 is Function(List<Function> x) Function());
+ Expect.isTrue(confuse(m1608) is F1608);
+ // In checked mode, verifies the type.
+ x1608 = m1608;
+ l1608 = m1608;
+ x1608 = confuse(m1608);
+ l1608 = confuse(m1608);
+
+ }
+
+ void testF1708() {
+ // Function(int y, [List<T> x]) Function()
+ Expect.isTrue(f1708 is F1708);
+ Expect.isTrue(confuse(f1708) is F1708);
+ // In checked mode, verifies the type.
+ Function(int y, [List<T> x]) Function() l1708;
+ // The static function f1708 sets `T` to `int`.
+ if (!tIsBool) {
+ x1708 = f1708 as dynamic;
+ l1708 = f1708 as dynamic;
+ x1708 = confuse(f1708);
+ l1708 = confuse(f1708);
+ }
+
+ Expect.isTrue(m1708 is F1708);
+ Expect.isTrue(m1708 is Function(int y, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1708) is F1708);
+ // In checked mode, verifies the type.
+ x1708 = m1708;
+ l1708 = m1708;
+ x1708 = confuse(m1708);
+ l1708 = confuse(m1708);
+ if (!tIsBool) {
+ Expect.isTrue(f1708 is F1708<int>);
+ Expect.isFalse(f1708 is F1708<bool>);
+ Expect.isTrue(confuse(f1708) is F1708<int>);
+ Expect.isFalse(confuse(f1708) is F1708<bool>);
+ Expect.equals(tIsDynamic, m1708 is F1708<bool>);
+ Expect.equals(tIsDynamic, confuse(m1708) is F1708<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1708 = (f1708 as dynamic); });
+ Expect.throws(() { x1708 = confuse(f1708); });
+ Function(int y, [List<T> x]) Function() l1708;
+ Expect.throws(() { l1708 = (f1708 as dynamic); });
+ Expect.throws(() { l1708 = confuse(f1708); });
+ }
+ Function(int y, [List<T> x]) Function() l1708 = m1708;
+ // In checked mode, verifies the type.
+ x1708 = m1708;
+ x1708 = confuse(m1708);
+ }
+ }
+
+ void testF1808() {
+ // List<Function> Function<A>(int x) Function()
+ Expect.isTrue(f1808 is F1808);
+ Expect.isTrue(confuse(f1808) is F1808);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(int x) Function() l1808;
+ // The static function f1808 sets `T` to `int`.
+ if (!tIsBool) {
+ x1808 = f1808 as dynamic;
+ l1808 = f1808 as dynamic;
+ x1808 = confuse(f1808);
+ l1808 = confuse(f1808);
+ }
+
+ Expect.isTrue(m1808 is F1808);
+ Expect.isTrue(m1808 is List<Function> Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1808) is F1808);
+ // In checked mode, verifies the type.
+ x1808 = m1808;
+ l1808 = m1808;
+ x1808 = confuse(m1808);
+ l1808 = confuse(m1808);
+
+ }
+
+ void testF1908() {
+ // Function<A>(Function x) Function()
+ Expect.isTrue(f1908 is F1908);
+ Expect.isTrue(confuse(f1908) is F1908);
+ // In checked mode, verifies the type.
+ Function<A>(Function x) Function() l1908;
+ // The static function f1908 sets `T` to `int`.
+ if (!tIsBool) {
+ x1908 = f1908 as dynamic;
+ l1908 = f1908 as dynamic;
+ x1908 = confuse(f1908);
+ l1908 = confuse(f1908);
+ }
+
+ Expect.isTrue(m1908 is F1908);
+ Expect.isTrue(m1908 is Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1908) is F1908);
+ // In checked mode, verifies the type.
+ x1908 = m1908;
+ l1908 = m1908;
+ x1908 = confuse(m1908);
+ l1908 = confuse(m1908);
+
+ }
+
+ void testF2008() {
+ // List<T> Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2008 is F2008);
+ Expect.isTrue(confuse(f2008) is F2008);
+ // In checked mode, verifies the type.
+ List<T> Function(B x) Function<B extends core.int>() l2008;
+ // The static function f2008 sets `T` to `int`.
+ if (!tIsBool) {
+ x2008 = f2008 as dynamic;
+ l2008 = f2008 as dynamic;
+ x2008 = confuse(f2008);
+ l2008 = confuse(f2008);
+ }
+
+ Expect.isTrue(m2008 is F2008);
+ Expect.isTrue(m2008 is List<T> Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2008) is F2008);
+ // In checked mode, verifies the type.
+ x2008 = m2008;
+ l2008 = m2008;
+ x2008 = confuse(m2008);
+ l2008 = confuse(m2008);
+ if (!tIsBool) {
+ Expect.isTrue(f2008 is F2008<int>);
+ Expect.isFalse(f2008 is F2008<bool>);
+ Expect.isTrue(confuse(f2008) is F2008<int>);
+ Expect.isFalse(confuse(f2008) is F2008<bool>);
+ Expect.equals(tIsDynamic, m2008 is F2008<bool>);
+ Expect.equals(tIsDynamic, confuse(m2008) is F2008<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x2008 = (f2008 as dynamic); });
+ Expect.throws(() { x2008 = confuse(f2008); });
+ List<T> Function(B x) Function<B extends core.int>() l2008;
+ Expect.throws(() { l2008 = (f2008 as dynamic); });
+ Expect.throws(() { l2008 = confuse(f2008); });
+ }
+ List<T> Function(B x) Function<B extends core.int>() l2008 = m2008;
+ // In checked mode, verifies the type.
+ x2008 = m2008;
+ x2008 = confuse(m2008);
+ }
+ }
+
+
+}
+
+class C9<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, {int x}) x9;
+ Function Function(int x0, {List<T> x}) x109;
+ core.List<core.int> Function({core.List<core.int> x}) x209;
+ Function(int x, [List<Function> x2]) x309;
+ int Function(int x1, [int x]) Function(int x) x409;
+ int Function([List<Function> x1]) Function(int x) x509;
+ int Function({List<T> x}) Function(int x) x609;
+ Function Function(int y, {Function x}) Function(int x) x709;
+ Function Function(int x1, [List<T> x]) Function(int x) x809;
+ List<Function> Function(Function x1) Function(int x) x909;
+ List<Function> Function(int x, [core.List<core.int> x1]) Function(int x) x1009;
+ core.List<core.int> Function(int x1, {int x}) Function(int x) x1109;
+ core.List<core.int> Function([core.List<core.int> x]) Function(int x) x1209;
+ List<T> Function(int y, [int x]) Function(int x) x1309;
+ List<T> Function(int x2, [List<Function> x3]) Function(int x) x1409;
+ List<T> Function(int x1, {List<T> x}) Function(int x) x1509;
+ Function(List<Function> x) Function(int x) x1609;
+ Function(int y, [List<T> x]) Function(int x) x1709;
+ List<Function> Function<A>(int x) Function(int x) x1809;
+ Function<A>(Function x) Function(int x) x1909;
+ List<T> Function(B x) Function<B extends core.int>(int x) x2009;
+
+
+ C9({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m9(int x0, {int x}) => null;
+ Function m109(int x0, {List<T> x}) => null;
+ core.List<core.int> m209({core.List<core.int> x}) => null;
+ m309(int x, [List<Function> x0]) => null;
+ int Function(int x0, [int x]) m409(int x) => null;
+ int Function([List<Function> x0]) m509(int x) => null;
+ int Function({List<T> x}) m609(int x) => null;
+ Function Function(int y, {Function x}) m709(int x) => null;
+ Function Function(int x0, [List<T> x]) m809(int x) => null;
+ List<Function> Function(Function x0) m909(int x) => null;
+ List<Function> Function(int x, [core.List<core.int> x0]) m1009(int x) => null;
+ core.List<core.int> Function(int x0, {int x}) m1109(int x) => null;
+ core.List<core.int> Function([core.List<core.int> x]) m1209(int x) => null;
+ List<T> Function(int y, [int x]) m1309(int x) => null;
+ List<T> Function(int x0, [List<Function> x1]) m1409(int x) => null;
+ List<T> Function(int x0, {List<T> x}) m1509(int x) => null;
+ Function(List<Function> x) m1609(int x) => null;
+ Function(int y, [List<T> x]) m1709(int x) => null;
+ List<Function> Function<A>(int x) m1809(int x) => null;
+ Function<A>(Function x) m1909(int x) => null;
+ List<T> Function(B x) m2009<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF9();
+ testF109();
+ testF209();
+ testF309();
+ testF409();
+ testF509();
+ testF609();
+ testF709();
+ testF809();
+ testF909();
+ testF1009();
+ testF1109();
+ testF1209();
+ testF1309();
+ testF1409();
+ testF1509();
+ testF1609();
+ testF1709();
+ testF1809();
+ testF1909();
+ testF2009();
+ }
+
+ void testF9() {
+ // int Function(int x0, {int x})
+ Expect.isTrue(f9 is F9);
+ Expect.isTrue(confuse(f9) is F9);
+ // In checked mode, verifies the type.
+ int Function(int x0, {int x}) l9;
+ // The static function f9 sets `T` to `int`.
+ if (!tIsBool) {
+ x9 = f9 as dynamic;
+ l9 = f9 as dynamic;
+ x9 = confuse(f9);
+ l9 = confuse(f9);
+ }
+
+ Expect.isTrue(m9 is F9);
+ Expect.isTrue(m9 is int Function(int x0, {int x}));
+ Expect.isTrue(confuse(m9) is F9);
+ // In checked mode, verifies the type.
+ x9 = m9;
+ l9 = m9;
+ x9 = confuse(m9);
+ l9 = confuse(m9);
+
+ }
+
+ void testF109() {
+ // Function Function(int x0, {List<T> x})
+ Expect.isTrue(f109 is F109);
+ Expect.isTrue(confuse(f109) is F109);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {List<T> x}) l109;
+ // The static function f109 sets `T` to `int`.
+ if (!tIsBool) {
+ x109 = f109 as dynamic;
+ l109 = f109 as dynamic;
+ x109 = confuse(f109);
+ l109 = confuse(f109);
+ }
+
+ Expect.isTrue(m109 is F109);
+ Expect.isTrue(m109 is Function Function(int x0, {List<T> x}));
+ Expect.isTrue(confuse(m109) is F109);
+ // In checked mode, verifies the type.
+ x109 = m109;
+ l109 = m109;
+ x109 = confuse(m109);
+ l109 = confuse(m109);
+ if (!tIsBool) {
+ Expect.isTrue(f109 is F109<int>);
+ Expect.isFalse(f109 is F109<bool>);
+ Expect.isTrue(confuse(f109) is F109<int>);
+ Expect.isFalse(confuse(f109) is F109<bool>);
+ Expect.equals(tIsDynamic, m109 is F109<bool>);
+ Expect.equals(tIsDynamic, confuse(m109) is F109<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x109 = (f109 as dynamic); });
+ Expect.throws(() { x109 = confuse(f109); });
+ Function Function(int x0, {List<T> x}) l109;
+ Expect.throws(() { l109 = (f109 as dynamic); });
+ Expect.throws(() { l109 = confuse(f109); });
+ }
+ Function Function(int x0, {List<T> x}) l109 = m109;
+ // In checked mode, verifies the type.
+ x109 = m109;
+ x109 = confuse(m109);
+ }
+ }
+
+ void testF209() {
+ // core.List<core.int> Function({core.List<core.int> x})
+ Expect.isTrue(f209 is F209);
+ Expect.isTrue(confuse(f209) is F209);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({core.List<core.int> x}) l209;
+ // The static function f209 sets `T` to `int`.
+ if (!tIsBool) {
+ x209 = f209 as dynamic;
+ l209 = f209 as dynamic;
+ x209 = confuse(f209);
+ l209 = confuse(f209);
+ }
+
+ Expect.isTrue(m209 is F209);
+ Expect.isTrue(m209 is core.List<core.int> Function({core.List<core.int> x}));
+ Expect.isTrue(confuse(m209) is F209);
+ // In checked mode, verifies the type.
+ x209 = m209;
+ l209 = m209;
+ x209 = confuse(m209);
+ l209 = confuse(m209);
+
+ }
+
+ void testF309() {
+ // Function(int x, [List<Function> x2])
+ Expect.isTrue(f309 is F309);
+ Expect.isTrue(confuse(f309) is F309);
+ // In checked mode, verifies the type.
+ Function(int x, [List<Function> x2]) l309;
+ // The static function f309 sets `T` to `int`.
+ if (!tIsBool) {
+ x309 = f309 as dynamic;
+ l309 = f309 as dynamic;
+ x309 = confuse(f309);
+ l309 = confuse(f309);
+ }
+
+ Expect.isTrue(m309 is F309);
+ Expect.isTrue(m309 is Function(int x, [List<Function> x2]));
+ Expect.isTrue(confuse(m309) is F309);
+ // In checked mode, verifies the type.
+ x309 = m309;
+ l309 = m309;
+ x309 = confuse(m309);
+ l309 = confuse(m309);
+
+ }
+
+ void testF409() {
+ // int Function(int x1, [int x]) Function(int x)
+ Expect.isTrue(f409 is F409);
+ Expect.isTrue(confuse(f409) is F409);
+ // In checked mode, verifies the type.
+ int Function(int x1, [int x]) Function(int x) l409;
+ // The static function f409 sets `T` to `int`.
+ if (!tIsBool) {
+ x409 = f409 as dynamic;
+ l409 = f409 as dynamic;
+ x409 = confuse(f409);
+ l409 = confuse(f409);
+ }
+
+ Expect.isTrue(m409 is F409);
+ Expect.isTrue(m409 is int Function(int x1, [int x]) Function(int x));
+ Expect.isTrue(confuse(m409) is F409);
+ // In checked mode, verifies the type.
+ x409 = m409;
+ l409 = m409;
+ x409 = confuse(m409);
+ l409 = confuse(m409);
+
+ }
+
+ void testF509() {
+ // int Function([List<Function> x1]) Function(int x)
+ Expect.isTrue(f509 is F509);
+ Expect.isTrue(confuse(f509) is F509);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x1]) Function(int x) l509;
+ // The static function f509 sets `T` to `int`.
+ if (!tIsBool) {
+ x509 = f509 as dynamic;
+ l509 = f509 as dynamic;
+ x509 = confuse(f509);
+ l509 = confuse(f509);
+ }
+
+ Expect.isTrue(m509 is F509);
+ Expect.isTrue(m509 is int Function([List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m509) is F509);
+ // In checked mode, verifies the type.
+ x509 = m509;
+ l509 = m509;
+ x509 = confuse(m509);
+ l509 = confuse(m509);
+
+ }
+
+ void testF609() {
+ // int Function({List<T> x}) Function(int x)
+ Expect.isTrue(f609 is F609);
+ Expect.isTrue(confuse(f609) is F609);
+ // In checked mode, verifies the type.
+ int Function({List<T> x}) Function(int x) l609;
+ // The static function f609 sets `T` to `int`.
+ if (!tIsBool) {
+ x609 = f609 as dynamic;
+ l609 = f609 as dynamic;
+ x609 = confuse(f609);
+ l609 = confuse(f609);
+ }
+
+ Expect.isTrue(m609 is F609);
+ Expect.isTrue(m609 is int Function({List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m609) is F609);
+ // In checked mode, verifies the type.
+ x609 = m609;
+ l609 = m609;
+ x609 = confuse(m609);
+ l609 = confuse(m609);
+ if (!tIsBool) {
+ Expect.isTrue(f609 is F609<int>);
+ Expect.isFalse(f609 is F609<bool>);
+ Expect.isTrue(confuse(f609) is F609<int>);
+ Expect.isFalse(confuse(f609) is F609<bool>);
+ Expect.equals(tIsDynamic, m609 is F609<bool>);
+ Expect.equals(tIsDynamic, confuse(m609) is F609<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x609 = (f609 as dynamic); });
+ Expect.throws(() { x609 = confuse(f609); });
+ int Function({List<T> x}) Function(int x) l609;
+ Expect.throws(() { l609 = (f609 as dynamic); });
+ Expect.throws(() { l609 = confuse(f609); });
+ }
+ int Function({List<T> x}) Function(int x) l609 = m609;
+ // In checked mode, verifies the type.
+ x609 = m609;
+ x609 = confuse(m609);
+ }
+ }
+
+ void testF709() {
+ // Function Function(int y, {Function x}) Function(int x)
+ Expect.isTrue(f709 is F709);
+ Expect.isTrue(confuse(f709) is F709);
+ // In checked mode, verifies the type.
+ Function Function(int y, {Function x}) Function(int x) l709;
+ // The static function f709 sets `T` to `int`.
+ if (!tIsBool) {
+ x709 = f709 as dynamic;
+ l709 = f709 as dynamic;
+ x709 = confuse(f709);
+ l709 = confuse(f709);
+ }
+
+ Expect.isTrue(m709 is F709);
+ Expect.isTrue(m709 is Function Function(int y, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m709) is F709);
+ // In checked mode, verifies the type.
+ x709 = m709;
+ l709 = m709;
+ x709 = confuse(m709);
+ l709 = confuse(m709);
+
+ }
+
+ void testF809() {
+ // Function Function(int x1, [List<T> x]) Function(int x)
+ Expect.isTrue(f809 is F809);
+ Expect.isTrue(confuse(f809) is F809);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<T> x]) Function(int x) l809;
+ // The static function f809 sets `T` to `int`.
+ if (!tIsBool) {
+ x809 = f809 as dynamic;
+ l809 = f809 as dynamic;
+ x809 = confuse(f809);
+ l809 = confuse(f809);
+ }
+
+ Expect.isTrue(m809 is F809);
+ Expect.isTrue(m809 is Function Function(int x1, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m809) is F809);
+ // In checked mode, verifies the type.
+ x809 = m809;
+ l809 = m809;
+ x809 = confuse(m809);
+ l809 = confuse(m809);
+ if (!tIsBool) {
+ Expect.isTrue(f809 is F809<int>);
+ Expect.isFalse(f809 is F809<bool>);
+ Expect.isTrue(confuse(f809) is F809<int>);
+ Expect.isFalse(confuse(f809) is F809<bool>);
+ Expect.equals(tIsDynamic, m809 is F809<bool>);
+ Expect.equals(tIsDynamic, confuse(m809) is F809<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x809 = (f809 as dynamic); });
+ Expect.throws(() { x809 = confuse(f809); });
+ Function Function(int x1, [List<T> x]) Function(int x) l809;
+ Expect.throws(() { l809 = (f809 as dynamic); });
+ Expect.throws(() { l809 = confuse(f809); });
+ }
+ Function Function(int x1, [List<T> x]) Function(int x) l809 = m809;
+ // In checked mode, verifies the type.
+ x809 = m809;
+ x809 = confuse(m809);
+ }
+ }
+
+ void testF909() {
+ // List<Function> Function(Function x1) Function(int x)
+ Expect.isTrue(f909 is F909);
+ Expect.isTrue(confuse(f909) is F909);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x1) Function(int x) l909;
+ // The static function f909 sets `T` to `int`.
+ if (!tIsBool) {
+ x909 = f909 as dynamic;
+ l909 = f909 as dynamic;
+ x909 = confuse(f909);
+ l909 = confuse(f909);
+ }
+
+ Expect.isTrue(m909 is F909);
+ Expect.isTrue(m909 is List<Function> Function(Function x1) Function(int x));
+ Expect.isTrue(confuse(m909) is F909);
+ // In checked mode, verifies the type.
+ x909 = m909;
+ l909 = m909;
+ x909 = confuse(m909);
+ l909 = confuse(m909);
+
+ }
+
+ void testF1009() {
+ // List<Function> Function(int x, [core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1009 is F1009);
+ Expect.isTrue(confuse(f1009) is F1009);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [core.List<core.int> x1]) Function(int x) l1009;
+ // The static function f1009 sets `T` to `int`.
+ if (!tIsBool) {
+ x1009 = f1009 as dynamic;
+ l1009 = f1009 as dynamic;
+ x1009 = confuse(f1009);
+ l1009 = confuse(f1009);
+ }
+
+ Expect.isTrue(m1009 is F1009);
+ Expect.isTrue(m1009 is List<Function> Function(int x, [core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1009) is F1009);
+ // In checked mode, verifies the type.
+ x1009 = m1009;
+ l1009 = m1009;
+ x1009 = confuse(m1009);
+ l1009 = confuse(m1009);
+
+ }
+
+ void testF1109() {
+ // core.List<core.int> Function(int x1, {int x}) Function(int x)
+ Expect.isTrue(f1109 is F1109);
+ Expect.isTrue(confuse(f1109) is F1109);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {int x}) Function(int x) l1109;
+ // The static function f1109 sets `T` to `int`.
+ if (!tIsBool) {
+ x1109 = f1109 as dynamic;
+ l1109 = f1109 as dynamic;
+ x1109 = confuse(f1109);
+ l1109 = confuse(f1109);
+ }
+
+ Expect.isTrue(m1109 is F1109);
+ Expect.isTrue(m1109 is core.List<core.int> Function(int x1, {int x}) Function(int x));
+ Expect.isTrue(confuse(m1109) is F1109);
+ // In checked mode, verifies the type.
+ x1109 = m1109;
+ l1109 = m1109;
+ x1109 = confuse(m1109);
+ l1109 = confuse(m1109);
+
+ }
+
+ void testF1209() {
+ // core.List<core.int> Function([core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1209 is F1209);
+ Expect.isTrue(confuse(f1209) is F1209);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x]) Function(int x) l1209;
+ // The static function f1209 sets `T` to `int`.
+ if (!tIsBool) {
+ x1209 = f1209 as dynamic;
+ l1209 = f1209 as dynamic;
+ x1209 = confuse(f1209);
+ l1209 = confuse(f1209);
+ }
+
+ Expect.isTrue(m1209 is F1209);
+ Expect.isTrue(m1209 is core.List<core.int> Function([core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1209) is F1209);
+ // In checked mode, verifies the type.
+ x1209 = m1209;
+ l1209 = m1209;
+ x1209 = confuse(m1209);
+ l1209 = confuse(m1209);
+
+ }
+
+ void testF1309() {
+ // List<T> Function(int y, [int x]) Function(int x)
+ Expect.isTrue(f1309 is F1309);
+ Expect.isTrue(confuse(f1309) is F1309);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [int x]) Function(int x) l1309;
+ // The static function f1309 sets `T` to `int`.
+ if (!tIsBool) {
+ x1309 = f1309 as dynamic;
+ l1309 = f1309 as dynamic;
+ x1309 = confuse(f1309);
+ l1309 = confuse(f1309);
+ }
+
+ Expect.isTrue(m1309 is F1309);
+ Expect.isTrue(m1309 is List<T> Function(int y, [int x]) Function(int x));
+ Expect.isTrue(confuse(m1309) is F1309);
+ // In checked mode, verifies the type.
+ x1309 = m1309;
+ l1309 = m1309;
+ x1309 = confuse(m1309);
+ l1309 = confuse(m1309);
+ if (!tIsBool) {
+ Expect.isTrue(f1309 is F1309<int>);
+ Expect.isFalse(f1309 is F1309<bool>);
+ Expect.isTrue(confuse(f1309) is F1309<int>);
+ Expect.isFalse(confuse(f1309) is F1309<bool>);
+ Expect.equals(tIsDynamic, m1309 is F1309<bool>);
+ Expect.equals(tIsDynamic, confuse(m1309) is F1309<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1309 = (f1309 as dynamic); });
+ Expect.throws(() { x1309 = confuse(f1309); });
+ List<T> Function(int y, [int x]) Function(int x) l1309;
+ Expect.throws(() { l1309 = (f1309 as dynamic); });
+ Expect.throws(() { l1309 = confuse(f1309); });
+ }
+ List<T> Function(int y, [int x]) Function(int x) l1309 = m1309;
+ // In checked mode, verifies the type.
+ x1309 = m1309;
+ x1309 = confuse(m1309);
+ }
+ }
+
+ void testF1409() {
+ // List<T> Function(int x2, [List<Function> x3]) Function(int x)
+ Expect.isTrue(f1409 is F1409);
+ Expect.isTrue(confuse(f1409) is F1409);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [List<Function> x3]) Function(int x) l1409;
+ // The static function f1409 sets `T` to `int`.
+ if (!tIsBool) {
+ x1409 = f1409 as dynamic;
+ l1409 = f1409 as dynamic;
+ x1409 = confuse(f1409);
+ l1409 = confuse(f1409);
+ }
+
+ Expect.isTrue(m1409 is F1409);
+ Expect.isTrue(m1409 is List<T> Function(int x2, [List<Function> x3]) Function(int x));
+ Expect.isTrue(confuse(m1409) is F1409);
+ // In checked mode, verifies the type.
+ x1409 = m1409;
+ l1409 = m1409;
+ x1409 = confuse(m1409);
+ l1409 = confuse(m1409);
+ if (!tIsBool) {
+ Expect.isTrue(f1409 is F1409<int>);
+ Expect.isFalse(f1409 is F1409<bool>);
+ Expect.isTrue(confuse(f1409) is F1409<int>);
+ Expect.isFalse(confuse(f1409) is F1409<bool>);
+ Expect.equals(tIsDynamic, m1409 is F1409<bool>);
+ Expect.equals(tIsDynamic, confuse(m1409) is F1409<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1409 = (f1409 as dynamic); });
+ Expect.throws(() { x1409 = confuse(f1409); });
+ List<T> Function(int x2, [List<Function> x3]) Function(int x) l1409;
+ Expect.throws(() { l1409 = (f1409 as dynamic); });
+ Expect.throws(() { l1409 = confuse(f1409); });
+ }
+ List<T> Function(int x2, [List<Function> x3]) Function(int x) l1409 = m1409;
+ // In checked mode, verifies the type.
+ x1409 = m1409;
+ x1409 = confuse(m1409);
+ }
+ }
+
+ void testF1509() {
+ // List<T> Function(int x1, {List<T> x}) Function(int x)
+ Expect.isTrue(f1509 is F1509);
+ Expect.isTrue(confuse(f1509) is F1509);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {List<T> x}) Function(int x) l1509;
+ // The static function f1509 sets `T` to `int`.
+ if (!tIsBool) {
+ x1509 = f1509 as dynamic;
+ l1509 = f1509 as dynamic;
+ x1509 = confuse(f1509);
+ l1509 = confuse(f1509);
+ }
+
+ Expect.isTrue(m1509 is F1509);
+ Expect.isTrue(m1509 is List<T> Function(int x1, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1509) is F1509);
+ // In checked mode, verifies the type.
+ x1509 = m1509;
+ l1509 = m1509;
+ x1509 = confuse(m1509);
+ l1509 = confuse(m1509);
+ if (!tIsBool) {
+ Expect.isTrue(f1509 is F1509<int>);
+ Expect.isFalse(f1509 is F1509<bool>);
+ Expect.isTrue(confuse(f1509) is F1509<int>);
+ Expect.isFalse(confuse(f1509) is F1509<bool>);
+ Expect.equals(tIsDynamic, m1509 is F1509<bool>);
+ Expect.equals(tIsDynamic, confuse(m1509) is F1509<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1509 = (f1509 as dynamic); });
+ Expect.throws(() { x1509 = confuse(f1509); });
+ List<T> Function(int x1, {List<T> x}) Function(int x) l1509;
+ Expect.throws(() { l1509 = (f1509 as dynamic); });
+ Expect.throws(() { l1509 = confuse(f1509); });
+ }
+ List<T> Function(int x1, {List<T> x}) Function(int x) l1509 = m1509;
+ // In checked mode, verifies the type.
+ x1509 = m1509;
+ x1509 = confuse(m1509);
+ }
+ }
+
+ void testF1609() {
+ // Function(List<Function> x) Function(int x)
+ Expect.isTrue(f1609 is F1609);
+ Expect.isTrue(confuse(f1609) is F1609);
+ // In checked mode, verifies the type.
+ Function(List<Function> x) Function(int x) l1609;
+ // The static function f1609 sets `T` to `int`.
+ if (!tIsBool) {
+ x1609 = f1609 as dynamic;
+ l1609 = f1609 as dynamic;
+ x1609 = confuse(f1609);
+ l1609 = confuse(f1609);
+ }
+
+ Expect.isTrue(m1609 is F1609);
+ Expect.isTrue(m1609 is Function(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1609) is F1609);
+ // In checked mode, verifies the type.
+ x1609 = m1609;
+ l1609 = m1609;
+ x1609 = confuse(m1609);
+ l1609 = confuse(m1609);
+
+ }
+
+ void testF1709() {
+ // Function(int y, [List<T> x]) Function(int x)
+ Expect.isTrue(f1709 is F1709);
+ Expect.isTrue(confuse(f1709) is F1709);
+ // In checked mode, verifies the type.
+ Function(int y, [List<T> x]) Function(int x) l1709;
+ // The static function f1709 sets `T` to `int`.
+ if (!tIsBool) {
+ x1709 = f1709 as dynamic;
+ l1709 = f1709 as dynamic;
+ x1709 = confuse(f1709);
+ l1709 = confuse(f1709);
+ }
+
+ Expect.isTrue(m1709 is F1709);
+ Expect.isTrue(m1709 is Function(int y, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1709) is F1709);
+ // In checked mode, verifies the type.
+ x1709 = m1709;
+ l1709 = m1709;
+ x1709 = confuse(m1709);
+ l1709 = confuse(m1709);
+ if (!tIsBool) {
+ Expect.isTrue(f1709 is F1709<int>);
+ Expect.isFalse(f1709 is F1709<bool>);
+ Expect.isTrue(confuse(f1709) is F1709<int>);
+ Expect.isFalse(confuse(f1709) is F1709<bool>);
+ Expect.equals(tIsDynamic, m1709 is F1709<bool>);
+ Expect.equals(tIsDynamic, confuse(m1709) is F1709<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1709 = (f1709 as dynamic); });
+ Expect.throws(() { x1709 = confuse(f1709); });
+ Function(int y, [List<T> x]) Function(int x) l1709;
+ Expect.throws(() { l1709 = (f1709 as dynamic); });
+ Expect.throws(() { l1709 = confuse(f1709); });
+ }
+ Function(int y, [List<T> x]) Function(int x) l1709 = m1709;
+ // In checked mode, verifies the type.
+ x1709 = m1709;
+ x1709 = confuse(m1709);
+ }
+ }
+
+ void testF1809() {
+ // List<Function> Function<A>(int x) Function(int x)
+ Expect.isTrue(f1809 is F1809);
+ Expect.isTrue(confuse(f1809) is F1809);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(int x) Function(int x) l1809;
+ // The static function f1809 sets `T` to `int`.
+ if (!tIsBool) {
+ x1809 = f1809 as dynamic;
+ l1809 = f1809 as dynamic;
+ x1809 = confuse(f1809);
+ l1809 = confuse(f1809);
+ }
+
+ Expect.isTrue(m1809 is F1809);
+ Expect.isTrue(m1809 is List<Function> Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1809) is F1809);
+ // In checked mode, verifies the type.
+ x1809 = m1809;
+ l1809 = m1809;
+ x1809 = confuse(m1809);
+ l1809 = confuse(m1809);
+
+ }
+
+ void testF1909() {
+ // Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1909 is F1909);
+ Expect.isTrue(confuse(f1909) is F1909);
+ // In checked mode, verifies the type.
+ Function<A>(Function x) Function(int x) l1909;
+ // The static function f1909 sets `T` to `int`.
+ if (!tIsBool) {
+ x1909 = f1909 as dynamic;
+ l1909 = f1909 as dynamic;
+ x1909 = confuse(f1909);
+ l1909 = confuse(f1909);
+ }
+
+ Expect.isTrue(m1909 is F1909);
+ Expect.isTrue(m1909 is Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1909) is F1909);
+ // In checked mode, verifies the type.
+ x1909 = m1909;
+ l1909 = m1909;
+ x1909 = confuse(m1909);
+ l1909 = confuse(m1909);
+
+ }
+
+ void testF2009() {
+ // List<T> Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2009 is F2009);
+ Expect.isTrue(confuse(f2009) is F2009);
+ // In checked mode, verifies the type.
+ List<T> Function(B x) Function<B extends core.int>(int x) l2009;
+ // The static function f2009 sets `T` to `int`.
+ if (!tIsBool) {
+ x2009 = f2009 as dynamic;
+ l2009 = f2009 as dynamic;
+ x2009 = confuse(f2009);
+ l2009 = confuse(f2009);
+ }
+
+ Expect.isTrue(m2009 is F2009);
+ Expect.isTrue(m2009 is List<T> Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2009) is F2009);
+ // In checked mode, verifies the type.
+ x2009 = m2009;
+ l2009 = m2009;
+ x2009 = confuse(m2009);
+ l2009 = confuse(m2009);
+ if (!tIsBool) {
+ Expect.isTrue(f2009 is F2009<int>);
+ Expect.isFalse(f2009 is F2009<bool>);
+ Expect.isTrue(confuse(f2009) is F2009<int>);
+ Expect.isFalse(confuse(f2009) is F2009<bool>);
+ Expect.equals(tIsDynamic, m2009 is F2009<bool>);
+ Expect.equals(tIsDynamic, confuse(m2009) is F2009<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x2009 = (f2009 as dynamic); });
+ Expect.throws(() { x2009 = confuse(f2009); });
+ List<T> Function(B x) Function<B extends core.int>(int x) l2009;
+ Expect.throws(() { l2009 = (f2009 as dynamic); });
+ Expect.throws(() { l2009 = confuse(f2009); });
+ }
+ List<T> Function(B x) Function<B extends core.int>(int x) l2009 = m2009;
+ // In checked mode, verifies the type.
+ x2009 = m2009;
+ x2009 = confuse(m2009);
+ }
+ }
+
+
+}
+
+class C10<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, {int x}) x10;
+ Function Function(int y, {List<T> x}) x110;
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) x210;
+ Function({List<Function> x}) x310;
+ int Function(int x1, [int x]) Function<B extends core.int>() x410;
+ int Function([List<Function> x1]) Function<B extends core.int>() x510;
+ int Function({List<T> x}) Function<B extends core.int>() x610;
+ Function Function(int y, {Function x}) Function<B extends core.int>() x710;
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>() x810;
+ List<Function> Function(Function x1) Function<B extends core.int>() x910;
+ List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() x1010;
+ core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>() x1110;
+ core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>() x1210;
+ List<T> Function(int y, [int x]) Function<B extends core.int>() x1310;
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>() x1410;
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>() x1510;
+ Function(List<Function> x) Function<B extends core.int>() x1610;
+ Function(int y, [List<T> x]) Function<B extends core.int>() x1710;
+ List<Function> Function<A>(int x) Function<B extends core.int>() x1810;
+ Function<A>(Function x) Function<B extends core.int>() x1910;
+ Function(B x) Function<B extends core.int>() x2010;
+
+
+ C10({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m10(int y, {int x}) => null;
+ Function m110(int y, {List<T> x}) => null;
+ core.List<core.int> m210(int x0, {core.List<core.int> x}) => null;
+ m310({List<Function> x}) => null;
+ int Function(int x0, [int x]) m410<B extends core.int>() => null;
+ int Function([List<Function> x0]) m510<B extends core.int>() => null;
+ int Function({List<T> x}) m610<B extends core.int>() => null;
+ Function Function(int y, {Function x}) m710<B extends core.int>() => null;
+ Function Function(int x0, [List<T> x]) m810<B extends core.int>() => null;
+ List<Function> Function(Function x0) m910<B extends core.int>() => null;
+ List<Function> Function(int x, [core.List<core.int> x0]) m1010<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, {int x}) m1110<B extends core.int>() => null;
+ core.List<core.int> Function([core.List<core.int> x]) m1210<B extends core.int>() => null;
+ List<T> Function(int y, [int x]) m1310<B extends core.int>() => null;
+ List<T> Function(int x0, [List<Function> x1]) m1410<B extends core.int>() => null;
+ List<T> Function(int x0, {List<T> x}) m1510<B extends core.int>() => null;
+ Function(List<Function> x) m1610<B extends core.int>() => null;
+ Function(int y, [List<T> x]) m1710<B extends core.int>() => null;
+ List<Function> Function<A>(int x) m1810<B extends core.int>() => null;
+ Function<A>(Function x) m1910<B extends core.int>() => null;
+ Function(B x) m2010<B extends core.int>() => null;
+
+
+ runTests() {
+ testF10();
+ testF110();
+ testF210();
+ testF310();
+ testF410();
+ testF510();
+ testF610();
+ testF710();
+ testF810();
+ testF910();
+ testF1010();
+ testF1110();
+ testF1210();
+ testF1310();
+ testF1410();
+ testF1510();
+ testF1610();
+ testF1710();
+ testF1810();
+ testF1910();
+ testF2010();
+ }
+
+ void testF10() {
+ // int Function(int y, {int x})
+ Expect.isTrue(f10 is F10);
+ Expect.isTrue(confuse(f10) is F10);
+ // In checked mode, verifies the type.
+ int Function(int y, {int x}) l10;
+ // The static function f10 sets `T` to `int`.
+ if (!tIsBool) {
+ x10 = f10 as dynamic;
+ l10 = f10 as dynamic;
+ x10 = confuse(f10);
+ l10 = confuse(f10);
+ }
+
+ Expect.isTrue(m10 is F10);
+ Expect.isTrue(m10 is int Function(int y, {int x}));
+ Expect.isTrue(confuse(m10) is F10);
+ // In checked mode, verifies the type.
+ x10 = m10;
+ l10 = m10;
+ x10 = confuse(m10);
+ l10 = confuse(m10);
+
+ }
+
+ void testF110() {
+ // Function Function(int y, {List<T> x})
+ Expect.isTrue(f110 is F110);
+ Expect.isTrue(confuse(f110) is F110);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<T> x}) l110;
+ // The static function f110 sets `T` to `int`.
+ if (!tIsBool) {
+ x110 = f110 as dynamic;
+ l110 = f110 as dynamic;
+ x110 = confuse(f110);
+ l110 = confuse(f110);
+ }
+
+ Expect.isTrue(m110 is F110);
+ Expect.isTrue(m110 is Function Function(int y, {List<T> x}));
+ Expect.isTrue(confuse(m110) is F110);
+ // In checked mode, verifies the type.
+ x110 = m110;
+ l110 = m110;
+ x110 = confuse(m110);
+ l110 = confuse(m110);
+ if (!tIsBool) {
+ Expect.isTrue(f110 is F110<int>);
+ Expect.isFalse(f110 is F110<bool>);
+ Expect.isTrue(confuse(f110) is F110<int>);
+ Expect.isFalse(confuse(f110) is F110<bool>);
+ Expect.equals(tIsDynamic, m110 is F110<bool>);
+ Expect.equals(tIsDynamic, confuse(m110) is F110<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x110 = (f110 as dynamic); });
+ Expect.throws(() { x110 = confuse(f110); });
+ Function Function(int y, {List<T> x}) l110;
+ Expect.throws(() { l110 = (f110 as dynamic); });
+ Expect.throws(() { l110 = confuse(f110); });
+ }
+ Function Function(int y, {List<T> x}) l110 = m110;
+ // In checked mode, verifies the type.
+ x110 = m110;
+ x110 = confuse(m110);
+ }
+ }
+
+ void testF210() {
+ // core.List<core.int> Function(int x0, {core.List<core.int> x})
+ Expect.isTrue(f210 is F210);
+ Expect.isTrue(confuse(f210) is F210);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) l210;
+ // The static function f210 sets `T` to `int`.
+ if (!tIsBool) {
+ x210 = f210 as dynamic;
+ l210 = f210 as dynamic;
+ x210 = confuse(f210);
+ l210 = confuse(f210);
+ }
+
+ Expect.isTrue(m210 is F210);
+ Expect.isTrue(m210 is core.List<core.int> Function(int x0, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m210) is F210);
+ // In checked mode, verifies the type.
+ x210 = m210;
+ l210 = m210;
+ x210 = confuse(m210);
+ l210 = confuse(m210);
+
+ }
+
+ void testF310() {
+ // Function({List<Function> x})
+ Expect.isTrue(f310 is F310);
+ Expect.isTrue(confuse(f310) is F310);
+ // In checked mode, verifies the type.
+ Function({List<Function> x}) l310;
+ // The static function f310 sets `T` to `int`.
+ if (!tIsBool) {
+ x310 = f310 as dynamic;
+ l310 = f310 as dynamic;
+ x310 = confuse(f310);
+ l310 = confuse(f310);
+ }
+
+ Expect.isTrue(m310 is F310);
+ Expect.isTrue(m310 is Function({List<Function> x}));
+ Expect.isTrue(confuse(m310) is F310);
+ // In checked mode, verifies the type.
+ x310 = m310;
+ l310 = m310;
+ x310 = confuse(m310);
+ l310 = confuse(m310);
+
+ }
+
+ void testF410() {
+ // int Function(int x1, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f410 is F410);
+ Expect.isTrue(confuse(f410) is F410);
+ // In checked mode, verifies the type.
+ int Function(int x1, [int x]) Function<B extends core.int>() l410;
+ // The static function f410 sets `T` to `int`.
+ if (!tIsBool) {
+ x410 = f410 as dynamic;
+ l410 = f410 as dynamic;
+ x410 = confuse(f410);
+ l410 = confuse(f410);
+ }
+
+ Expect.isTrue(m410 is F410);
+ Expect.isTrue(m410 is int Function(int x1, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m410) is F410);
+ // In checked mode, verifies the type.
+ x410 = m410;
+ l410 = m410;
+ x410 = confuse(m410);
+ l410 = confuse(m410);
+
+ }
+
+ void testF510() {
+ // int Function([List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f510 is F510);
+ Expect.isTrue(confuse(f510) is F510);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x1]) Function<B extends core.int>() l510;
+ // The static function f510 sets `T` to `int`.
+ if (!tIsBool) {
+ x510 = f510 as dynamic;
+ l510 = f510 as dynamic;
+ x510 = confuse(f510);
+ l510 = confuse(f510);
+ }
+
+ Expect.isTrue(m510 is F510);
+ Expect.isTrue(m510 is int Function([List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m510) is F510);
+ // In checked mode, verifies the type.
+ x510 = m510;
+ l510 = m510;
+ x510 = confuse(m510);
+ l510 = confuse(m510);
+
+ }
+
+ void testF610() {
+ // int Function({List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f610 is F610);
+ Expect.isTrue(confuse(f610) is F610);
+ // In checked mode, verifies the type.
+ int Function({List<T> x}) Function<B extends core.int>() l610;
+ // The static function f610 sets `T` to `int`.
+ if (!tIsBool) {
+ x610 = f610 as dynamic;
+ l610 = f610 as dynamic;
+ x610 = confuse(f610);
+ l610 = confuse(f610);
+ }
+
+ Expect.isTrue(m610 is F610);
+ Expect.isTrue(m610 is int Function({List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m610) is F610);
+ // In checked mode, verifies the type.
+ x610 = m610;
+ l610 = m610;
+ x610 = confuse(m610);
+ l610 = confuse(m610);
+ if (!tIsBool) {
+ Expect.isTrue(f610 is F610<int>);
+ Expect.isFalse(f610 is F610<bool>);
+ Expect.isTrue(confuse(f610) is F610<int>);
+ Expect.isFalse(confuse(f610) is F610<bool>);
+ Expect.equals(tIsDynamic, m610 is F610<bool>);
+ Expect.equals(tIsDynamic, confuse(m610) is F610<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x610 = (f610 as dynamic); });
+ Expect.throws(() { x610 = confuse(f610); });
+ int Function({List<T> x}) Function<B extends core.int>() l610;
+ Expect.throws(() { l610 = (f610 as dynamic); });
+ Expect.throws(() { l610 = confuse(f610); });
+ }
+ int Function({List<T> x}) Function<B extends core.int>() l610 = m610;
+ // In checked mode, verifies the type.
+ x610 = m610;
+ x610 = confuse(m610);
+ }
+ }
+
+ void testF710() {
+ // Function Function(int y, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f710 is F710);
+ Expect.isTrue(confuse(f710) is F710);
+ // In checked mode, verifies the type.
+ Function Function(int y, {Function x}) Function<B extends core.int>() l710;
+ // The static function f710 sets `T` to `int`.
+ if (!tIsBool) {
+ x710 = f710 as dynamic;
+ l710 = f710 as dynamic;
+ x710 = confuse(f710);
+ l710 = confuse(f710);
+ }
+
+ Expect.isTrue(m710 is F710);
+ Expect.isTrue(m710 is Function Function(int y, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m710) is F710);
+ // In checked mode, verifies the type.
+ x710 = m710;
+ l710 = m710;
+ x710 = confuse(m710);
+ l710 = confuse(m710);
+
+ }
+
+ void testF810() {
+ // Function Function(int x1, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f810 is F810);
+ Expect.isTrue(confuse(f810) is F810);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>() l810;
+ // The static function f810 sets `T` to `int`.
+ if (!tIsBool) {
+ x810 = f810 as dynamic;
+ l810 = f810 as dynamic;
+ x810 = confuse(f810);
+ l810 = confuse(f810);
+ }
+
+ Expect.isTrue(m810 is F810);
+ Expect.isTrue(m810 is Function Function(int x1, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m810) is F810);
+ // In checked mode, verifies the type.
+ x810 = m810;
+ l810 = m810;
+ x810 = confuse(m810);
+ l810 = confuse(m810);
+ if (!tIsBool) {
+ Expect.isTrue(f810 is F810<int>);
+ Expect.isFalse(f810 is F810<bool>);
+ Expect.isTrue(confuse(f810) is F810<int>);
+ Expect.isFalse(confuse(f810) is F810<bool>);
+ Expect.equals(tIsDynamic, m810 is F810<bool>);
+ Expect.equals(tIsDynamic, confuse(m810) is F810<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x810 = (f810 as dynamic); });
+ Expect.throws(() { x810 = confuse(f810); });
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>() l810;
+ Expect.throws(() { l810 = (f810 as dynamic); });
+ Expect.throws(() { l810 = confuse(f810); });
+ }
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>() l810 = m810;
+ // In checked mode, verifies the type.
+ x810 = m810;
+ x810 = confuse(m810);
+ }
+ }
+
+ void testF910() {
+ // List<Function> Function(Function x1) Function<B extends core.int>()
+ Expect.isTrue(f910 is F910);
+ Expect.isTrue(confuse(f910) is F910);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x1) Function<B extends core.int>() l910;
+ // The static function f910 sets `T` to `int`.
+ if (!tIsBool) {
+ x910 = f910 as dynamic;
+ l910 = f910 as dynamic;
+ x910 = confuse(f910);
+ l910 = confuse(f910);
+ }
+
+ Expect.isTrue(m910 is F910);
+ Expect.isTrue(m910 is List<Function> Function(Function x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m910) is F910);
+ // In checked mode, verifies the type.
+ x910 = m910;
+ l910 = m910;
+ x910 = confuse(m910);
+ l910 = confuse(m910);
+
+ }
+
+ void testF1010() {
+ // List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1010 is F1010);
+ Expect.isTrue(confuse(f1010) is F1010);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l1010;
+ // The static function f1010 sets `T` to `int`.
+ if (!tIsBool) {
+ x1010 = f1010 as dynamic;
+ l1010 = f1010 as dynamic;
+ x1010 = confuse(f1010);
+ l1010 = confuse(f1010);
+ }
+
+ Expect.isTrue(m1010 is F1010);
+ Expect.isTrue(m1010 is List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1010) is F1010);
+ // In checked mode, verifies the type.
+ x1010 = m1010;
+ l1010 = m1010;
+ x1010 = confuse(m1010);
+ l1010 = confuse(m1010);
+
+ }
+
+ void testF1110() {
+ // core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f1110 is F1110);
+ Expect.isTrue(confuse(f1110) is F1110);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>() l1110;
+ // The static function f1110 sets `T` to `int`.
+ if (!tIsBool) {
+ x1110 = f1110 as dynamic;
+ l1110 = f1110 as dynamic;
+ x1110 = confuse(f1110);
+ l1110 = confuse(f1110);
+ }
+
+ Expect.isTrue(m1110 is F1110);
+ Expect.isTrue(m1110 is core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1110) is F1110);
+ // In checked mode, verifies the type.
+ x1110 = m1110;
+ l1110 = m1110;
+ x1110 = confuse(m1110);
+ l1110 = confuse(m1110);
+
+ }
+
+ void testF1210() {
+ // core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1210 is F1210);
+ Expect.isTrue(confuse(f1210) is F1210);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>() l1210;
+ // The static function f1210 sets `T` to `int`.
+ if (!tIsBool) {
+ x1210 = f1210 as dynamic;
+ l1210 = f1210 as dynamic;
+ x1210 = confuse(f1210);
+ l1210 = confuse(f1210);
+ }
+
+ Expect.isTrue(m1210 is F1210);
+ Expect.isTrue(m1210 is core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1210) is F1210);
+ // In checked mode, verifies the type.
+ x1210 = m1210;
+ l1210 = m1210;
+ x1210 = confuse(m1210);
+ l1210 = confuse(m1210);
+
+ }
+
+ void testF1310() {
+ // List<T> Function(int y, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f1310 is F1310);
+ Expect.isTrue(confuse(f1310) is F1310);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [int x]) Function<B extends core.int>() l1310;
+ // The static function f1310 sets `T` to `int`.
+ if (!tIsBool) {
+ x1310 = f1310 as dynamic;
+ l1310 = f1310 as dynamic;
+ x1310 = confuse(f1310);
+ l1310 = confuse(f1310);
+ }
+
+ Expect.isTrue(m1310 is F1310);
+ Expect.isTrue(m1310 is List<T> Function(int y, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1310) is F1310);
+ // In checked mode, verifies the type.
+ x1310 = m1310;
+ l1310 = m1310;
+ x1310 = confuse(m1310);
+ l1310 = confuse(m1310);
+ if (!tIsBool) {
+ Expect.isTrue(f1310 is F1310<int>);
+ Expect.isFalse(f1310 is F1310<bool>);
+ Expect.isTrue(confuse(f1310) is F1310<int>);
+ Expect.isFalse(confuse(f1310) is F1310<bool>);
+ Expect.equals(tIsDynamic, m1310 is F1310<bool>);
+ Expect.equals(tIsDynamic, confuse(m1310) is F1310<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1310 = (f1310 as dynamic); });
+ Expect.throws(() { x1310 = confuse(f1310); });
+ List<T> Function(int y, [int x]) Function<B extends core.int>() l1310;
+ Expect.throws(() { l1310 = (f1310 as dynamic); });
+ Expect.throws(() { l1310 = confuse(f1310); });
+ }
+ List<T> Function(int y, [int x]) Function<B extends core.int>() l1310 = m1310;
+ // In checked mode, verifies the type.
+ x1310 = m1310;
+ x1310 = confuse(m1310);
+ }
+ }
+
+ void testF1410() {
+ // List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1410 is F1410);
+ Expect.isTrue(confuse(f1410) is F1410);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>() l1410;
+ // The static function f1410 sets `T` to `int`.
+ if (!tIsBool) {
+ x1410 = f1410 as dynamic;
+ l1410 = f1410 as dynamic;
+ x1410 = confuse(f1410);
+ l1410 = confuse(f1410);
+ }
+
+ Expect.isTrue(m1410 is F1410);
+ Expect.isTrue(m1410 is List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1410) is F1410);
+ // In checked mode, verifies the type.
+ x1410 = m1410;
+ l1410 = m1410;
+ x1410 = confuse(m1410);
+ l1410 = confuse(m1410);
+ if (!tIsBool) {
+ Expect.isTrue(f1410 is F1410<int>);
+ Expect.isFalse(f1410 is F1410<bool>);
+ Expect.isTrue(confuse(f1410) is F1410<int>);
+ Expect.isFalse(confuse(f1410) is F1410<bool>);
+ Expect.equals(tIsDynamic, m1410 is F1410<bool>);
+ Expect.equals(tIsDynamic, confuse(m1410) is F1410<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1410 = (f1410 as dynamic); });
+ Expect.throws(() { x1410 = confuse(f1410); });
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>() l1410;
+ Expect.throws(() { l1410 = (f1410 as dynamic); });
+ Expect.throws(() { l1410 = confuse(f1410); });
+ }
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>() l1410 = m1410;
+ // In checked mode, verifies the type.
+ x1410 = m1410;
+ x1410 = confuse(m1410);
+ }
+ }
+
+ void testF1510() {
+ // List<T> Function(int x1, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1510 is F1510);
+ Expect.isTrue(confuse(f1510) is F1510);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>() l1510;
+ // The static function f1510 sets `T` to `int`.
+ if (!tIsBool) {
+ x1510 = f1510 as dynamic;
+ l1510 = f1510 as dynamic;
+ x1510 = confuse(f1510);
+ l1510 = confuse(f1510);
+ }
+
+ Expect.isTrue(m1510 is F1510);
+ Expect.isTrue(m1510 is List<T> Function(int x1, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1510) is F1510);
+ // In checked mode, verifies the type.
+ x1510 = m1510;
+ l1510 = m1510;
+ x1510 = confuse(m1510);
+ l1510 = confuse(m1510);
+ if (!tIsBool) {
+ Expect.isTrue(f1510 is F1510<int>);
+ Expect.isFalse(f1510 is F1510<bool>);
+ Expect.isTrue(confuse(f1510) is F1510<int>);
+ Expect.isFalse(confuse(f1510) is F1510<bool>);
+ Expect.equals(tIsDynamic, m1510 is F1510<bool>);
+ Expect.equals(tIsDynamic, confuse(m1510) is F1510<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1510 = (f1510 as dynamic); });
+ Expect.throws(() { x1510 = confuse(f1510); });
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>() l1510;
+ Expect.throws(() { l1510 = (f1510 as dynamic); });
+ Expect.throws(() { l1510 = confuse(f1510); });
+ }
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>() l1510 = m1510;
+ // In checked mode, verifies the type.
+ x1510 = m1510;
+ x1510 = confuse(m1510);
+ }
+ }
+
+ void testF1610() {
+ // Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1610 is F1610);
+ Expect.isTrue(confuse(f1610) is F1610);
+ // In checked mode, verifies the type.
+ Function(List<Function> x) Function<B extends core.int>() l1610;
+ // The static function f1610 sets `T` to `int`.
+ if (!tIsBool) {
+ x1610 = f1610 as dynamic;
+ l1610 = f1610 as dynamic;
+ x1610 = confuse(f1610);
+ l1610 = confuse(f1610);
+ }
+
+ Expect.isTrue(m1610 is F1610);
+ Expect.isTrue(m1610 is Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1610) is F1610);
+ // In checked mode, verifies the type.
+ x1610 = m1610;
+ l1610 = m1610;
+ x1610 = confuse(m1610);
+ l1610 = confuse(m1610);
+
+ }
+
+ void testF1710() {
+ // Function(int y, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1710 is F1710);
+ Expect.isTrue(confuse(f1710) is F1710);
+ // In checked mode, verifies the type.
+ Function(int y, [List<T> x]) Function<B extends core.int>() l1710;
+ // The static function f1710 sets `T` to `int`.
+ if (!tIsBool) {
+ x1710 = f1710 as dynamic;
+ l1710 = f1710 as dynamic;
+ x1710 = confuse(f1710);
+ l1710 = confuse(f1710);
+ }
+
+ Expect.isTrue(m1710 is F1710);
+ Expect.isTrue(m1710 is Function(int y, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1710) is F1710);
+ // In checked mode, verifies the type.
+ x1710 = m1710;
+ l1710 = m1710;
+ x1710 = confuse(m1710);
+ l1710 = confuse(m1710);
+ if (!tIsBool) {
+ Expect.isTrue(f1710 is F1710<int>);
+ Expect.isFalse(f1710 is F1710<bool>);
+ Expect.isTrue(confuse(f1710) is F1710<int>);
+ Expect.isFalse(confuse(f1710) is F1710<bool>);
+ Expect.equals(tIsDynamic, m1710 is F1710<bool>);
+ Expect.equals(tIsDynamic, confuse(m1710) is F1710<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1710 = (f1710 as dynamic); });
+ Expect.throws(() { x1710 = confuse(f1710); });
+ Function(int y, [List<T> x]) Function<B extends core.int>() l1710;
+ Expect.throws(() { l1710 = (f1710 as dynamic); });
+ Expect.throws(() { l1710 = confuse(f1710); });
+ }
+ Function(int y, [List<T> x]) Function<B extends core.int>() l1710 = m1710;
+ // In checked mode, verifies the type.
+ x1710 = m1710;
+ x1710 = confuse(m1710);
+ }
+ }
+
+ void testF1810() {
+ // List<Function> Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1810 is F1810);
+ Expect.isTrue(confuse(f1810) is F1810);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(int x) Function<B extends core.int>() l1810;
+ // The static function f1810 sets `T` to `int`.
+ if (!tIsBool) {
+ x1810 = f1810 as dynamic;
+ l1810 = f1810 as dynamic;
+ x1810 = confuse(f1810);
+ l1810 = confuse(f1810);
+ }
+
+ Expect.isTrue(m1810 is F1810);
+ Expect.isTrue(m1810 is List<Function> Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1810) is F1810);
+ // In checked mode, verifies the type.
+ x1810 = m1810;
+ l1810 = m1810;
+ x1810 = confuse(m1810);
+ l1810 = confuse(m1810);
+
+ }
+
+ void testF1910() {
+ // Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1910 is F1910);
+ Expect.isTrue(confuse(f1910) is F1910);
+ // In checked mode, verifies the type.
+ Function<A>(Function x) Function<B extends core.int>() l1910;
+ // The static function f1910 sets `T` to `int`.
+ if (!tIsBool) {
+ x1910 = f1910 as dynamic;
+ l1910 = f1910 as dynamic;
+ x1910 = confuse(f1910);
+ l1910 = confuse(f1910);
+ }
+
+ Expect.isTrue(m1910 is F1910);
+ Expect.isTrue(m1910 is Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1910) is F1910);
+ // In checked mode, verifies the type.
+ x1910 = m1910;
+ l1910 = m1910;
+ x1910 = confuse(m1910);
+ l1910 = confuse(m1910);
+
+ }
+
+ void testF2010() {
+ // Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2010 is F2010);
+ Expect.isTrue(confuse(f2010) is F2010);
+ // In checked mode, verifies the type.
+ Function(B x) Function<B extends core.int>() l2010;
+ // The static function f2010 sets `T` to `int`.
+ if (!tIsBool) {
+ x2010 = f2010 as dynamic;
+ l2010 = f2010 as dynamic;
+ x2010 = confuse(f2010);
+ l2010 = confuse(f2010);
+ }
+
+ Expect.isTrue(m2010 is F2010);
+ Expect.isTrue(m2010 is Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2010) is F2010);
+ // In checked mode, verifies the type.
+ x2010 = m2010;
+ l2010 = m2010;
+ x2010 = confuse(m2010);
+ l2010 = confuse(m2010);
+
+ }
+
+
+}
+
+class C11<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(Function x) x11;
+ Function Function() x111;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) x211;
+ Function(int x0, {List<Function> x}) x311;
+ int Function(int x1, [int x]) Function<B extends core.int>(int x) x411;
+ int Function([List<Function> x1]) Function<B extends core.int>(int x) x511;
+ int Function({List<T> x}) Function<B extends core.int>(int x) x611;
+ Function Function(int y, {Function x}) Function<B extends core.int>(int x) x711;
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x811;
+ List<Function> Function(Function x1) Function<B extends core.int>(int x) x911;
+ List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) x1011;
+ core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>(int x) x1111;
+ core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>(int x) x1211;
+ List<T> Function(int y, [int x]) Function<B extends core.int>(int x) x1311;
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) x1411;
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) x1511;
+ Function(List<Function> x) Function<B extends core.int>(int x) x1611;
+ Function(int y, [List<T> x]) Function<B extends core.int>(int x) x1711;
+ List<Function> Function<A>(int x) Function<B extends core.int>(int x) x1811;
+ Function<A>(Function x) Function<B extends core.int>(int x) x1911;
+ Function(B x) Function<B extends core.int>(int x) x2011;
+
+
+ C11({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m11(Function x) => null;
+ Function m111() => null;
+ core.List<core.int> m211(int y, {core.List<core.int> x}) => null;
+ m311(int x0, {List<Function> x}) => null;
+ int Function(int x0, [int x]) m411<B extends core.int>(int x) => null;
+ int Function([List<Function> x0]) m511<B extends core.int>(int x) => null;
+ int Function({List<T> x}) m611<B extends core.int>(int x) => null;
+ Function Function(int y, {Function x}) m711<B extends core.int>(int x) => null;
+ Function Function(int x0, [List<T> x]) m811<B extends core.int>(int x) => null;
+ List<Function> Function(Function x0) m911<B extends core.int>(int x) => null;
+ List<Function> Function(int x, [core.List<core.int> x0]) m1011<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, {int x}) m1111<B extends core.int>(int x) => null;
+ core.List<core.int> Function([core.List<core.int> x]) m1211<B extends core.int>(int x) => null;
+ List<T> Function(int y, [int x]) m1311<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [List<Function> x1]) m1411<B extends core.int>(int x) => null;
+ List<T> Function(int x0, {List<T> x}) m1511<B extends core.int>(int x) => null;
+ Function(List<Function> x) m1611<B extends core.int>(int x) => null;
+ Function(int y, [List<T> x]) m1711<B extends core.int>(int x) => null;
+ List<Function> Function<A>(int x) m1811<B extends core.int>(int x) => null;
+ Function<A>(Function x) m1911<B extends core.int>(int x) => null;
+ Function(B x) m2011<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF11();
+ testF111();
+ testF211();
+ testF311();
+ testF411();
+ testF511();
+ testF611();
+ testF711();
+ testF811();
+ testF911();
+ testF1011();
+ testF1111();
+ testF1211();
+ testF1311();
+ testF1411();
+ testF1511();
+ testF1611();
+ testF1711();
+ testF1811();
+ testF1911();
+ testF2011();
+ }
+
+ void testF11() {
+ // int Function(Function x)
+ Expect.isTrue(f11 is F11);
+ Expect.isTrue(confuse(f11) is F11);
+ // In checked mode, verifies the type.
+ int Function(Function x) l11;
+ // The static function f11 sets `T` to `int`.
+ if (!tIsBool) {
+ x11 = f11 as dynamic;
+ l11 = f11 as dynamic;
+ x11 = confuse(f11);
+ l11 = confuse(f11);
+ }
+
+ Expect.isTrue(m11 is F11);
+ Expect.isTrue(m11 is int Function(Function x));
+ Expect.isTrue(confuse(m11) is F11);
+ // In checked mode, verifies the type.
+ x11 = m11;
+ l11 = m11;
+ x11 = confuse(m11);
+ l11 = confuse(m11);
+
+ }
+
+ void testF111() {
+ // Function Function()
+ Expect.isTrue(f111 is F111);
+ Expect.isTrue(confuse(f111) is F111);
+ // In checked mode, verifies the type.
+ Function Function() l111;
+ // The static function f111 sets `T` to `int`.
+ if (!tIsBool) {
+ x111 = f111 as dynamic;
+ l111 = f111 as dynamic;
+ x111 = confuse(f111);
+ l111 = confuse(f111);
+ }
+
+ Expect.isTrue(m111 is F111);
+ Expect.isTrue(m111 is Function Function());
+ Expect.isTrue(confuse(m111) is F111);
+ // In checked mode, verifies the type.
+ x111 = m111;
+ l111 = m111;
+ x111 = confuse(m111);
+ l111 = confuse(m111);
+
+ }
+
+ void testF211() {
+ // core.List<core.int> Function(int y, {core.List<core.int> x})
+ Expect.isTrue(f211 is F211);
+ Expect.isTrue(confuse(f211) is F211);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {core.List<core.int> x}) l211;
+ // The static function f211 sets `T` to `int`.
+ if (!tIsBool) {
+ x211 = f211 as dynamic;
+ l211 = f211 as dynamic;
+ x211 = confuse(f211);
+ l211 = confuse(f211);
+ }
+
+ Expect.isTrue(m211 is F211);
+ Expect.isTrue(m211 is core.List<core.int> Function(int y, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m211) is F211);
+ // In checked mode, verifies the type.
+ x211 = m211;
+ l211 = m211;
+ x211 = confuse(m211);
+ l211 = confuse(m211);
+
+ }
+
+ void testF311() {
+ // Function(int x0, {List<Function> x})
+ Expect.isTrue(f311 is F311);
+ Expect.isTrue(confuse(f311) is F311);
+ // In checked mode, verifies the type.
+ Function(int x0, {List<Function> x}) l311;
+ // The static function f311 sets `T` to `int`.
+ if (!tIsBool) {
+ x311 = f311 as dynamic;
+ l311 = f311 as dynamic;
+ x311 = confuse(f311);
+ l311 = confuse(f311);
+ }
+
+ Expect.isTrue(m311 is F311);
+ Expect.isTrue(m311 is Function(int x0, {List<Function> x}));
+ Expect.isTrue(confuse(m311) is F311);
+ // In checked mode, verifies the type.
+ x311 = m311;
+ l311 = m311;
+ x311 = confuse(m311);
+ l311 = confuse(m311);
+
+ }
+
+ void testF411() {
+ // int Function(int x1, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f411 is F411);
+ Expect.isTrue(confuse(f411) is F411);
+ // In checked mode, verifies the type.
+ int Function(int x1, [int x]) Function<B extends core.int>(int x) l411;
+ // The static function f411 sets `T` to `int`.
+ if (!tIsBool) {
+ x411 = f411 as dynamic;
+ l411 = f411 as dynamic;
+ x411 = confuse(f411);
+ l411 = confuse(f411);
+ }
+
+ Expect.isTrue(m411 is F411);
+ Expect.isTrue(m411 is int Function(int x1, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m411) is F411);
+ // In checked mode, verifies the type.
+ x411 = m411;
+ l411 = m411;
+ x411 = confuse(m411);
+ l411 = confuse(m411);
+
+ }
+
+ void testF511() {
+ // int Function([List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f511 is F511);
+ Expect.isTrue(confuse(f511) is F511);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x1]) Function<B extends core.int>(int x) l511;
+ // The static function f511 sets `T` to `int`.
+ if (!tIsBool) {
+ x511 = f511 as dynamic;
+ l511 = f511 as dynamic;
+ x511 = confuse(f511);
+ l511 = confuse(f511);
+ }
+
+ Expect.isTrue(m511 is F511);
+ Expect.isTrue(m511 is int Function([List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m511) is F511);
+ // In checked mode, verifies the type.
+ x511 = m511;
+ l511 = m511;
+ x511 = confuse(m511);
+ l511 = confuse(m511);
+
+ }
+
+ void testF611() {
+ // int Function({List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f611 is F611);
+ Expect.isTrue(confuse(f611) is F611);
+ // In checked mode, verifies the type.
+ int Function({List<T> x}) Function<B extends core.int>(int x) l611;
+ // The static function f611 sets `T` to `int`.
+ if (!tIsBool) {
+ x611 = f611 as dynamic;
+ l611 = f611 as dynamic;
+ x611 = confuse(f611);
+ l611 = confuse(f611);
+ }
+
+ Expect.isTrue(m611 is F611);
+ Expect.isTrue(m611 is int Function({List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m611) is F611);
+ // In checked mode, verifies the type.
+ x611 = m611;
+ l611 = m611;
+ x611 = confuse(m611);
+ l611 = confuse(m611);
+ if (!tIsBool) {
+ Expect.isTrue(f611 is F611<int>);
+ Expect.isFalse(f611 is F611<bool>);
+ Expect.isTrue(confuse(f611) is F611<int>);
+ Expect.isFalse(confuse(f611) is F611<bool>);
+ Expect.equals(tIsDynamic, m611 is F611<bool>);
+ Expect.equals(tIsDynamic, confuse(m611) is F611<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x611 = (f611 as dynamic); });
+ Expect.throws(() { x611 = confuse(f611); });
+ int Function({List<T> x}) Function<B extends core.int>(int x) l611;
+ Expect.throws(() { l611 = (f611 as dynamic); });
+ Expect.throws(() { l611 = confuse(f611); });
+ }
+ int Function({List<T> x}) Function<B extends core.int>(int x) l611 = m611;
+ // In checked mode, verifies the type.
+ x611 = m611;
+ x611 = confuse(m611);
+ }
+ }
+
+ void testF711() {
+ // Function Function(int y, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f711 is F711);
+ Expect.isTrue(confuse(f711) is F711);
+ // In checked mode, verifies the type.
+ Function Function(int y, {Function x}) Function<B extends core.int>(int x) l711;
+ // The static function f711 sets `T` to `int`.
+ if (!tIsBool) {
+ x711 = f711 as dynamic;
+ l711 = f711 as dynamic;
+ x711 = confuse(f711);
+ l711 = confuse(f711);
+ }
+
+ Expect.isTrue(m711 is F711);
+ Expect.isTrue(m711 is Function Function(int y, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m711) is F711);
+ // In checked mode, verifies the type.
+ x711 = m711;
+ l711 = m711;
+ x711 = confuse(m711);
+ l711 = confuse(m711);
+
+ }
+
+ void testF811() {
+ // Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f811 is F811);
+ Expect.isTrue(confuse(f811) is F811);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l811;
+ // The static function f811 sets `T` to `int`.
+ if (!tIsBool) {
+ x811 = f811 as dynamic;
+ l811 = f811 as dynamic;
+ x811 = confuse(f811);
+ l811 = confuse(f811);
+ }
+
+ Expect.isTrue(m811 is F811);
+ Expect.isTrue(m811 is Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m811) is F811);
+ // In checked mode, verifies the type.
+ x811 = m811;
+ l811 = m811;
+ x811 = confuse(m811);
+ l811 = confuse(m811);
+ if (!tIsBool) {
+ Expect.isTrue(f811 is F811<int>);
+ Expect.isFalse(f811 is F811<bool>);
+ Expect.isTrue(confuse(f811) is F811<int>);
+ Expect.isFalse(confuse(f811) is F811<bool>);
+ Expect.equals(tIsDynamic, m811 is F811<bool>);
+ Expect.equals(tIsDynamic, confuse(m811) is F811<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x811 = (f811 as dynamic); });
+ Expect.throws(() { x811 = confuse(f811); });
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l811;
+ Expect.throws(() { l811 = (f811 as dynamic); });
+ Expect.throws(() { l811 = confuse(f811); });
+ }
+ Function Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l811 = m811;
+ // In checked mode, verifies the type.
+ x811 = m811;
+ x811 = confuse(m811);
+ }
+ }
+
+ void testF911() {
+ // List<Function> Function(Function x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f911 is F911);
+ Expect.isTrue(confuse(f911) is F911);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x1) Function<B extends core.int>(int x) l911;
+ // The static function f911 sets `T` to `int`.
+ if (!tIsBool) {
+ x911 = f911 as dynamic;
+ l911 = f911 as dynamic;
+ x911 = confuse(f911);
+ l911 = confuse(f911);
+ }
+
+ Expect.isTrue(m911 is F911);
+ Expect.isTrue(m911 is List<Function> Function(Function x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m911) is F911);
+ // In checked mode, verifies the type.
+ x911 = m911;
+ l911 = m911;
+ x911 = confuse(m911);
+ l911 = confuse(m911);
+
+ }
+
+ void testF1011() {
+ // List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1011 is F1011);
+ Expect.isTrue(confuse(f1011) is F1011);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l1011;
+ // The static function f1011 sets `T` to `int`.
+ if (!tIsBool) {
+ x1011 = f1011 as dynamic;
+ l1011 = f1011 as dynamic;
+ x1011 = confuse(f1011);
+ l1011 = confuse(f1011);
+ }
+
+ Expect.isTrue(m1011 is F1011);
+ Expect.isTrue(m1011 is List<Function> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1011) is F1011);
+ // In checked mode, verifies the type.
+ x1011 = m1011;
+ l1011 = m1011;
+ x1011 = confuse(m1011);
+ l1011 = confuse(m1011);
+
+ }
+
+ void testF1111() {
+ // core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1111 is F1111);
+ Expect.isTrue(confuse(f1111) is F1111);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>(int x) l1111;
+ // The static function f1111 sets `T` to `int`.
+ if (!tIsBool) {
+ x1111 = f1111 as dynamic;
+ l1111 = f1111 as dynamic;
+ x1111 = confuse(f1111);
+ l1111 = confuse(f1111);
+ }
+
+ Expect.isTrue(m1111 is F1111);
+ Expect.isTrue(m1111 is core.List<core.int> Function(int x1, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1111) is F1111);
+ // In checked mode, verifies the type.
+ x1111 = m1111;
+ l1111 = m1111;
+ x1111 = confuse(m1111);
+ l1111 = confuse(m1111);
+
+ }
+
+ void testF1211() {
+ // core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1211 is F1211);
+ Expect.isTrue(confuse(f1211) is F1211);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>(int x) l1211;
+ // The static function f1211 sets `T` to `int`.
+ if (!tIsBool) {
+ x1211 = f1211 as dynamic;
+ l1211 = f1211 as dynamic;
+ x1211 = confuse(f1211);
+ l1211 = confuse(f1211);
+ }
+
+ Expect.isTrue(m1211 is F1211);
+ Expect.isTrue(m1211 is core.List<core.int> Function([core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1211) is F1211);
+ // In checked mode, verifies the type.
+ x1211 = m1211;
+ l1211 = m1211;
+ x1211 = confuse(m1211);
+ l1211 = confuse(m1211);
+
+ }
+
+ void testF1311() {
+ // List<T> Function(int y, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1311 is F1311);
+ Expect.isTrue(confuse(f1311) is F1311);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [int x]) Function<B extends core.int>(int x) l1311;
+ // The static function f1311 sets `T` to `int`.
+ if (!tIsBool) {
+ x1311 = f1311 as dynamic;
+ l1311 = f1311 as dynamic;
+ x1311 = confuse(f1311);
+ l1311 = confuse(f1311);
+ }
+
+ Expect.isTrue(m1311 is F1311);
+ Expect.isTrue(m1311 is List<T> Function(int y, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1311) is F1311);
+ // In checked mode, verifies the type.
+ x1311 = m1311;
+ l1311 = m1311;
+ x1311 = confuse(m1311);
+ l1311 = confuse(m1311);
+ if (!tIsBool) {
+ Expect.isTrue(f1311 is F1311<int>);
+ Expect.isFalse(f1311 is F1311<bool>);
+ Expect.isTrue(confuse(f1311) is F1311<int>);
+ Expect.isFalse(confuse(f1311) is F1311<bool>);
+ Expect.equals(tIsDynamic, m1311 is F1311<bool>);
+ Expect.equals(tIsDynamic, confuse(m1311) is F1311<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1311 = (f1311 as dynamic); });
+ Expect.throws(() { x1311 = confuse(f1311); });
+ List<T> Function(int y, [int x]) Function<B extends core.int>(int x) l1311;
+ Expect.throws(() { l1311 = (f1311 as dynamic); });
+ Expect.throws(() { l1311 = confuse(f1311); });
+ }
+ List<T> Function(int y, [int x]) Function<B extends core.int>(int x) l1311 = m1311;
+ // In checked mode, verifies the type.
+ x1311 = m1311;
+ x1311 = confuse(m1311);
+ }
+ }
+
+ void testF1411() {
+ // List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1411 is F1411);
+ Expect.isTrue(confuse(f1411) is F1411);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l1411;
+ // The static function f1411 sets `T` to `int`.
+ if (!tIsBool) {
+ x1411 = f1411 as dynamic;
+ l1411 = f1411 as dynamic;
+ x1411 = confuse(f1411);
+ l1411 = confuse(f1411);
+ }
+
+ Expect.isTrue(m1411 is F1411);
+ Expect.isTrue(m1411 is List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1411) is F1411);
+ // In checked mode, verifies the type.
+ x1411 = m1411;
+ l1411 = m1411;
+ x1411 = confuse(m1411);
+ l1411 = confuse(m1411);
+ if (!tIsBool) {
+ Expect.isTrue(f1411 is F1411<int>);
+ Expect.isFalse(f1411 is F1411<bool>);
+ Expect.isTrue(confuse(f1411) is F1411<int>);
+ Expect.isFalse(confuse(f1411) is F1411<bool>);
+ Expect.equals(tIsDynamic, m1411 is F1411<bool>);
+ Expect.equals(tIsDynamic, confuse(m1411) is F1411<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1411 = (f1411 as dynamic); });
+ Expect.throws(() { x1411 = confuse(f1411); });
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l1411;
+ Expect.throws(() { l1411 = (f1411 as dynamic); });
+ Expect.throws(() { l1411 = confuse(f1411); });
+ }
+ List<T> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l1411 = m1411;
+ // In checked mode, verifies the type.
+ x1411 = m1411;
+ x1411 = confuse(m1411);
+ }
+ }
+
+ void testF1511() {
+ // List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1511 is F1511);
+ Expect.isTrue(confuse(f1511) is F1511);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1511;
+ // The static function f1511 sets `T` to `int`.
+ if (!tIsBool) {
+ x1511 = f1511 as dynamic;
+ l1511 = f1511 as dynamic;
+ x1511 = confuse(f1511);
+ l1511 = confuse(f1511);
+ }
+
+ Expect.isTrue(m1511 is F1511);
+ Expect.isTrue(m1511 is List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1511) is F1511);
+ // In checked mode, verifies the type.
+ x1511 = m1511;
+ l1511 = m1511;
+ x1511 = confuse(m1511);
+ l1511 = confuse(m1511);
+ if (!tIsBool) {
+ Expect.isTrue(f1511 is F1511<int>);
+ Expect.isFalse(f1511 is F1511<bool>);
+ Expect.isTrue(confuse(f1511) is F1511<int>);
+ Expect.isFalse(confuse(f1511) is F1511<bool>);
+ Expect.equals(tIsDynamic, m1511 is F1511<bool>);
+ Expect.equals(tIsDynamic, confuse(m1511) is F1511<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1511 = (f1511 as dynamic); });
+ Expect.throws(() { x1511 = confuse(f1511); });
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1511;
+ Expect.throws(() { l1511 = (f1511 as dynamic); });
+ Expect.throws(() { l1511 = confuse(f1511); });
+ }
+ List<T> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1511 = m1511;
+ // In checked mode, verifies the type.
+ x1511 = m1511;
+ x1511 = confuse(m1511);
+ }
+ }
+
+ void testF1611() {
+ // Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1611 is F1611);
+ Expect.isTrue(confuse(f1611) is F1611);
+ // In checked mode, verifies the type.
+ Function(List<Function> x) Function<B extends core.int>(int x) l1611;
+ // The static function f1611 sets `T` to `int`.
+ if (!tIsBool) {
+ x1611 = f1611 as dynamic;
+ l1611 = f1611 as dynamic;
+ x1611 = confuse(f1611);
+ l1611 = confuse(f1611);
+ }
+
+ Expect.isTrue(m1611 is F1611);
+ Expect.isTrue(m1611 is Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1611) is F1611);
+ // In checked mode, verifies the type.
+ x1611 = m1611;
+ l1611 = m1611;
+ x1611 = confuse(m1611);
+ l1611 = confuse(m1611);
+
+ }
+
+ void testF1711() {
+ // Function(int y, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1711 is F1711);
+ Expect.isTrue(confuse(f1711) is F1711);
+ // In checked mode, verifies the type.
+ Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1711;
+ // The static function f1711 sets `T` to `int`.
+ if (!tIsBool) {
+ x1711 = f1711 as dynamic;
+ l1711 = f1711 as dynamic;
+ x1711 = confuse(f1711);
+ l1711 = confuse(f1711);
+ }
+
+ Expect.isTrue(m1711 is F1711);
+ Expect.isTrue(m1711 is Function(int y, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1711) is F1711);
+ // In checked mode, verifies the type.
+ x1711 = m1711;
+ l1711 = m1711;
+ x1711 = confuse(m1711);
+ l1711 = confuse(m1711);
+ if (!tIsBool) {
+ Expect.isTrue(f1711 is F1711<int>);
+ Expect.isFalse(f1711 is F1711<bool>);
+ Expect.isTrue(confuse(f1711) is F1711<int>);
+ Expect.isFalse(confuse(f1711) is F1711<bool>);
+ Expect.equals(tIsDynamic, m1711 is F1711<bool>);
+ Expect.equals(tIsDynamic, confuse(m1711) is F1711<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1711 = (f1711 as dynamic); });
+ Expect.throws(() { x1711 = confuse(f1711); });
+ Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1711;
+ Expect.throws(() { l1711 = (f1711 as dynamic); });
+ Expect.throws(() { l1711 = confuse(f1711); });
+ }
+ Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1711 = m1711;
+ // In checked mode, verifies the type.
+ x1711 = m1711;
+ x1711 = confuse(m1711);
+ }
+ }
+
+ void testF1811() {
+ // List<Function> Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1811 is F1811);
+ Expect.isTrue(confuse(f1811) is F1811);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(int x) Function<B extends core.int>(int x) l1811;
+ // The static function f1811 sets `T` to `int`.
+ if (!tIsBool) {
+ x1811 = f1811 as dynamic;
+ l1811 = f1811 as dynamic;
+ x1811 = confuse(f1811);
+ l1811 = confuse(f1811);
+ }
+
+ Expect.isTrue(m1811 is F1811);
+ Expect.isTrue(m1811 is List<Function> Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1811) is F1811);
+ // In checked mode, verifies the type.
+ x1811 = m1811;
+ l1811 = m1811;
+ x1811 = confuse(m1811);
+ l1811 = confuse(m1811);
+
+ }
+
+ void testF1911() {
+ // Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1911 is F1911);
+ Expect.isTrue(confuse(f1911) is F1911);
+ // In checked mode, verifies the type.
+ Function<A>(Function x) Function<B extends core.int>(int x) l1911;
+ // The static function f1911 sets `T` to `int`.
+ if (!tIsBool) {
+ x1911 = f1911 as dynamic;
+ l1911 = f1911 as dynamic;
+ x1911 = confuse(f1911);
+ l1911 = confuse(f1911);
+ }
+
+ Expect.isTrue(m1911 is F1911);
+ Expect.isTrue(m1911 is Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1911) is F1911);
+ // In checked mode, verifies the type.
+ x1911 = m1911;
+ l1911 = m1911;
+ x1911 = confuse(m1911);
+ l1911 = confuse(m1911);
+
+ }
+
+ void testF2011() {
+ // Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2011 is F2011);
+ Expect.isTrue(confuse(f2011) is F2011);
+ // In checked mode, verifies the type.
+ Function(B x) Function<B extends core.int>(int x) l2011;
+ // The static function f2011 sets `T` to `int`.
+ if (!tIsBool) {
+ x2011 = f2011 as dynamic;
+ l2011 = f2011 as dynamic;
+ x2011 = confuse(f2011);
+ l2011 = confuse(f2011);
+ }
+
+ Expect.isTrue(m2011 is F2011);
+ Expect.isTrue(m2011 is Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2011) is F2011);
+ // In checked mode, verifies the type.
+ x2011 = m2011;
+ l2011 = m2011;
+ x2011 = confuse(m2011);
+ l2011 = confuse(m2011);
+
+ }
+
+
+}
+
+class C12<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([Function x]) x12;
+ List<Function> Function(int x) x112;
+ core.List<core.int> Function(List<T> x) x212;
+ Function(int y, {List<Function> x}) x312;
+ int Function(int y, [int x]) Function() x412;
+ int Function(int x1, [List<Function> x2]) Function() x512;
+ int Function(int x0, {List<T> x}) Function() x612;
+ Function Function(List<Function> x) Function() x712;
+ Function Function(int y, [List<T> x]) Function() x812;
+ List<Function> Function([Function x1]) Function() x912;
+ List<Function> Function({core.List<core.int> x}) Function() x1012;
+ core.List<core.int> Function(int y, {int x}) Function() x1112;
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) Function() x1212;
+ List<T> Function(int x0) Function() x1312;
+ List<T> Function(int x, [List<Function> x2]) Function() x1412;
+ List<T> Function(int y, {List<T> x}) Function() x1512;
+ Function([List<Function> x]) Function() x1612;
+ Function(List<T> x0) Function() x1712;
+ List<Function> Function<A>(Function x) Function() x1812;
+ Function<A>(List<Function> x) Function() x1912;
+ B Function(B x) Function<B extends core.int>() x2012;
+
+
+ C12({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m12([Function x]) => null;
+ List<Function> m112(int x) => null;
+ core.List<core.int> m212(List<T> x) => null;
+ m312(int y, {List<Function> x}) => null;
+ int Function(int y, [int x]) m412() => null;
+ int Function(int x0, [List<Function> x1]) m512() => null;
+ int Function(int x0, {List<T> x}) m612() => null;
+ Function Function(List<Function> x) m712() => null;
+ Function Function(int y, [List<T> x]) m812() => null;
+ List<Function> Function([Function x0]) m912() => null;
+ List<Function> Function({core.List<core.int> x}) m1012() => null;
+ core.List<core.int> Function(int y, {int x}) m1112() => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) m1212() => null;
+ List<T> Function(int x0) m1312() => null;
+ List<T> Function(int x, [List<Function> x0]) m1412() => null;
+ List<T> Function(int y, {List<T> x}) m1512() => null;
+ Function([List<Function> x]) m1612() => null;
+ Function(List<T> x0) m1712() => null;
+ List<Function> Function<A>(Function x) m1812() => null;
+ Function<A>(List<Function> x) m1912() => null;
+ B Function(B x) m2012<B extends core.int>() => null;
+
+
+ runTests() {
+ testF12();
+ testF112();
+ testF212();
+ testF312();
+ testF412();
+ testF512();
+ testF612();
+ testF712();
+ testF812();
+ testF912();
+ testF1012();
+ testF1112();
+ testF1212();
+ testF1312();
+ testF1412();
+ testF1512();
+ testF1612();
+ testF1712();
+ testF1812();
+ testF1912();
+ testF2012();
+ }
+
+ void testF12() {
+ // int Function([Function x])
+ Expect.isTrue(f12 is F12);
+ Expect.isTrue(confuse(f12) is F12);
+ // In checked mode, verifies the type.
+ int Function([Function x]) l12;
+ // The static function f12 sets `T` to `int`.
+ if (!tIsBool) {
+ x12 = f12 as dynamic;
+ l12 = f12 as dynamic;
+ x12 = confuse(f12);
+ l12 = confuse(f12);
+ }
+
+ Expect.isTrue(m12 is F12);
+ Expect.isTrue(m12 is int Function([Function x]));
+ Expect.isTrue(confuse(m12) is F12);
+ // In checked mode, verifies the type.
+ x12 = m12;
+ l12 = m12;
+ x12 = confuse(m12);
+ l12 = confuse(m12);
+
+ }
+
+ void testF112() {
+ // List<Function> Function(int x)
+ Expect.isTrue(f112 is F112);
+ Expect.isTrue(confuse(f112) is F112);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x) l112;
+ // The static function f112 sets `T` to `int`.
+ if (!tIsBool) {
+ x112 = f112 as dynamic;
+ l112 = f112 as dynamic;
+ x112 = confuse(f112);
+ l112 = confuse(f112);
+ }
+
+ Expect.isTrue(m112 is F112);
+ Expect.isTrue(m112 is List<Function> Function(int x));
+ Expect.isTrue(confuse(m112) is F112);
+ // In checked mode, verifies the type.
+ x112 = m112;
+ l112 = m112;
+ x112 = confuse(m112);
+ l112 = confuse(m112);
+
+ }
+
+ void testF212() {
+ // core.List<core.int> Function(List<T> x)
+ Expect.isTrue(f212 is F212);
+ Expect.isTrue(confuse(f212) is F212);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x) l212;
+ // The static function f212 sets `T` to `int`.
+ if (!tIsBool) {
+ x212 = f212 as dynamic;
+ l212 = f212 as dynamic;
+ x212 = confuse(f212);
+ l212 = confuse(f212);
+ }
+
+ Expect.isTrue(m212 is F212);
+ Expect.isTrue(m212 is core.List<core.int> Function(List<T> x));
+ Expect.isTrue(confuse(m212) is F212);
+ // In checked mode, verifies the type.
+ x212 = m212;
+ l212 = m212;
+ x212 = confuse(m212);
+ l212 = confuse(m212);
+ if (!tIsBool) {
+ Expect.isTrue(f212 is F212<int>);
+ Expect.isFalse(f212 is F212<bool>);
+ Expect.isTrue(confuse(f212) is F212<int>);
+ Expect.isFalse(confuse(f212) is F212<bool>);
+ Expect.equals(tIsDynamic, m212 is F212<bool>);
+ Expect.equals(tIsDynamic, confuse(m212) is F212<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x212 = (f212 as dynamic); });
+ Expect.throws(() { x212 = confuse(f212); });
+ core.List<core.int> Function(List<T> x) l212;
+ Expect.throws(() { l212 = (f212 as dynamic); });
+ Expect.throws(() { l212 = confuse(f212); });
+ }
+ core.List<core.int> Function(List<T> x) l212 = m212;
+ // In checked mode, verifies the type.
+ x212 = m212;
+ x212 = confuse(m212);
+ }
+ }
+
+ void testF312() {
+ // Function(int y, {List<Function> x})
+ Expect.isTrue(f312 is F312);
+ Expect.isTrue(confuse(f312) is F312);
+ // In checked mode, verifies the type.
+ Function(int y, {List<Function> x}) l312;
+ // The static function f312 sets `T` to `int`.
+ if (!tIsBool) {
+ x312 = f312 as dynamic;
+ l312 = f312 as dynamic;
+ x312 = confuse(f312);
+ l312 = confuse(f312);
+ }
+
+ Expect.isTrue(m312 is F312);
+ Expect.isTrue(m312 is Function(int y, {List<Function> x}));
+ Expect.isTrue(confuse(m312) is F312);
+ // In checked mode, verifies the type.
+ x312 = m312;
+ l312 = m312;
+ x312 = confuse(m312);
+ l312 = confuse(m312);
+
+ }
+
+ void testF412() {
+ // int Function(int y, [int x]) Function()
+ Expect.isTrue(f412 is F412);
+ Expect.isTrue(confuse(f412) is F412);
+ // In checked mode, verifies the type.
+ int Function(int y, [int x]) Function() l412;
+ // The static function f412 sets `T` to `int`.
+ if (!tIsBool) {
+ x412 = f412 as dynamic;
+ l412 = f412 as dynamic;
+ x412 = confuse(f412);
+ l412 = confuse(f412);
+ }
+
+ Expect.isTrue(m412 is F412);
+ Expect.isTrue(m412 is int Function(int y, [int x]) Function());
+ Expect.isTrue(confuse(m412) is F412);
+ // In checked mode, verifies the type.
+ x412 = m412;
+ l412 = m412;
+ x412 = confuse(m412);
+ l412 = confuse(m412);
+
+ }
+
+ void testF512() {
+ // int Function(int x1, [List<Function> x2]) Function()
+ Expect.isTrue(f512 is F512);
+ Expect.isTrue(confuse(f512) is F512);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<Function> x2]) Function() l512;
+ // The static function f512 sets `T` to `int`.
+ if (!tIsBool) {
+ x512 = f512 as dynamic;
+ l512 = f512 as dynamic;
+ x512 = confuse(f512);
+ l512 = confuse(f512);
+ }
+
+ Expect.isTrue(m512 is F512);
+ Expect.isTrue(m512 is int Function(int x1, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m512) is F512);
+ // In checked mode, verifies the type.
+ x512 = m512;
+ l512 = m512;
+ x512 = confuse(m512);
+ l512 = confuse(m512);
+
+ }
+
+ void testF612() {
+ // int Function(int x0, {List<T> x}) Function()
+ Expect.isTrue(f612 is F612);
+ Expect.isTrue(confuse(f612) is F612);
+ // In checked mode, verifies the type.
+ int Function(int x0, {List<T> x}) Function() l612;
+ // The static function f612 sets `T` to `int`.
+ if (!tIsBool) {
+ x612 = f612 as dynamic;
+ l612 = f612 as dynamic;
+ x612 = confuse(f612);
+ l612 = confuse(f612);
+ }
+
+ Expect.isTrue(m612 is F612);
+ Expect.isTrue(m612 is int Function(int x0, {List<T> x}) Function());
+ Expect.isTrue(confuse(m612) is F612);
+ // In checked mode, verifies the type.
+ x612 = m612;
+ l612 = m612;
+ x612 = confuse(m612);
+ l612 = confuse(m612);
+ if (!tIsBool) {
+ Expect.isTrue(f612 is F612<int>);
+ Expect.isFalse(f612 is F612<bool>);
+ Expect.isTrue(confuse(f612) is F612<int>);
+ Expect.isFalse(confuse(f612) is F612<bool>);
+ Expect.equals(tIsDynamic, m612 is F612<bool>);
+ Expect.equals(tIsDynamic, confuse(m612) is F612<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x612 = (f612 as dynamic); });
+ Expect.throws(() { x612 = confuse(f612); });
+ int Function(int x0, {List<T> x}) Function() l612;
+ Expect.throws(() { l612 = (f612 as dynamic); });
+ Expect.throws(() { l612 = confuse(f612); });
+ }
+ int Function(int x0, {List<T> x}) Function() l612 = m612;
+ // In checked mode, verifies the type.
+ x612 = m612;
+ x612 = confuse(m612);
+ }
+ }
+
+ void testF712() {
+ // Function Function(List<Function> x) Function()
+ Expect.isTrue(f712 is F712);
+ Expect.isTrue(confuse(f712) is F712);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x) Function() l712;
+ // The static function f712 sets `T` to `int`.
+ if (!tIsBool) {
+ x712 = f712 as dynamic;
+ l712 = f712 as dynamic;
+ x712 = confuse(f712);
+ l712 = confuse(f712);
+ }
+
+ Expect.isTrue(m712 is F712);
+ Expect.isTrue(m712 is Function Function(List<Function> x) Function());
+ Expect.isTrue(confuse(m712) is F712);
+ // In checked mode, verifies the type.
+ x712 = m712;
+ l712 = m712;
+ x712 = confuse(m712);
+ l712 = confuse(m712);
+
+ }
+
+ void testF812() {
+ // Function Function(int y, [List<T> x]) Function()
+ Expect.isTrue(f812 is F812);
+ Expect.isTrue(confuse(f812) is F812);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<T> x]) Function() l812;
+ // The static function f812 sets `T` to `int`.
+ if (!tIsBool) {
+ x812 = f812 as dynamic;
+ l812 = f812 as dynamic;
+ x812 = confuse(f812);
+ l812 = confuse(f812);
+ }
+
+ Expect.isTrue(m812 is F812);
+ Expect.isTrue(m812 is Function Function(int y, [List<T> x]) Function());
+ Expect.isTrue(confuse(m812) is F812);
+ // In checked mode, verifies the type.
+ x812 = m812;
+ l812 = m812;
+ x812 = confuse(m812);
+ l812 = confuse(m812);
+ if (!tIsBool) {
+ Expect.isTrue(f812 is F812<int>);
+ Expect.isFalse(f812 is F812<bool>);
+ Expect.isTrue(confuse(f812) is F812<int>);
+ Expect.isFalse(confuse(f812) is F812<bool>);
+ Expect.equals(tIsDynamic, m812 is F812<bool>);
+ Expect.equals(tIsDynamic, confuse(m812) is F812<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x812 = (f812 as dynamic); });
+ Expect.throws(() { x812 = confuse(f812); });
+ Function Function(int y, [List<T> x]) Function() l812;
+ Expect.throws(() { l812 = (f812 as dynamic); });
+ Expect.throws(() { l812 = confuse(f812); });
+ }
+ Function Function(int y, [List<T> x]) Function() l812 = m812;
+ // In checked mode, verifies the type.
+ x812 = m812;
+ x812 = confuse(m812);
+ }
+ }
+
+ void testF912() {
+ // List<Function> Function([Function x1]) Function()
+ Expect.isTrue(f912 is F912);
+ Expect.isTrue(confuse(f912) is F912);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x1]) Function() l912;
+ // The static function f912 sets `T` to `int`.
+ if (!tIsBool) {
+ x912 = f912 as dynamic;
+ l912 = f912 as dynamic;
+ x912 = confuse(f912);
+ l912 = confuse(f912);
+ }
+
+ Expect.isTrue(m912 is F912);
+ Expect.isTrue(m912 is List<Function> Function([Function x1]) Function());
+ Expect.isTrue(confuse(m912) is F912);
+ // In checked mode, verifies the type.
+ x912 = m912;
+ l912 = m912;
+ x912 = confuse(m912);
+ l912 = confuse(m912);
+
+ }
+
+ void testF1012() {
+ // List<Function> Function({core.List<core.int> x}) Function()
+ Expect.isTrue(f1012 is F1012);
+ Expect.isTrue(confuse(f1012) is F1012);
+ // In checked mode, verifies the type.
+ List<Function> Function({core.List<core.int> x}) Function() l1012;
+ // The static function f1012 sets `T` to `int`.
+ if (!tIsBool) {
+ x1012 = f1012 as dynamic;
+ l1012 = f1012 as dynamic;
+ x1012 = confuse(f1012);
+ l1012 = confuse(f1012);
+ }
+
+ Expect.isTrue(m1012 is F1012);
+ Expect.isTrue(m1012 is List<Function> Function({core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1012) is F1012);
+ // In checked mode, verifies the type.
+ x1012 = m1012;
+ l1012 = m1012;
+ x1012 = confuse(m1012);
+ l1012 = confuse(m1012);
+
+ }
+
+ void testF1112() {
+ // core.List<core.int> Function(int y, {int x}) Function()
+ Expect.isTrue(f1112 is F1112);
+ Expect.isTrue(confuse(f1112) is F1112);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {int x}) Function() l1112;
+ // The static function f1112 sets `T` to `int`.
+ if (!tIsBool) {
+ x1112 = f1112 as dynamic;
+ l1112 = f1112 as dynamic;
+ x1112 = confuse(f1112);
+ l1112 = confuse(f1112);
+ }
+
+ Expect.isTrue(m1112 is F1112);
+ Expect.isTrue(m1112 is core.List<core.int> Function(int y, {int x}) Function());
+ Expect.isTrue(confuse(m1112) is F1112);
+ // In checked mode, verifies the type.
+ x1112 = m1112;
+ l1112 = m1112;
+ x1112 = confuse(m1112);
+ l1112 = confuse(m1112);
+
+ }
+
+ void testF1212() {
+ // core.List<core.int> Function(int x0, [core.List<core.int> x]) Function()
+ Expect.isTrue(f1212 is F1212);
+ Expect.isTrue(confuse(f1212) is F1212);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) Function() l1212;
+ // The static function f1212 sets `T` to `int`.
+ if (!tIsBool) {
+ x1212 = f1212 as dynamic;
+ l1212 = f1212 as dynamic;
+ x1212 = confuse(f1212);
+ l1212 = confuse(f1212);
+ }
+
+ Expect.isTrue(m1212 is F1212);
+ Expect.isTrue(m1212 is core.List<core.int> Function(int x0, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1212) is F1212);
+ // In checked mode, verifies the type.
+ x1212 = m1212;
+ l1212 = m1212;
+ x1212 = confuse(m1212);
+ l1212 = confuse(m1212);
+
+ }
+
+ void testF1312() {
+ // List<T> Function(int x0) Function()
+ Expect.isTrue(f1312 is F1312);
+ Expect.isTrue(confuse(f1312) is F1312);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0) Function() l1312;
+ // The static function f1312 sets `T` to `int`.
+ if (!tIsBool) {
+ x1312 = f1312 as dynamic;
+ l1312 = f1312 as dynamic;
+ x1312 = confuse(f1312);
+ l1312 = confuse(f1312);
+ }
+
+ Expect.isTrue(m1312 is F1312);
+ Expect.isTrue(m1312 is List<T> Function(int x0) Function());
+ Expect.isTrue(confuse(m1312) is F1312);
+ // In checked mode, verifies the type.
+ x1312 = m1312;
+ l1312 = m1312;
+ x1312 = confuse(m1312);
+ l1312 = confuse(m1312);
+ if (!tIsBool) {
+ Expect.isTrue(f1312 is F1312<int>);
+ Expect.isFalse(f1312 is F1312<bool>);
+ Expect.isTrue(confuse(f1312) is F1312<int>);
+ Expect.isFalse(confuse(f1312) is F1312<bool>);
+ Expect.equals(tIsDynamic, m1312 is F1312<bool>);
+ Expect.equals(tIsDynamic, confuse(m1312) is F1312<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1312 = (f1312 as dynamic); });
+ Expect.throws(() { x1312 = confuse(f1312); });
+ List<T> Function(int x0) Function() l1312;
+ Expect.throws(() { l1312 = (f1312 as dynamic); });
+ Expect.throws(() { l1312 = confuse(f1312); });
+ }
+ List<T> Function(int x0) Function() l1312 = m1312;
+ // In checked mode, verifies the type.
+ x1312 = m1312;
+ x1312 = confuse(m1312);
+ }
+ }
+
+ void testF1412() {
+ // List<T> Function(int x, [List<Function> x2]) Function()
+ Expect.isTrue(f1412 is F1412);
+ Expect.isTrue(confuse(f1412) is F1412);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<Function> x2]) Function() l1412;
+ // The static function f1412 sets `T` to `int`.
+ if (!tIsBool) {
+ x1412 = f1412 as dynamic;
+ l1412 = f1412 as dynamic;
+ x1412 = confuse(f1412);
+ l1412 = confuse(f1412);
+ }
+
+ Expect.isTrue(m1412 is F1412);
+ Expect.isTrue(m1412 is List<T> Function(int x, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m1412) is F1412);
+ // In checked mode, verifies the type.
+ x1412 = m1412;
+ l1412 = m1412;
+ x1412 = confuse(m1412);
+ l1412 = confuse(m1412);
+ if (!tIsBool) {
+ Expect.isTrue(f1412 is F1412<int>);
+ Expect.isFalse(f1412 is F1412<bool>);
+ Expect.isTrue(confuse(f1412) is F1412<int>);
+ Expect.isFalse(confuse(f1412) is F1412<bool>);
+ Expect.equals(tIsDynamic, m1412 is F1412<bool>);
+ Expect.equals(tIsDynamic, confuse(m1412) is F1412<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1412 = (f1412 as dynamic); });
+ Expect.throws(() { x1412 = confuse(f1412); });
+ List<T> Function(int x, [List<Function> x2]) Function() l1412;
+ Expect.throws(() { l1412 = (f1412 as dynamic); });
+ Expect.throws(() { l1412 = confuse(f1412); });
+ }
+ List<T> Function(int x, [List<Function> x2]) Function() l1412 = m1412;
+ // In checked mode, verifies the type.
+ x1412 = m1412;
+ x1412 = confuse(m1412);
+ }
+ }
+
+ void testF1512() {
+ // List<T> Function(int y, {List<T> x}) Function()
+ Expect.isTrue(f1512 is F1512);
+ Expect.isTrue(confuse(f1512) is F1512);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<T> x}) Function() l1512;
+ // The static function f1512 sets `T` to `int`.
+ if (!tIsBool) {
+ x1512 = f1512 as dynamic;
+ l1512 = f1512 as dynamic;
+ x1512 = confuse(f1512);
+ l1512 = confuse(f1512);
+ }
+
+ Expect.isTrue(m1512 is F1512);
+ Expect.isTrue(m1512 is List<T> Function(int y, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1512) is F1512);
+ // In checked mode, verifies the type.
+ x1512 = m1512;
+ l1512 = m1512;
+ x1512 = confuse(m1512);
+ l1512 = confuse(m1512);
+ if (!tIsBool) {
+ Expect.isTrue(f1512 is F1512<int>);
+ Expect.isFalse(f1512 is F1512<bool>);
+ Expect.isTrue(confuse(f1512) is F1512<int>);
+ Expect.isFalse(confuse(f1512) is F1512<bool>);
+ Expect.equals(tIsDynamic, m1512 is F1512<bool>);
+ Expect.equals(tIsDynamic, confuse(m1512) is F1512<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1512 = (f1512 as dynamic); });
+ Expect.throws(() { x1512 = confuse(f1512); });
+ List<T> Function(int y, {List<T> x}) Function() l1512;
+ Expect.throws(() { l1512 = (f1512 as dynamic); });
+ Expect.throws(() { l1512 = confuse(f1512); });
+ }
+ List<T> Function(int y, {List<T> x}) Function() l1512 = m1512;
+ // In checked mode, verifies the type.
+ x1512 = m1512;
+ x1512 = confuse(m1512);
+ }
+ }
+
+ void testF1612() {
+ // Function([List<Function> x]) Function()
+ Expect.isTrue(f1612 is F1612);
+ Expect.isTrue(confuse(f1612) is F1612);
+ // In checked mode, verifies the type.
+ Function([List<Function> x]) Function() l1612;
+ // The static function f1612 sets `T` to `int`.
+ if (!tIsBool) {
+ x1612 = f1612 as dynamic;
+ l1612 = f1612 as dynamic;
+ x1612 = confuse(f1612);
+ l1612 = confuse(f1612);
+ }
+
+ Expect.isTrue(m1612 is F1612);
+ Expect.isTrue(m1612 is Function([List<Function> x]) Function());
+ Expect.isTrue(confuse(m1612) is F1612);
+ // In checked mode, verifies the type.
+ x1612 = m1612;
+ l1612 = m1612;
+ x1612 = confuse(m1612);
+ l1612 = confuse(m1612);
+
+ }
+
+ void testF1712() {
+ // Function(List<T> x0) Function()
+ Expect.isTrue(f1712 is F1712);
+ Expect.isTrue(confuse(f1712) is F1712);
+ // In checked mode, verifies the type.
+ Function(List<T> x0) Function() l1712;
+ // The static function f1712 sets `T` to `int`.
+ if (!tIsBool) {
+ x1712 = f1712 as dynamic;
+ l1712 = f1712 as dynamic;
+ x1712 = confuse(f1712);
+ l1712 = confuse(f1712);
+ }
+
+ Expect.isTrue(m1712 is F1712);
+ Expect.isTrue(m1712 is Function(List<T> x0) Function());
+ Expect.isTrue(confuse(m1712) is F1712);
+ // In checked mode, verifies the type.
+ x1712 = m1712;
+ l1712 = m1712;
+ x1712 = confuse(m1712);
+ l1712 = confuse(m1712);
+ if (!tIsBool) {
+ Expect.isTrue(f1712 is F1712<int>);
+ Expect.isFalse(f1712 is F1712<bool>);
+ Expect.isTrue(confuse(f1712) is F1712<int>);
+ Expect.isFalse(confuse(f1712) is F1712<bool>);
+ Expect.equals(tIsDynamic, m1712 is F1712<bool>);
+ Expect.equals(tIsDynamic, confuse(m1712) is F1712<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1712 = (f1712 as dynamic); });
+ Expect.throws(() { x1712 = confuse(f1712); });
+ Function(List<T> x0) Function() l1712;
+ Expect.throws(() { l1712 = (f1712 as dynamic); });
+ Expect.throws(() { l1712 = confuse(f1712); });
+ }
+ Function(List<T> x0) Function() l1712 = m1712;
+ // In checked mode, verifies the type.
+ x1712 = m1712;
+ x1712 = confuse(m1712);
+ }
+ }
+
+ void testF1812() {
+ // List<Function> Function<A>(Function x) Function()
+ Expect.isTrue(f1812 is F1812);
+ Expect.isTrue(confuse(f1812) is F1812);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(Function x) Function() l1812;
+ // The static function f1812 sets `T` to `int`.
+ if (!tIsBool) {
+ x1812 = f1812 as dynamic;
+ l1812 = f1812 as dynamic;
+ x1812 = confuse(f1812);
+ l1812 = confuse(f1812);
+ }
+
+ Expect.isTrue(m1812 is F1812);
+ Expect.isTrue(m1812 is List<Function> Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1812) is F1812);
+ // In checked mode, verifies the type.
+ x1812 = m1812;
+ l1812 = m1812;
+ x1812 = confuse(m1812);
+ l1812 = confuse(m1812);
+
+ }
+
+ void testF1912() {
+ // Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1912 is F1912);
+ Expect.isTrue(confuse(f1912) is F1912);
+ // In checked mode, verifies the type.
+ Function<A>(List<Function> x) Function() l1912;
+ // The static function f1912 sets `T` to `int`.
+ if (!tIsBool) {
+ x1912 = f1912 as dynamic;
+ l1912 = f1912 as dynamic;
+ x1912 = confuse(f1912);
+ l1912 = confuse(f1912);
+ }
+
+ Expect.isTrue(m1912 is F1912);
+ Expect.isTrue(m1912 is Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1912) is F1912);
+ // In checked mode, verifies the type.
+ x1912 = m1912;
+ l1912 = m1912;
+ x1912 = confuse(m1912);
+ l1912 = confuse(m1912);
+
+ }
+
+ void testF2012() {
+ // B Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2012 is F2012);
+ Expect.isTrue(confuse(f2012) is F2012);
+ // In checked mode, verifies the type.
+ B Function(B x) Function<B extends core.int>() l2012;
+ // The static function f2012 sets `T` to `int`.
+ if (!tIsBool) {
+ x2012 = f2012 as dynamic;
+ l2012 = f2012 as dynamic;
+ x2012 = confuse(f2012);
+ l2012 = confuse(f2012);
+ }
+
+ Expect.isTrue(m2012 is F2012);
+ Expect.isTrue(m2012 is B Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2012) is F2012);
+ // In checked mode, verifies the type.
+ x2012 = m2012;
+ l2012 = m2012;
+ x2012 = confuse(m2012);
+ l2012 = confuse(m2012);
+
+ }
+
+
+}
+
+class C13<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, [Function x]) x13;
+ List<Function> Function([int x]) x113;
+ core.List<core.int> Function([List<T> x]) x213;
+ Function(core.List<core.int> x) x313;
+ int Function(int y, [int x]) Function(int x) x413;
+ int Function(int x2, [List<Function> x3]) Function(int x) x513;
+ int Function(int x1, {List<T> x}) Function(int x) x613;
+ Function Function(List<Function> x) Function(int x) x713;
+ Function Function(int y, [List<T> x]) Function(int x) x813;
+ List<Function> Function([Function x1]) Function(int x) x913;
+ List<Function> Function({core.List<core.int> x}) Function(int x) x1013;
+ core.List<core.int> Function(int y, {int x}) Function(int x) x1113;
+ core.List<core.int> Function(int x1, [core.List<core.int> x]) Function(int x) x1213;
+ List<T> Function(int x1) Function(int x) x1313;
+ List<T> Function(int x, [List<Function> x1]) Function(int x) x1413;
+ List<T> Function(int y, {List<T> x}) Function(int x) x1513;
+ Function([List<Function> x]) Function(int x) x1613;
+ Function(List<T> x1) Function(int x) x1713;
+ List<Function> Function<A>(Function x) Function(int x) x1813;
+ Function<A>(List<Function> x) Function(int x) x1913;
+ B Function(B x) Function<B extends core.int>(int x) x2013;
+
+
+ C13({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m13(int x0, [Function x]) => null;
+ List<Function> m113([int x]) => null;
+ core.List<core.int> m213([List<T> x]) => null;
+ m313(core.List<core.int> x) => null;
+ int Function(int y, [int x]) m413(int x) => null;
+ int Function(int x0, [List<Function> x1]) m513(int x) => null;
+ int Function(int x0, {List<T> x}) m613(int x) => null;
+ Function Function(List<Function> x) m713(int x) => null;
+ Function Function(int y, [List<T> x]) m813(int x) => null;
+ List<Function> Function([Function x0]) m913(int x) => null;
+ List<Function> Function({core.List<core.int> x}) m1013(int x) => null;
+ core.List<core.int> Function(int y, {int x}) m1113(int x) => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) m1213(int x) => null;
+ List<T> Function(int x0) m1313(int x) => null;
+ List<T> Function(int x, [List<Function> x0]) m1413(int x) => null;
+ List<T> Function(int y, {List<T> x}) m1513(int x) => null;
+ Function([List<Function> x]) m1613(int x) => null;
+ Function(List<T> x0) m1713(int x) => null;
+ List<Function> Function<A>(Function x) m1813(int x) => null;
+ Function<A>(List<Function> x) m1913(int x) => null;
+ B Function(B x) m2013<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF13();
+ testF113();
+ testF213();
+ testF313();
+ testF413();
+ testF513();
+ testF613();
+ testF713();
+ testF813();
+ testF913();
+ testF1013();
+ testF1113();
+ testF1213();
+ testF1313();
+ testF1413();
+ testF1513();
+ testF1613();
+ testF1713();
+ testF1813();
+ testF1913();
+ testF2013();
+ }
+
+ void testF13() {
+ // int Function(int x0, [Function x])
+ Expect.isTrue(f13 is F13);
+ Expect.isTrue(confuse(f13) is F13);
+ // In checked mode, verifies the type.
+ int Function(int x0, [Function x]) l13;
+ // The static function f13 sets `T` to `int`.
+ if (!tIsBool) {
+ x13 = f13 as dynamic;
+ l13 = f13 as dynamic;
+ x13 = confuse(f13);
+ l13 = confuse(f13);
+ }
+
+ Expect.isTrue(m13 is F13);
+ Expect.isTrue(m13 is int Function(int x0, [Function x]));
+ Expect.isTrue(confuse(m13) is F13);
+ // In checked mode, verifies the type.
+ x13 = m13;
+ l13 = m13;
+ x13 = confuse(m13);
+ l13 = confuse(m13);
+
+ }
+
+ void testF113() {
+ // List<Function> Function([int x])
+ Expect.isTrue(f113 is F113);
+ Expect.isTrue(confuse(f113) is F113);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x]) l113;
+ // The static function f113 sets `T` to `int`.
+ if (!tIsBool) {
+ x113 = f113 as dynamic;
+ l113 = f113 as dynamic;
+ x113 = confuse(f113);
+ l113 = confuse(f113);
+ }
+
+ Expect.isTrue(m113 is F113);
+ Expect.isTrue(m113 is List<Function> Function([int x]));
+ Expect.isTrue(confuse(m113) is F113);
+ // In checked mode, verifies the type.
+ x113 = m113;
+ l113 = m113;
+ x113 = confuse(m113);
+ l113 = confuse(m113);
+
+ }
+
+ void testF213() {
+ // core.List<core.int> Function([List<T> x])
+ Expect.isTrue(f213 is F213);
+ Expect.isTrue(confuse(f213) is F213);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x]) l213;
+ // The static function f213 sets `T` to `int`.
+ if (!tIsBool) {
+ x213 = f213 as dynamic;
+ l213 = f213 as dynamic;
+ x213 = confuse(f213);
+ l213 = confuse(f213);
+ }
+
+ Expect.isTrue(m213 is F213);
+ Expect.isTrue(m213 is core.List<core.int> Function([List<T> x]));
+ Expect.isTrue(confuse(m213) is F213);
+ // In checked mode, verifies the type.
+ x213 = m213;
+ l213 = m213;
+ x213 = confuse(m213);
+ l213 = confuse(m213);
+ if (!tIsBool) {
+ Expect.isTrue(f213 is F213<int>);
+ Expect.isFalse(f213 is F213<bool>);
+ Expect.isTrue(confuse(f213) is F213<int>);
+ Expect.isFalse(confuse(f213) is F213<bool>);
+ Expect.equals(tIsDynamic, m213 is F213<bool>);
+ Expect.equals(tIsDynamic, confuse(m213) is F213<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x213 = (f213 as dynamic); });
+ Expect.throws(() { x213 = confuse(f213); });
+ core.List<core.int> Function([List<T> x]) l213;
+ Expect.throws(() { l213 = (f213 as dynamic); });
+ Expect.throws(() { l213 = confuse(f213); });
+ }
+ core.List<core.int> Function([List<T> x]) l213 = m213;
+ // In checked mode, verifies the type.
+ x213 = m213;
+ x213 = confuse(m213);
+ }
+ }
+
+ void testF313() {
+ // Function(core.List<core.int> x)
+ Expect.isTrue(f313 is F313);
+ Expect.isTrue(confuse(f313) is F313);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x) l313;
+ // The static function f313 sets `T` to `int`.
+ if (!tIsBool) {
+ x313 = f313 as dynamic;
+ l313 = f313 as dynamic;
+ x313 = confuse(f313);
+ l313 = confuse(f313);
+ }
+
+ Expect.isTrue(m313 is F313);
+ Expect.isTrue(m313 is Function(core.List<core.int> x));
+ Expect.isTrue(confuse(m313) is F313);
+ // In checked mode, verifies the type.
+ x313 = m313;
+ l313 = m313;
+ x313 = confuse(m313);
+ l313 = confuse(m313);
+
+ }
+
+ void testF413() {
+ // int Function(int y, [int x]) Function(int x)
+ Expect.isTrue(f413 is F413);
+ Expect.isTrue(confuse(f413) is F413);
+ // In checked mode, verifies the type.
+ int Function(int y, [int x]) Function(int x) l413;
+ // The static function f413 sets `T` to `int`.
+ if (!tIsBool) {
+ x413 = f413 as dynamic;
+ l413 = f413 as dynamic;
+ x413 = confuse(f413);
+ l413 = confuse(f413);
+ }
+
+ Expect.isTrue(m413 is F413);
+ Expect.isTrue(m413 is int Function(int y, [int x]) Function(int x));
+ Expect.isTrue(confuse(m413) is F413);
+ // In checked mode, verifies the type.
+ x413 = m413;
+ l413 = m413;
+ x413 = confuse(m413);
+ l413 = confuse(m413);
+
+ }
+
+ void testF513() {
+ // int Function(int x2, [List<Function> x3]) Function(int x)
+ Expect.isTrue(f513 is F513);
+ Expect.isTrue(confuse(f513) is F513);
+ // In checked mode, verifies the type.
+ int Function(int x2, [List<Function> x3]) Function(int x) l513;
+ // The static function f513 sets `T` to `int`.
+ if (!tIsBool) {
+ x513 = f513 as dynamic;
+ l513 = f513 as dynamic;
+ x513 = confuse(f513);
+ l513 = confuse(f513);
+ }
+
+ Expect.isTrue(m513 is F513);
+ Expect.isTrue(m513 is int Function(int x2, [List<Function> x3]) Function(int x));
+ Expect.isTrue(confuse(m513) is F513);
+ // In checked mode, verifies the type.
+ x513 = m513;
+ l513 = m513;
+ x513 = confuse(m513);
+ l513 = confuse(m513);
+
+ }
+
+ void testF613() {
+ // int Function(int x1, {List<T> x}) Function(int x)
+ Expect.isTrue(f613 is F613);
+ Expect.isTrue(confuse(f613) is F613);
+ // In checked mode, verifies the type.
+ int Function(int x1, {List<T> x}) Function(int x) l613;
+ // The static function f613 sets `T` to `int`.
+ if (!tIsBool) {
+ x613 = f613 as dynamic;
+ l613 = f613 as dynamic;
+ x613 = confuse(f613);
+ l613 = confuse(f613);
+ }
+
+ Expect.isTrue(m613 is F613);
+ Expect.isTrue(m613 is int Function(int x1, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m613) is F613);
+ // In checked mode, verifies the type.
+ x613 = m613;
+ l613 = m613;
+ x613 = confuse(m613);
+ l613 = confuse(m613);
+ if (!tIsBool) {
+ Expect.isTrue(f613 is F613<int>);
+ Expect.isFalse(f613 is F613<bool>);
+ Expect.isTrue(confuse(f613) is F613<int>);
+ Expect.isFalse(confuse(f613) is F613<bool>);
+ Expect.equals(tIsDynamic, m613 is F613<bool>);
+ Expect.equals(tIsDynamic, confuse(m613) is F613<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x613 = (f613 as dynamic); });
+ Expect.throws(() { x613 = confuse(f613); });
+ int Function(int x1, {List<T> x}) Function(int x) l613;
+ Expect.throws(() { l613 = (f613 as dynamic); });
+ Expect.throws(() { l613 = confuse(f613); });
+ }
+ int Function(int x1, {List<T> x}) Function(int x) l613 = m613;
+ // In checked mode, verifies the type.
+ x613 = m613;
+ x613 = confuse(m613);
+ }
+ }
+
+ void testF713() {
+ // Function Function(List<Function> x) Function(int x)
+ Expect.isTrue(f713 is F713);
+ Expect.isTrue(confuse(f713) is F713);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x) Function(int x) l713;
+ // The static function f713 sets `T` to `int`.
+ if (!tIsBool) {
+ x713 = f713 as dynamic;
+ l713 = f713 as dynamic;
+ x713 = confuse(f713);
+ l713 = confuse(f713);
+ }
+
+ Expect.isTrue(m713 is F713);
+ Expect.isTrue(m713 is Function Function(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m713) is F713);
+ // In checked mode, verifies the type.
+ x713 = m713;
+ l713 = m713;
+ x713 = confuse(m713);
+ l713 = confuse(m713);
+
+ }
+
+ void testF813() {
+ // Function Function(int y, [List<T> x]) Function(int x)
+ Expect.isTrue(f813 is F813);
+ Expect.isTrue(confuse(f813) is F813);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<T> x]) Function(int x) l813;
+ // The static function f813 sets `T` to `int`.
+ if (!tIsBool) {
+ x813 = f813 as dynamic;
+ l813 = f813 as dynamic;
+ x813 = confuse(f813);
+ l813 = confuse(f813);
+ }
+
+ Expect.isTrue(m813 is F813);
+ Expect.isTrue(m813 is Function Function(int y, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m813) is F813);
+ // In checked mode, verifies the type.
+ x813 = m813;
+ l813 = m813;
+ x813 = confuse(m813);
+ l813 = confuse(m813);
+ if (!tIsBool) {
+ Expect.isTrue(f813 is F813<int>);
+ Expect.isFalse(f813 is F813<bool>);
+ Expect.isTrue(confuse(f813) is F813<int>);
+ Expect.isFalse(confuse(f813) is F813<bool>);
+ Expect.equals(tIsDynamic, m813 is F813<bool>);
+ Expect.equals(tIsDynamic, confuse(m813) is F813<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x813 = (f813 as dynamic); });
+ Expect.throws(() { x813 = confuse(f813); });
+ Function Function(int y, [List<T> x]) Function(int x) l813;
+ Expect.throws(() { l813 = (f813 as dynamic); });
+ Expect.throws(() { l813 = confuse(f813); });
+ }
+ Function Function(int y, [List<T> x]) Function(int x) l813 = m813;
+ // In checked mode, verifies the type.
+ x813 = m813;
+ x813 = confuse(m813);
+ }
+ }
+
+ void testF913() {
+ // List<Function> Function([Function x1]) Function(int x)
+ Expect.isTrue(f913 is F913);
+ Expect.isTrue(confuse(f913) is F913);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x1]) Function(int x) l913;
+ // The static function f913 sets `T` to `int`.
+ if (!tIsBool) {
+ x913 = f913 as dynamic;
+ l913 = f913 as dynamic;
+ x913 = confuse(f913);
+ l913 = confuse(f913);
+ }
+
+ Expect.isTrue(m913 is F913);
+ Expect.isTrue(m913 is List<Function> Function([Function x1]) Function(int x));
+ Expect.isTrue(confuse(m913) is F913);
+ // In checked mode, verifies the type.
+ x913 = m913;
+ l913 = m913;
+ x913 = confuse(m913);
+ l913 = confuse(m913);
+
+ }
+
+ void testF1013() {
+ // List<Function> Function({core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1013 is F1013);
+ Expect.isTrue(confuse(f1013) is F1013);
+ // In checked mode, verifies the type.
+ List<Function> Function({core.List<core.int> x}) Function(int x) l1013;
+ // The static function f1013 sets `T` to `int`.
+ if (!tIsBool) {
+ x1013 = f1013 as dynamic;
+ l1013 = f1013 as dynamic;
+ x1013 = confuse(f1013);
+ l1013 = confuse(f1013);
+ }
+
+ Expect.isTrue(m1013 is F1013);
+ Expect.isTrue(m1013 is List<Function> Function({core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1013) is F1013);
+ // In checked mode, verifies the type.
+ x1013 = m1013;
+ l1013 = m1013;
+ x1013 = confuse(m1013);
+ l1013 = confuse(m1013);
+
+ }
+
+ void testF1113() {
+ // core.List<core.int> Function(int y, {int x}) Function(int x)
+ Expect.isTrue(f1113 is F1113);
+ Expect.isTrue(confuse(f1113) is F1113);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {int x}) Function(int x) l1113;
+ // The static function f1113 sets `T` to `int`.
+ if (!tIsBool) {
+ x1113 = f1113 as dynamic;
+ l1113 = f1113 as dynamic;
+ x1113 = confuse(f1113);
+ l1113 = confuse(f1113);
+ }
+
+ Expect.isTrue(m1113 is F1113);
+ Expect.isTrue(m1113 is core.List<core.int> Function(int y, {int x}) Function(int x));
+ Expect.isTrue(confuse(m1113) is F1113);
+ // In checked mode, verifies the type.
+ x1113 = m1113;
+ l1113 = m1113;
+ x1113 = confuse(m1113);
+ l1113 = confuse(m1113);
+
+ }
+
+ void testF1213() {
+ // core.List<core.int> Function(int x1, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1213 is F1213);
+ Expect.isTrue(confuse(f1213) is F1213);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [core.List<core.int> x]) Function(int x) l1213;
+ // The static function f1213 sets `T` to `int`.
+ if (!tIsBool) {
+ x1213 = f1213 as dynamic;
+ l1213 = f1213 as dynamic;
+ x1213 = confuse(f1213);
+ l1213 = confuse(f1213);
+ }
+
+ Expect.isTrue(m1213 is F1213);
+ Expect.isTrue(m1213 is core.List<core.int> Function(int x1, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1213) is F1213);
+ // In checked mode, verifies the type.
+ x1213 = m1213;
+ l1213 = m1213;
+ x1213 = confuse(m1213);
+ l1213 = confuse(m1213);
+
+ }
+
+ void testF1313() {
+ // List<T> Function(int x1) Function(int x)
+ Expect.isTrue(f1313 is F1313);
+ Expect.isTrue(confuse(f1313) is F1313);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1) Function(int x) l1313;
+ // The static function f1313 sets `T` to `int`.
+ if (!tIsBool) {
+ x1313 = f1313 as dynamic;
+ l1313 = f1313 as dynamic;
+ x1313 = confuse(f1313);
+ l1313 = confuse(f1313);
+ }
+
+ Expect.isTrue(m1313 is F1313);
+ Expect.isTrue(m1313 is List<T> Function(int x1) Function(int x));
+ Expect.isTrue(confuse(m1313) is F1313);
+ // In checked mode, verifies the type.
+ x1313 = m1313;
+ l1313 = m1313;
+ x1313 = confuse(m1313);
+ l1313 = confuse(m1313);
+ if (!tIsBool) {
+ Expect.isTrue(f1313 is F1313<int>);
+ Expect.isFalse(f1313 is F1313<bool>);
+ Expect.isTrue(confuse(f1313) is F1313<int>);
+ Expect.isFalse(confuse(f1313) is F1313<bool>);
+ Expect.equals(tIsDynamic, m1313 is F1313<bool>);
+ Expect.equals(tIsDynamic, confuse(m1313) is F1313<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1313 = (f1313 as dynamic); });
+ Expect.throws(() { x1313 = confuse(f1313); });
+ List<T> Function(int x1) Function(int x) l1313;
+ Expect.throws(() { l1313 = (f1313 as dynamic); });
+ Expect.throws(() { l1313 = confuse(f1313); });
+ }
+ List<T> Function(int x1) Function(int x) l1313 = m1313;
+ // In checked mode, verifies the type.
+ x1313 = m1313;
+ x1313 = confuse(m1313);
+ }
+ }
+
+ void testF1413() {
+ // List<T> Function(int x, [List<Function> x1]) Function(int x)
+ Expect.isTrue(f1413 is F1413);
+ Expect.isTrue(confuse(f1413) is F1413);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<Function> x1]) Function(int x) l1413;
+ // The static function f1413 sets `T` to `int`.
+ if (!tIsBool) {
+ x1413 = f1413 as dynamic;
+ l1413 = f1413 as dynamic;
+ x1413 = confuse(f1413);
+ l1413 = confuse(f1413);
+ }
+
+ Expect.isTrue(m1413 is F1413);
+ Expect.isTrue(m1413 is List<T> Function(int x, [List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m1413) is F1413);
+ // In checked mode, verifies the type.
+ x1413 = m1413;
+ l1413 = m1413;
+ x1413 = confuse(m1413);
+ l1413 = confuse(m1413);
+ if (!tIsBool) {
+ Expect.isTrue(f1413 is F1413<int>);
+ Expect.isFalse(f1413 is F1413<bool>);
+ Expect.isTrue(confuse(f1413) is F1413<int>);
+ Expect.isFalse(confuse(f1413) is F1413<bool>);
+ Expect.equals(tIsDynamic, m1413 is F1413<bool>);
+ Expect.equals(tIsDynamic, confuse(m1413) is F1413<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1413 = (f1413 as dynamic); });
+ Expect.throws(() { x1413 = confuse(f1413); });
+ List<T> Function(int x, [List<Function> x1]) Function(int x) l1413;
+ Expect.throws(() { l1413 = (f1413 as dynamic); });
+ Expect.throws(() { l1413 = confuse(f1413); });
+ }
+ List<T> Function(int x, [List<Function> x1]) Function(int x) l1413 = m1413;
+ // In checked mode, verifies the type.
+ x1413 = m1413;
+ x1413 = confuse(m1413);
+ }
+ }
+
+ void testF1513() {
+ // List<T> Function(int y, {List<T> x}) Function(int x)
+ Expect.isTrue(f1513 is F1513);
+ Expect.isTrue(confuse(f1513) is F1513);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<T> x}) Function(int x) l1513;
+ // The static function f1513 sets `T` to `int`.
+ if (!tIsBool) {
+ x1513 = f1513 as dynamic;
+ l1513 = f1513 as dynamic;
+ x1513 = confuse(f1513);
+ l1513 = confuse(f1513);
+ }
+
+ Expect.isTrue(m1513 is F1513);
+ Expect.isTrue(m1513 is List<T> Function(int y, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1513) is F1513);
+ // In checked mode, verifies the type.
+ x1513 = m1513;
+ l1513 = m1513;
+ x1513 = confuse(m1513);
+ l1513 = confuse(m1513);
+ if (!tIsBool) {
+ Expect.isTrue(f1513 is F1513<int>);
+ Expect.isFalse(f1513 is F1513<bool>);
+ Expect.isTrue(confuse(f1513) is F1513<int>);
+ Expect.isFalse(confuse(f1513) is F1513<bool>);
+ Expect.equals(tIsDynamic, m1513 is F1513<bool>);
+ Expect.equals(tIsDynamic, confuse(m1513) is F1513<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1513 = (f1513 as dynamic); });
+ Expect.throws(() { x1513 = confuse(f1513); });
+ List<T> Function(int y, {List<T> x}) Function(int x) l1513;
+ Expect.throws(() { l1513 = (f1513 as dynamic); });
+ Expect.throws(() { l1513 = confuse(f1513); });
+ }
+ List<T> Function(int y, {List<T> x}) Function(int x) l1513 = m1513;
+ // In checked mode, verifies the type.
+ x1513 = m1513;
+ x1513 = confuse(m1513);
+ }
+ }
+
+ void testF1613() {
+ // Function([List<Function> x]) Function(int x)
+ Expect.isTrue(f1613 is F1613);
+ Expect.isTrue(confuse(f1613) is F1613);
+ // In checked mode, verifies the type.
+ Function([List<Function> x]) Function(int x) l1613;
+ // The static function f1613 sets `T` to `int`.
+ if (!tIsBool) {
+ x1613 = f1613 as dynamic;
+ l1613 = f1613 as dynamic;
+ x1613 = confuse(f1613);
+ l1613 = confuse(f1613);
+ }
+
+ Expect.isTrue(m1613 is F1613);
+ Expect.isTrue(m1613 is Function([List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1613) is F1613);
+ // In checked mode, verifies the type.
+ x1613 = m1613;
+ l1613 = m1613;
+ x1613 = confuse(m1613);
+ l1613 = confuse(m1613);
+
+ }
+
+ void testF1713() {
+ // Function(List<T> x1) Function(int x)
+ Expect.isTrue(f1713 is F1713);
+ Expect.isTrue(confuse(f1713) is F1713);
+ // In checked mode, verifies the type.
+ Function(List<T> x1) Function(int x) l1713;
+ // The static function f1713 sets `T` to `int`.
+ if (!tIsBool) {
+ x1713 = f1713 as dynamic;
+ l1713 = f1713 as dynamic;
+ x1713 = confuse(f1713);
+ l1713 = confuse(f1713);
+ }
+
+ Expect.isTrue(m1713 is F1713);
+ Expect.isTrue(m1713 is Function(List<T> x1) Function(int x));
+ Expect.isTrue(confuse(m1713) is F1713);
+ // In checked mode, verifies the type.
+ x1713 = m1713;
+ l1713 = m1713;
+ x1713 = confuse(m1713);
+ l1713 = confuse(m1713);
+ if (!tIsBool) {
+ Expect.isTrue(f1713 is F1713<int>);
+ Expect.isFalse(f1713 is F1713<bool>);
+ Expect.isTrue(confuse(f1713) is F1713<int>);
+ Expect.isFalse(confuse(f1713) is F1713<bool>);
+ Expect.equals(tIsDynamic, m1713 is F1713<bool>);
+ Expect.equals(tIsDynamic, confuse(m1713) is F1713<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1713 = (f1713 as dynamic); });
+ Expect.throws(() { x1713 = confuse(f1713); });
+ Function(List<T> x1) Function(int x) l1713;
+ Expect.throws(() { l1713 = (f1713 as dynamic); });
+ Expect.throws(() { l1713 = confuse(f1713); });
+ }
+ Function(List<T> x1) Function(int x) l1713 = m1713;
+ // In checked mode, verifies the type.
+ x1713 = m1713;
+ x1713 = confuse(m1713);
+ }
+ }
+
+ void testF1813() {
+ // List<Function> Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1813 is F1813);
+ Expect.isTrue(confuse(f1813) is F1813);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(Function x) Function(int x) l1813;
+ // The static function f1813 sets `T` to `int`.
+ if (!tIsBool) {
+ x1813 = f1813 as dynamic;
+ l1813 = f1813 as dynamic;
+ x1813 = confuse(f1813);
+ l1813 = confuse(f1813);
+ }
+
+ Expect.isTrue(m1813 is F1813);
+ Expect.isTrue(m1813 is List<Function> Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1813) is F1813);
+ // In checked mode, verifies the type.
+ x1813 = m1813;
+ l1813 = m1813;
+ x1813 = confuse(m1813);
+ l1813 = confuse(m1813);
+
+ }
+
+ void testF1913() {
+ // Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1913 is F1913);
+ Expect.isTrue(confuse(f1913) is F1913);
+ // In checked mode, verifies the type.
+ Function<A>(List<Function> x) Function(int x) l1913;
+ // The static function f1913 sets `T` to `int`.
+ if (!tIsBool) {
+ x1913 = f1913 as dynamic;
+ l1913 = f1913 as dynamic;
+ x1913 = confuse(f1913);
+ l1913 = confuse(f1913);
+ }
+
+ Expect.isTrue(m1913 is F1913);
+ Expect.isTrue(m1913 is Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1913) is F1913);
+ // In checked mode, verifies the type.
+ x1913 = m1913;
+ l1913 = m1913;
+ x1913 = confuse(m1913);
+ l1913 = confuse(m1913);
+
+ }
+
+ void testF2013() {
+ // B Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2013 is F2013);
+ Expect.isTrue(confuse(f2013) is F2013);
+ // In checked mode, verifies the type.
+ B Function(B x) Function<B extends core.int>(int x) l2013;
+ // The static function f2013 sets `T` to `int`.
+ if (!tIsBool) {
+ x2013 = f2013 as dynamic;
+ l2013 = f2013 as dynamic;
+ x2013 = confuse(f2013);
+ l2013 = confuse(f2013);
+ }
+
+ Expect.isTrue(m2013 is F2013);
+ Expect.isTrue(m2013 is B Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2013) is F2013);
+ // In checked mode, verifies the type.
+ x2013 = m2013;
+ l2013 = m2013;
+ x2013 = confuse(m2013);
+ l2013 = confuse(m2013);
+
+ }
+
+
+}
+
+class C14<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, [Function x]) x14;
+ List<Function> Function(int x0, [int x]) x114;
+ core.List<core.int> Function(int x0, [List<T> x]) x214;
+ Function([core.List<core.int> x]) x314;
+ int Function(int y, [int x]) Function<B extends core.int>() x414;
+ int Function(int x2, [List<Function> x3]) Function<B extends core.int>() x514;
+ int Function(int x1, {List<T> x}) Function<B extends core.int>() x614;
+ Function Function(List<Function> x) Function<B extends core.int>() x714;
+ Function Function(int y, [List<T> x]) Function<B extends core.int>() x814;
+ List<Function> Function([Function x1]) Function<B extends core.int>() x914;
+ List<Function> Function({core.List<core.int> x}) Function<B extends core.int>() x1014;
+ core.List<core.int> Function(int y, {int x}) Function<B extends core.int>() x1114;
+ core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() x1214;
+ List<T> Function(int x1) Function<B extends core.int>() x1314;
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>() x1414;
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>() x1514;
+ Function([List<Function> x]) Function<B extends core.int>() x1614;
+ Function(List<T> x1) Function<B extends core.int>() x1714;
+ List<Function> Function<A>(Function x) Function<B extends core.int>() x1814;
+ Function<A>(List<Function> x) Function<B extends core.int>() x1914;
+ List<B> Function(B x) Function<B extends core.int>() x2014;
+
+
+ C14({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m14(int y, [Function x]) => null;
+ List<Function> m114(int x0, [int x]) => null;
+ core.List<core.int> m214(int x0, [List<T> x]) => null;
+ m314([core.List<core.int> x]) => null;
+ int Function(int y, [int x]) m414<B extends core.int>() => null;
+ int Function(int x0, [List<Function> x1]) m514<B extends core.int>() => null;
+ int Function(int x0, {List<T> x}) m614<B extends core.int>() => null;
+ Function Function(List<Function> x) m714<B extends core.int>() => null;
+ Function Function(int y, [List<T> x]) m814<B extends core.int>() => null;
+ List<Function> Function([Function x0]) m914<B extends core.int>() => null;
+ List<Function> Function({core.List<core.int> x}) m1014<B extends core.int>() => null;
+ core.List<core.int> Function(int y, {int x}) m1114<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) m1214<B extends core.int>() => null;
+ List<T> Function(int x0) m1314<B extends core.int>() => null;
+ List<T> Function(int x, [List<Function> x0]) m1414<B extends core.int>() => null;
+ List<T> Function(int y, {List<T> x}) m1514<B extends core.int>() => null;
+ Function([List<Function> x]) m1614<B extends core.int>() => null;
+ Function(List<T> x0) m1714<B extends core.int>() => null;
+ List<Function> Function<A>(Function x) m1814<B extends core.int>() => null;
+ Function<A>(List<Function> x) m1914<B extends core.int>() => null;
+ List<B> Function(B x) m2014<B extends core.int>() => null;
+
+
+ runTests() {
+ testF14();
+ testF114();
+ testF214();
+ testF314();
+ testF414();
+ testF514();
+ testF614();
+ testF714();
+ testF814();
+ testF914();
+ testF1014();
+ testF1114();
+ testF1214();
+ testF1314();
+ testF1414();
+ testF1514();
+ testF1614();
+ testF1714();
+ testF1814();
+ testF1914();
+ testF2014();
+ }
+
+ void testF14() {
+ // int Function(int y, [Function x])
+ Expect.isTrue(f14 is F14);
+ Expect.isTrue(confuse(f14) is F14);
+ // In checked mode, verifies the type.
+ int Function(int y, [Function x]) l14;
+ // The static function f14 sets `T` to `int`.
+ if (!tIsBool) {
+ x14 = f14 as dynamic;
+ l14 = f14 as dynamic;
+ x14 = confuse(f14);
+ l14 = confuse(f14);
+ }
+
+ Expect.isTrue(m14 is F14);
+ Expect.isTrue(m14 is int Function(int y, [Function x]));
+ Expect.isTrue(confuse(m14) is F14);
+ // In checked mode, verifies the type.
+ x14 = m14;
+ l14 = m14;
+ x14 = confuse(m14);
+ l14 = confuse(m14);
+
+ }
+
+ void testF114() {
+ // List<Function> Function(int x0, [int x])
+ Expect.isTrue(f114 is F114);
+ Expect.isTrue(confuse(f114) is F114);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [int x]) l114;
+ // The static function f114 sets `T` to `int`.
+ if (!tIsBool) {
+ x114 = f114 as dynamic;
+ l114 = f114 as dynamic;
+ x114 = confuse(f114);
+ l114 = confuse(f114);
+ }
+
+ Expect.isTrue(m114 is F114);
+ Expect.isTrue(m114 is List<Function> Function(int x0, [int x]));
+ Expect.isTrue(confuse(m114) is F114);
+ // In checked mode, verifies the type.
+ x114 = m114;
+ l114 = m114;
+ x114 = confuse(m114);
+ l114 = confuse(m114);
+
+ }
+
+ void testF214() {
+ // core.List<core.int> Function(int x0, [List<T> x])
+ Expect.isTrue(f214 is F214);
+ Expect.isTrue(confuse(f214) is F214);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [List<T> x]) l214;
+ // The static function f214 sets `T` to `int`.
+ if (!tIsBool) {
+ x214 = f214 as dynamic;
+ l214 = f214 as dynamic;
+ x214 = confuse(f214);
+ l214 = confuse(f214);
+ }
+
+ Expect.isTrue(m214 is F214);
+ Expect.isTrue(m214 is core.List<core.int> Function(int x0, [List<T> x]));
+ Expect.isTrue(confuse(m214) is F214);
+ // In checked mode, verifies the type.
+ x214 = m214;
+ l214 = m214;
+ x214 = confuse(m214);
+ l214 = confuse(m214);
+ if (!tIsBool) {
+ Expect.isTrue(f214 is F214<int>);
+ Expect.isFalse(f214 is F214<bool>);
+ Expect.isTrue(confuse(f214) is F214<int>);
+ Expect.isFalse(confuse(f214) is F214<bool>);
+ Expect.equals(tIsDynamic, m214 is F214<bool>);
+ Expect.equals(tIsDynamic, confuse(m214) is F214<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x214 = (f214 as dynamic); });
+ Expect.throws(() { x214 = confuse(f214); });
+ core.List<core.int> Function(int x0, [List<T> x]) l214;
+ Expect.throws(() { l214 = (f214 as dynamic); });
+ Expect.throws(() { l214 = confuse(f214); });
+ }
+ core.List<core.int> Function(int x0, [List<T> x]) l214 = m214;
+ // In checked mode, verifies the type.
+ x214 = m214;
+ x214 = confuse(m214);
+ }
+ }
+
+ void testF314() {
+ // Function([core.List<core.int> x])
+ Expect.isTrue(f314 is F314);
+ Expect.isTrue(confuse(f314) is F314);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x]) l314;
+ // The static function f314 sets `T` to `int`.
+ if (!tIsBool) {
+ x314 = f314 as dynamic;
+ l314 = f314 as dynamic;
+ x314 = confuse(f314);
+ l314 = confuse(f314);
+ }
+
+ Expect.isTrue(m314 is F314);
+ Expect.isTrue(m314 is Function([core.List<core.int> x]));
+ Expect.isTrue(confuse(m314) is F314);
+ // In checked mode, verifies the type.
+ x314 = m314;
+ l314 = m314;
+ x314 = confuse(m314);
+ l314 = confuse(m314);
+
+ }
+
+ void testF414() {
+ // int Function(int y, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f414 is F414);
+ Expect.isTrue(confuse(f414) is F414);
+ // In checked mode, verifies the type.
+ int Function(int y, [int x]) Function<B extends core.int>() l414;
+ // The static function f414 sets `T` to `int`.
+ if (!tIsBool) {
+ x414 = f414 as dynamic;
+ l414 = f414 as dynamic;
+ x414 = confuse(f414);
+ l414 = confuse(f414);
+ }
+
+ Expect.isTrue(m414 is F414);
+ Expect.isTrue(m414 is int Function(int y, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m414) is F414);
+ // In checked mode, verifies the type.
+ x414 = m414;
+ l414 = m414;
+ x414 = confuse(m414);
+ l414 = confuse(m414);
+
+ }
+
+ void testF514() {
+ // int Function(int x2, [List<Function> x3]) Function<B extends core.int>()
+ Expect.isTrue(f514 is F514);
+ Expect.isTrue(confuse(f514) is F514);
+ // In checked mode, verifies the type.
+ int Function(int x2, [List<Function> x3]) Function<B extends core.int>() l514;
+ // The static function f514 sets `T` to `int`.
+ if (!tIsBool) {
+ x514 = f514 as dynamic;
+ l514 = f514 as dynamic;
+ x514 = confuse(f514);
+ l514 = confuse(f514);
+ }
+
+ Expect.isTrue(m514 is F514);
+ Expect.isTrue(m514 is int Function(int x2, [List<Function> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m514) is F514);
+ // In checked mode, verifies the type.
+ x514 = m514;
+ l514 = m514;
+ x514 = confuse(m514);
+ l514 = confuse(m514);
+
+ }
+
+ void testF614() {
+ // int Function(int x1, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f614 is F614);
+ Expect.isTrue(confuse(f614) is F614);
+ // In checked mode, verifies the type.
+ int Function(int x1, {List<T> x}) Function<B extends core.int>() l614;
+ // The static function f614 sets `T` to `int`.
+ if (!tIsBool) {
+ x614 = f614 as dynamic;
+ l614 = f614 as dynamic;
+ x614 = confuse(f614);
+ l614 = confuse(f614);
+ }
+
+ Expect.isTrue(m614 is F614);
+ Expect.isTrue(m614 is int Function(int x1, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m614) is F614);
+ // In checked mode, verifies the type.
+ x614 = m614;
+ l614 = m614;
+ x614 = confuse(m614);
+ l614 = confuse(m614);
+ if (!tIsBool) {
+ Expect.isTrue(f614 is F614<int>);
+ Expect.isFalse(f614 is F614<bool>);
+ Expect.isTrue(confuse(f614) is F614<int>);
+ Expect.isFalse(confuse(f614) is F614<bool>);
+ Expect.equals(tIsDynamic, m614 is F614<bool>);
+ Expect.equals(tIsDynamic, confuse(m614) is F614<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x614 = (f614 as dynamic); });
+ Expect.throws(() { x614 = confuse(f614); });
+ int Function(int x1, {List<T> x}) Function<B extends core.int>() l614;
+ Expect.throws(() { l614 = (f614 as dynamic); });
+ Expect.throws(() { l614 = confuse(f614); });
+ }
+ int Function(int x1, {List<T> x}) Function<B extends core.int>() l614 = m614;
+ // In checked mode, verifies the type.
+ x614 = m614;
+ x614 = confuse(m614);
+ }
+ }
+
+ void testF714() {
+ // Function Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f714 is F714);
+ Expect.isTrue(confuse(f714) is F714);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x) Function<B extends core.int>() l714;
+ // The static function f714 sets `T` to `int`.
+ if (!tIsBool) {
+ x714 = f714 as dynamic;
+ l714 = f714 as dynamic;
+ x714 = confuse(f714);
+ l714 = confuse(f714);
+ }
+
+ Expect.isTrue(m714 is F714);
+ Expect.isTrue(m714 is Function Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m714) is F714);
+ // In checked mode, verifies the type.
+ x714 = m714;
+ l714 = m714;
+ x714 = confuse(m714);
+ l714 = confuse(m714);
+
+ }
+
+ void testF814() {
+ // Function Function(int y, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f814 is F814);
+ Expect.isTrue(confuse(f814) is F814);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<T> x]) Function<B extends core.int>() l814;
+ // The static function f814 sets `T` to `int`.
+ if (!tIsBool) {
+ x814 = f814 as dynamic;
+ l814 = f814 as dynamic;
+ x814 = confuse(f814);
+ l814 = confuse(f814);
+ }
+
+ Expect.isTrue(m814 is F814);
+ Expect.isTrue(m814 is Function Function(int y, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m814) is F814);
+ // In checked mode, verifies the type.
+ x814 = m814;
+ l814 = m814;
+ x814 = confuse(m814);
+ l814 = confuse(m814);
+ if (!tIsBool) {
+ Expect.isTrue(f814 is F814<int>);
+ Expect.isFalse(f814 is F814<bool>);
+ Expect.isTrue(confuse(f814) is F814<int>);
+ Expect.isFalse(confuse(f814) is F814<bool>);
+ Expect.equals(tIsDynamic, m814 is F814<bool>);
+ Expect.equals(tIsDynamic, confuse(m814) is F814<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x814 = (f814 as dynamic); });
+ Expect.throws(() { x814 = confuse(f814); });
+ Function Function(int y, [List<T> x]) Function<B extends core.int>() l814;
+ Expect.throws(() { l814 = (f814 as dynamic); });
+ Expect.throws(() { l814 = confuse(f814); });
+ }
+ Function Function(int y, [List<T> x]) Function<B extends core.int>() l814 = m814;
+ // In checked mode, verifies the type.
+ x814 = m814;
+ x814 = confuse(m814);
+ }
+ }
+
+ void testF914() {
+ // List<Function> Function([Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f914 is F914);
+ Expect.isTrue(confuse(f914) is F914);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x1]) Function<B extends core.int>() l914;
+ // The static function f914 sets `T` to `int`.
+ if (!tIsBool) {
+ x914 = f914 as dynamic;
+ l914 = f914 as dynamic;
+ x914 = confuse(f914);
+ l914 = confuse(f914);
+ }
+
+ Expect.isTrue(m914 is F914);
+ Expect.isTrue(m914 is List<Function> Function([Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m914) is F914);
+ // In checked mode, verifies the type.
+ x914 = m914;
+ l914 = m914;
+ x914 = confuse(m914);
+ l914 = confuse(m914);
+
+ }
+
+ void testF1014() {
+ // List<Function> Function({core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1014 is F1014);
+ Expect.isTrue(confuse(f1014) is F1014);
+ // In checked mode, verifies the type.
+ List<Function> Function({core.List<core.int> x}) Function<B extends core.int>() l1014;
+ // The static function f1014 sets `T` to `int`.
+ if (!tIsBool) {
+ x1014 = f1014 as dynamic;
+ l1014 = f1014 as dynamic;
+ x1014 = confuse(f1014);
+ l1014 = confuse(f1014);
+ }
+
+ Expect.isTrue(m1014 is F1014);
+ Expect.isTrue(m1014 is List<Function> Function({core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1014) is F1014);
+ // In checked mode, verifies the type.
+ x1014 = m1014;
+ l1014 = m1014;
+ x1014 = confuse(m1014);
+ l1014 = confuse(m1014);
+
+ }
+
+ void testF1114() {
+ // core.List<core.int> Function(int y, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f1114 is F1114);
+ Expect.isTrue(confuse(f1114) is F1114);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {int x}) Function<B extends core.int>() l1114;
+ // The static function f1114 sets `T` to `int`.
+ if (!tIsBool) {
+ x1114 = f1114 as dynamic;
+ l1114 = f1114 as dynamic;
+ x1114 = confuse(f1114);
+ l1114 = confuse(f1114);
+ }
+
+ Expect.isTrue(m1114 is F1114);
+ Expect.isTrue(m1114 is core.List<core.int> Function(int y, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1114) is F1114);
+ // In checked mode, verifies the type.
+ x1114 = m1114;
+ l1114 = m1114;
+ x1114 = confuse(m1114);
+ l1114 = confuse(m1114);
+
+ }
+
+ void testF1214() {
+ // core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1214 is F1214);
+ Expect.isTrue(confuse(f1214) is F1214);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l1214;
+ // The static function f1214 sets `T` to `int`.
+ if (!tIsBool) {
+ x1214 = f1214 as dynamic;
+ l1214 = f1214 as dynamic;
+ x1214 = confuse(f1214);
+ l1214 = confuse(f1214);
+ }
+
+ Expect.isTrue(m1214 is F1214);
+ Expect.isTrue(m1214 is core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1214) is F1214);
+ // In checked mode, verifies the type.
+ x1214 = m1214;
+ l1214 = m1214;
+ x1214 = confuse(m1214);
+ l1214 = confuse(m1214);
+
+ }
+
+ void testF1314() {
+ // List<T> Function(int x1) Function<B extends core.int>()
+ Expect.isTrue(f1314 is F1314);
+ Expect.isTrue(confuse(f1314) is F1314);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1) Function<B extends core.int>() l1314;
+ // The static function f1314 sets `T` to `int`.
+ if (!tIsBool) {
+ x1314 = f1314 as dynamic;
+ l1314 = f1314 as dynamic;
+ x1314 = confuse(f1314);
+ l1314 = confuse(f1314);
+ }
+
+ Expect.isTrue(m1314 is F1314);
+ Expect.isTrue(m1314 is List<T> Function(int x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1314) is F1314);
+ // In checked mode, verifies the type.
+ x1314 = m1314;
+ l1314 = m1314;
+ x1314 = confuse(m1314);
+ l1314 = confuse(m1314);
+ if (!tIsBool) {
+ Expect.isTrue(f1314 is F1314<int>);
+ Expect.isFalse(f1314 is F1314<bool>);
+ Expect.isTrue(confuse(f1314) is F1314<int>);
+ Expect.isFalse(confuse(f1314) is F1314<bool>);
+ Expect.equals(tIsDynamic, m1314 is F1314<bool>);
+ Expect.equals(tIsDynamic, confuse(m1314) is F1314<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1314 = (f1314 as dynamic); });
+ Expect.throws(() { x1314 = confuse(f1314); });
+ List<T> Function(int x1) Function<B extends core.int>() l1314;
+ Expect.throws(() { l1314 = (f1314 as dynamic); });
+ Expect.throws(() { l1314 = confuse(f1314); });
+ }
+ List<T> Function(int x1) Function<B extends core.int>() l1314 = m1314;
+ // In checked mode, verifies the type.
+ x1314 = m1314;
+ x1314 = confuse(m1314);
+ }
+ }
+
+ void testF1414() {
+ // List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1414 is F1414);
+ Expect.isTrue(confuse(f1414) is F1414);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>() l1414;
+ // The static function f1414 sets `T` to `int`.
+ if (!tIsBool) {
+ x1414 = f1414 as dynamic;
+ l1414 = f1414 as dynamic;
+ x1414 = confuse(f1414);
+ l1414 = confuse(f1414);
+ }
+
+ Expect.isTrue(m1414 is F1414);
+ Expect.isTrue(m1414 is List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1414) is F1414);
+ // In checked mode, verifies the type.
+ x1414 = m1414;
+ l1414 = m1414;
+ x1414 = confuse(m1414);
+ l1414 = confuse(m1414);
+ if (!tIsBool) {
+ Expect.isTrue(f1414 is F1414<int>);
+ Expect.isFalse(f1414 is F1414<bool>);
+ Expect.isTrue(confuse(f1414) is F1414<int>);
+ Expect.isFalse(confuse(f1414) is F1414<bool>);
+ Expect.equals(tIsDynamic, m1414 is F1414<bool>);
+ Expect.equals(tIsDynamic, confuse(m1414) is F1414<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1414 = (f1414 as dynamic); });
+ Expect.throws(() { x1414 = confuse(f1414); });
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>() l1414;
+ Expect.throws(() { l1414 = (f1414 as dynamic); });
+ Expect.throws(() { l1414 = confuse(f1414); });
+ }
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>() l1414 = m1414;
+ // In checked mode, verifies the type.
+ x1414 = m1414;
+ x1414 = confuse(m1414);
+ }
+ }
+
+ void testF1514() {
+ // List<T> Function(int y, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1514 is F1514);
+ Expect.isTrue(confuse(f1514) is F1514);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>() l1514;
+ // The static function f1514 sets `T` to `int`.
+ if (!tIsBool) {
+ x1514 = f1514 as dynamic;
+ l1514 = f1514 as dynamic;
+ x1514 = confuse(f1514);
+ l1514 = confuse(f1514);
+ }
+
+ Expect.isTrue(m1514 is F1514);
+ Expect.isTrue(m1514 is List<T> Function(int y, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1514) is F1514);
+ // In checked mode, verifies the type.
+ x1514 = m1514;
+ l1514 = m1514;
+ x1514 = confuse(m1514);
+ l1514 = confuse(m1514);
+ if (!tIsBool) {
+ Expect.isTrue(f1514 is F1514<int>);
+ Expect.isFalse(f1514 is F1514<bool>);
+ Expect.isTrue(confuse(f1514) is F1514<int>);
+ Expect.isFalse(confuse(f1514) is F1514<bool>);
+ Expect.equals(tIsDynamic, m1514 is F1514<bool>);
+ Expect.equals(tIsDynamic, confuse(m1514) is F1514<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1514 = (f1514 as dynamic); });
+ Expect.throws(() { x1514 = confuse(f1514); });
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>() l1514;
+ Expect.throws(() { l1514 = (f1514 as dynamic); });
+ Expect.throws(() { l1514 = confuse(f1514); });
+ }
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>() l1514 = m1514;
+ // In checked mode, verifies the type.
+ x1514 = m1514;
+ x1514 = confuse(m1514);
+ }
+ }
+
+ void testF1614() {
+ // Function([List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1614 is F1614);
+ Expect.isTrue(confuse(f1614) is F1614);
+ // In checked mode, verifies the type.
+ Function([List<Function> x]) Function<B extends core.int>() l1614;
+ // The static function f1614 sets `T` to `int`.
+ if (!tIsBool) {
+ x1614 = f1614 as dynamic;
+ l1614 = f1614 as dynamic;
+ x1614 = confuse(f1614);
+ l1614 = confuse(f1614);
+ }
+
+ Expect.isTrue(m1614 is F1614);
+ Expect.isTrue(m1614 is Function([List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1614) is F1614);
+ // In checked mode, verifies the type.
+ x1614 = m1614;
+ l1614 = m1614;
+ x1614 = confuse(m1614);
+ l1614 = confuse(m1614);
+
+ }
+
+ void testF1714() {
+ // Function(List<T> x1) Function<B extends core.int>()
+ Expect.isTrue(f1714 is F1714);
+ Expect.isTrue(confuse(f1714) is F1714);
+ // In checked mode, verifies the type.
+ Function(List<T> x1) Function<B extends core.int>() l1714;
+ // The static function f1714 sets `T` to `int`.
+ if (!tIsBool) {
+ x1714 = f1714 as dynamic;
+ l1714 = f1714 as dynamic;
+ x1714 = confuse(f1714);
+ l1714 = confuse(f1714);
+ }
+
+ Expect.isTrue(m1714 is F1714);
+ Expect.isTrue(m1714 is Function(List<T> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1714) is F1714);
+ // In checked mode, verifies the type.
+ x1714 = m1714;
+ l1714 = m1714;
+ x1714 = confuse(m1714);
+ l1714 = confuse(m1714);
+ if (!tIsBool) {
+ Expect.isTrue(f1714 is F1714<int>);
+ Expect.isFalse(f1714 is F1714<bool>);
+ Expect.isTrue(confuse(f1714) is F1714<int>);
+ Expect.isFalse(confuse(f1714) is F1714<bool>);
+ Expect.equals(tIsDynamic, m1714 is F1714<bool>);
+ Expect.equals(tIsDynamic, confuse(m1714) is F1714<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1714 = (f1714 as dynamic); });
+ Expect.throws(() { x1714 = confuse(f1714); });
+ Function(List<T> x1) Function<B extends core.int>() l1714;
+ Expect.throws(() { l1714 = (f1714 as dynamic); });
+ Expect.throws(() { l1714 = confuse(f1714); });
+ }
+ Function(List<T> x1) Function<B extends core.int>() l1714 = m1714;
+ // In checked mode, verifies the type.
+ x1714 = m1714;
+ x1714 = confuse(m1714);
+ }
+ }
+
+ void testF1814() {
+ // List<Function> Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1814 is F1814);
+ Expect.isTrue(confuse(f1814) is F1814);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(Function x) Function<B extends core.int>() l1814;
+ // The static function f1814 sets `T` to `int`.
+ if (!tIsBool) {
+ x1814 = f1814 as dynamic;
+ l1814 = f1814 as dynamic;
+ x1814 = confuse(f1814);
+ l1814 = confuse(f1814);
+ }
+
+ Expect.isTrue(m1814 is F1814);
+ Expect.isTrue(m1814 is List<Function> Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1814) is F1814);
+ // In checked mode, verifies the type.
+ x1814 = m1814;
+ l1814 = m1814;
+ x1814 = confuse(m1814);
+ l1814 = confuse(m1814);
+
+ }
+
+ void testF1914() {
+ // Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1914 is F1914);
+ Expect.isTrue(confuse(f1914) is F1914);
+ // In checked mode, verifies the type.
+ Function<A>(List<Function> x) Function<B extends core.int>() l1914;
+ // The static function f1914 sets `T` to `int`.
+ if (!tIsBool) {
+ x1914 = f1914 as dynamic;
+ l1914 = f1914 as dynamic;
+ x1914 = confuse(f1914);
+ l1914 = confuse(f1914);
+ }
+
+ Expect.isTrue(m1914 is F1914);
+ Expect.isTrue(m1914 is Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1914) is F1914);
+ // In checked mode, verifies the type.
+ x1914 = m1914;
+ l1914 = m1914;
+ x1914 = confuse(m1914);
+ l1914 = confuse(m1914);
+
+ }
+
+ void testF2014() {
+ // List<B> Function(B x) Function<B extends core.int>()
+ Expect.isTrue(f2014 is F2014);
+ Expect.isTrue(confuse(f2014) is F2014);
+ // In checked mode, verifies the type.
+ List<B> Function(B x) Function<B extends core.int>() l2014;
+ // The static function f2014 sets `T` to `int`.
+ if (!tIsBool) {
+ x2014 = f2014 as dynamic;
+ l2014 = f2014 as dynamic;
+ x2014 = confuse(f2014);
+ l2014 = confuse(f2014);
+ }
+
+ Expect.isTrue(m2014 is F2014);
+ Expect.isTrue(m2014 is List<B> Function(B x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2014) is F2014);
+ // In checked mode, verifies the type.
+ x2014 = m2014;
+ l2014 = m2014;
+ x2014 = confuse(m2014);
+ l2014 = confuse(m2014);
+
+ }
+
+
+}
+
+class C15<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(Function x0) x15;
+ List<Function> Function(int y, [int x]) x115;
+ core.List<core.int> Function(int y, [List<T> x]) x215;
+ Function(int x0, [core.List<core.int> x]) x315;
+ int Function(int y, [int x]) Function<B extends core.int>(int x) x415;
+ int Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) x515;
+ int Function(int x1, {List<T> x}) Function<B extends core.int>(int x) x615;
+ Function Function(List<Function> x) Function<B extends core.int>(int x) x715;
+ Function Function(int y, [List<T> x]) Function<B extends core.int>(int x) x815;
+ List<Function> Function([Function x1]) Function<B extends core.int>(int x) x915;
+ List<Function> Function({core.List<core.int> x}) Function<B extends core.int>(int x) x1015;
+ core.List<core.int> Function(int y, {int x}) Function<B extends core.int>(int x) x1115;
+ core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) x1215;
+ List<T> Function(int x1) Function<B extends core.int>(int x) x1315;
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) x1415;
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x) x1515;
+ Function([List<Function> x]) Function<B extends core.int>(int x) x1615;
+ Function(List<T> x1) Function<B extends core.int>(int x) x1715;
+ List<Function> Function<A>(Function x) Function<B extends core.int>(int x) x1815;
+ Function<A>(List<Function> x) Function<B extends core.int>(int x) x1915;
+ List<B> Function(B x) Function<B extends core.int>(int x) x2015;
+
+
+ C15({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m15(Function x0) => null;
+ List<Function> m115(int y, [int x]) => null;
+ core.List<core.int> m215(int y, [List<T> x]) => null;
+ m315(int x0, [core.List<core.int> x]) => null;
+ int Function(int y, [int x]) m415<B extends core.int>(int x) => null;
+ int Function(int x0, [List<Function> x1]) m515<B extends core.int>(int x) => null;
+ int Function(int x0, {List<T> x}) m615<B extends core.int>(int x) => null;
+ Function Function(List<Function> x) m715<B extends core.int>(int x) => null;
+ Function Function(int y, [List<T> x]) m815<B extends core.int>(int x) => null;
+ List<Function> Function([Function x0]) m915<B extends core.int>(int x) => null;
+ List<Function> Function({core.List<core.int> x}) m1015<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, {int x}) m1115<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x]) m1215<B extends core.int>(int x) => null;
+ List<T> Function(int x0) m1315<B extends core.int>(int x) => null;
+ List<T> Function(int x, [List<Function> x0]) m1415<B extends core.int>(int x) => null;
+ List<T> Function(int y, {List<T> x}) m1515<B extends core.int>(int x) => null;
+ Function([List<Function> x]) m1615<B extends core.int>(int x) => null;
+ Function(List<T> x0) m1715<B extends core.int>(int x) => null;
+ List<Function> Function<A>(Function x) m1815<B extends core.int>(int x) => null;
+ Function<A>(List<Function> x) m1915<B extends core.int>(int x) => null;
+ List<B> Function(B x) m2015<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF15();
+ testF115();
+ testF215();
+ testF315();
+ testF415();
+ testF515();
+ testF615();
+ testF715();
+ testF815();
+ testF915();
+ testF1015();
+ testF1115();
+ testF1215();
+ testF1315();
+ testF1415();
+ testF1515();
+ testF1615();
+ testF1715();
+ testF1815();
+ testF1915();
+ testF2015();
+ }
+
+ void testF15() {
+ // int Function(Function x0)
+ Expect.isTrue(f15 is F15);
+ Expect.isTrue(confuse(f15) is F15);
+ // In checked mode, verifies the type.
+ int Function(Function x0) l15;
+ // The static function f15 sets `T` to `int`.
+ if (!tIsBool) {
+ x15 = f15 as dynamic;
+ l15 = f15 as dynamic;
+ x15 = confuse(f15);
+ l15 = confuse(f15);
+ }
+
+ Expect.isTrue(m15 is F15);
+ Expect.isTrue(m15 is int Function(Function x0));
+ Expect.isTrue(confuse(m15) is F15);
+ // In checked mode, verifies the type.
+ x15 = m15;
+ l15 = m15;
+ x15 = confuse(m15);
+ l15 = confuse(m15);
+
+ }
+
+ void testF115() {
+ // List<Function> Function(int y, [int x])
+ Expect.isTrue(f115 is F115);
+ Expect.isTrue(confuse(f115) is F115);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [int x]) l115;
+ // The static function f115 sets `T` to `int`.
+ if (!tIsBool) {
+ x115 = f115 as dynamic;
+ l115 = f115 as dynamic;
+ x115 = confuse(f115);
+ l115 = confuse(f115);
+ }
+
+ Expect.isTrue(m115 is F115);
+ Expect.isTrue(m115 is List<Function> Function(int y, [int x]));
+ Expect.isTrue(confuse(m115) is F115);
+ // In checked mode, verifies the type.
+ x115 = m115;
+ l115 = m115;
+ x115 = confuse(m115);
+ l115 = confuse(m115);
+
+ }
+
+ void testF215() {
+ // core.List<core.int> Function(int y, [List<T> x])
+ Expect.isTrue(f215 is F215);
+ Expect.isTrue(confuse(f215) is F215);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<T> x]) l215;
+ // The static function f215 sets `T` to `int`.
+ if (!tIsBool) {
+ x215 = f215 as dynamic;
+ l215 = f215 as dynamic;
+ x215 = confuse(f215);
+ l215 = confuse(f215);
+ }
+
+ Expect.isTrue(m215 is F215);
+ Expect.isTrue(m215 is core.List<core.int> Function(int y, [List<T> x]));
+ Expect.isTrue(confuse(m215) is F215);
+ // In checked mode, verifies the type.
+ x215 = m215;
+ l215 = m215;
+ x215 = confuse(m215);
+ l215 = confuse(m215);
+ if (!tIsBool) {
+ Expect.isTrue(f215 is F215<int>);
+ Expect.isFalse(f215 is F215<bool>);
+ Expect.isTrue(confuse(f215) is F215<int>);
+ Expect.isFalse(confuse(f215) is F215<bool>);
+ Expect.equals(tIsDynamic, m215 is F215<bool>);
+ Expect.equals(tIsDynamic, confuse(m215) is F215<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x215 = (f215 as dynamic); });
+ Expect.throws(() { x215 = confuse(f215); });
+ core.List<core.int> Function(int y, [List<T> x]) l215;
+ Expect.throws(() { l215 = (f215 as dynamic); });
+ Expect.throws(() { l215 = confuse(f215); });
+ }
+ core.List<core.int> Function(int y, [List<T> x]) l215 = m215;
+ // In checked mode, verifies the type.
+ x215 = m215;
+ x215 = confuse(m215);
+ }
+ }
+
+ void testF315() {
+ // Function(int x0, [core.List<core.int> x])
+ Expect.isTrue(f315 is F315);
+ Expect.isTrue(confuse(f315) is F315);
+ // In checked mode, verifies the type.
+ Function(int x0, [core.List<core.int> x]) l315;
+ // The static function f315 sets `T` to `int`.
+ if (!tIsBool) {
+ x315 = f315 as dynamic;
+ l315 = f315 as dynamic;
+ x315 = confuse(f315);
+ l315 = confuse(f315);
+ }
+
+ Expect.isTrue(m315 is F315);
+ Expect.isTrue(m315 is Function(int x0, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m315) is F315);
+ // In checked mode, verifies the type.
+ x315 = m315;
+ l315 = m315;
+ x315 = confuse(m315);
+ l315 = confuse(m315);
+
+ }
+
+ void testF415() {
+ // int Function(int y, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f415 is F415);
+ Expect.isTrue(confuse(f415) is F415);
+ // In checked mode, verifies the type.
+ int Function(int y, [int x]) Function<B extends core.int>(int x) l415;
+ // The static function f415 sets `T` to `int`.
+ if (!tIsBool) {
+ x415 = f415 as dynamic;
+ l415 = f415 as dynamic;
+ x415 = confuse(f415);
+ l415 = confuse(f415);
+ }
+
+ Expect.isTrue(m415 is F415);
+ Expect.isTrue(m415 is int Function(int y, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m415) is F415);
+ // In checked mode, verifies the type.
+ x415 = m415;
+ l415 = m415;
+ x415 = confuse(m415);
+ l415 = confuse(m415);
+
+ }
+
+ void testF515() {
+ // int Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f515 is F515);
+ Expect.isTrue(confuse(f515) is F515);
+ // In checked mode, verifies the type.
+ int Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l515;
+ // The static function f515 sets `T` to `int`.
+ if (!tIsBool) {
+ x515 = f515 as dynamic;
+ l515 = f515 as dynamic;
+ x515 = confuse(f515);
+ l515 = confuse(f515);
+ }
+
+ Expect.isTrue(m515 is F515);
+ Expect.isTrue(m515 is int Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m515) is F515);
+ // In checked mode, verifies the type.
+ x515 = m515;
+ l515 = m515;
+ x515 = confuse(m515);
+ l515 = confuse(m515);
+
+ }
+
+ void testF615() {
+ // int Function(int x1, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f615 is F615);
+ Expect.isTrue(confuse(f615) is F615);
+ // In checked mode, verifies the type.
+ int Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l615;
+ // The static function f615 sets `T` to `int`.
+ if (!tIsBool) {
+ x615 = f615 as dynamic;
+ l615 = f615 as dynamic;
+ x615 = confuse(f615);
+ l615 = confuse(f615);
+ }
+
+ Expect.isTrue(m615 is F615);
+ Expect.isTrue(m615 is int Function(int x1, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m615) is F615);
+ // In checked mode, verifies the type.
+ x615 = m615;
+ l615 = m615;
+ x615 = confuse(m615);
+ l615 = confuse(m615);
+ if (!tIsBool) {
+ Expect.isTrue(f615 is F615<int>);
+ Expect.isFalse(f615 is F615<bool>);
+ Expect.isTrue(confuse(f615) is F615<int>);
+ Expect.isFalse(confuse(f615) is F615<bool>);
+ Expect.equals(tIsDynamic, m615 is F615<bool>);
+ Expect.equals(tIsDynamic, confuse(m615) is F615<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x615 = (f615 as dynamic); });
+ Expect.throws(() { x615 = confuse(f615); });
+ int Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l615;
+ Expect.throws(() { l615 = (f615 as dynamic); });
+ Expect.throws(() { l615 = confuse(f615); });
+ }
+ int Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l615 = m615;
+ // In checked mode, verifies the type.
+ x615 = m615;
+ x615 = confuse(m615);
+ }
+ }
+
+ void testF715() {
+ // Function Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f715 is F715);
+ Expect.isTrue(confuse(f715) is F715);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x) Function<B extends core.int>(int x) l715;
+ // The static function f715 sets `T` to `int`.
+ if (!tIsBool) {
+ x715 = f715 as dynamic;
+ l715 = f715 as dynamic;
+ x715 = confuse(f715);
+ l715 = confuse(f715);
+ }
+
+ Expect.isTrue(m715 is F715);
+ Expect.isTrue(m715 is Function Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m715) is F715);
+ // In checked mode, verifies the type.
+ x715 = m715;
+ l715 = m715;
+ x715 = confuse(m715);
+ l715 = confuse(m715);
+
+ }
+
+ void testF815() {
+ // Function Function(int y, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f815 is F815);
+ Expect.isTrue(confuse(f815) is F815);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<T> x]) Function<B extends core.int>(int x) l815;
+ // The static function f815 sets `T` to `int`.
+ if (!tIsBool) {
+ x815 = f815 as dynamic;
+ l815 = f815 as dynamic;
+ x815 = confuse(f815);
+ l815 = confuse(f815);
+ }
+
+ Expect.isTrue(m815 is F815);
+ Expect.isTrue(m815 is Function Function(int y, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m815) is F815);
+ // In checked mode, verifies the type.
+ x815 = m815;
+ l815 = m815;
+ x815 = confuse(m815);
+ l815 = confuse(m815);
+ if (!tIsBool) {
+ Expect.isTrue(f815 is F815<int>);
+ Expect.isFalse(f815 is F815<bool>);
+ Expect.isTrue(confuse(f815) is F815<int>);
+ Expect.isFalse(confuse(f815) is F815<bool>);
+ Expect.equals(tIsDynamic, m815 is F815<bool>);
+ Expect.equals(tIsDynamic, confuse(m815) is F815<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x815 = (f815 as dynamic); });
+ Expect.throws(() { x815 = confuse(f815); });
+ Function Function(int y, [List<T> x]) Function<B extends core.int>(int x) l815;
+ Expect.throws(() { l815 = (f815 as dynamic); });
+ Expect.throws(() { l815 = confuse(f815); });
+ }
+ Function Function(int y, [List<T> x]) Function<B extends core.int>(int x) l815 = m815;
+ // In checked mode, verifies the type.
+ x815 = m815;
+ x815 = confuse(m815);
+ }
+ }
+
+ void testF915() {
+ // List<Function> Function([Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f915 is F915);
+ Expect.isTrue(confuse(f915) is F915);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x1]) Function<B extends core.int>(int x) l915;
+ // The static function f915 sets `T` to `int`.
+ if (!tIsBool) {
+ x915 = f915 as dynamic;
+ l915 = f915 as dynamic;
+ x915 = confuse(f915);
+ l915 = confuse(f915);
+ }
+
+ Expect.isTrue(m915 is F915);
+ Expect.isTrue(m915 is List<Function> Function([Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m915) is F915);
+ // In checked mode, verifies the type.
+ x915 = m915;
+ l915 = m915;
+ x915 = confuse(m915);
+ l915 = confuse(m915);
+
+ }
+
+ void testF1015() {
+ // List<Function> Function({core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1015 is F1015);
+ Expect.isTrue(confuse(f1015) is F1015);
+ // In checked mode, verifies the type.
+ List<Function> Function({core.List<core.int> x}) Function<B extends core.int>(int x) l1015;
+ // The static function f1015 sets `T` to `int`.
+ if (!tIsBool) {
+ x1015 = f1015 as dynamic;
+ l1015 = f1015 as dynamic;
+ x1015 = confuse(f1015);
+ l1015 = confuse(f1015);
+ }
+
+ Expect.isTrue(m1015 is F1015);
+ Expect.isTrue(m1015 is List<Function> Function({core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1015) is F1015);
+ // In checked mode, verifies the type.
+ x1015 = m1015;
+ l1015 = m1015;
+ x1015 = confuse(m1015);
+ l1015 = confuse(m1015);
+
+ }
+
+ void testF1115() {
+ // core.List<core.int> Function(int y, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1115 is F1115);
+ Expect.isTrue(confuse(f1115) is F1115);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {int x}) Function<B extends core.int>(int x) l1115;
+ // The static function f1115 sets `T` to `int`.
+ if (!tIsBool) {
+ x1115 = f1115 as dynamic;
+ l1115 = f1115 as dynamic;
+ x1115 = confuse(f1115);
+ l1115 = confuse(f1115);
+ }
+
+ Expect.isTrue(m1115 is F1115);
+ Expect.isTrue(m1115 is core.List<core.int> Function(int y, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1115) is F1115);
+ // In checked mode, verifies the type.
+ x1115 = m1115;
+ l1115 = m1115;
+ x1115 = confuse(m1115);
+ l1115 = confuse(m1115);
+
+ }
+
+ void testF1215() {
+ // core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1215 is F1215);
+ Expect.isTrue(confuse(f1215) is F1215);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l1215;
+ // The static function f1215 sets `T` to `int`.
+ if (!tIsBool) {
+ x1215 = f1215 as dynamic;
+ l1215 = f1215 as dynamic;
+ x1215 = confuse(f1215);
+ l1215 = confuse(f1215);
+ }
+
+ Expect.isTrue(m1215 is F1215);
+ Expect.isTrue(m1215 is core.List<core.int> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1215) is F1215);
+ // In checked mode, verifies the type.
+ x1215 = m1215;
+ l1215 = m1215;
+ x1215 = confuse(m1215);
+ l1215 = confuse(m1215);
+
+ }
+
+ void testF1315() {
+ // List<T> Function(int x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1315 is F1315);
+ Expect.isTrue(confuse(f1315) is F1315);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1) Function<B extends core.int>(int x) l1315;
+ // The static function f1315 sets `T` to `int`.
+ if (!tIsBool) {
+ x1315 = f1315 as dynamic;
+ l1315 = f1315 as dynamic;
+ x1315 = confuse(f1315);
+ l1315 = confuse(f1315);
+ }
+
+ Expect.isTrue(m1315 is F1315);
+ Expect.isTrue(m1315 is List<T> Function(int x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1315) is F1315);
+ // In checked mode, verifies the type.
+ x1315 = m1315;
+ l1315 = m1315;
+ x1315 = confuse(m1315);
+ l1315 = confuse(m1315);
+ if (!tIsBool) {
+ Expect.isTrue(f1315 is F1315<int>);
+ Expect.isFalse(f1315 is F1315<bool>);
+ Expect.isTrue(confuse(f1315) is F1315<int>);
+ Expect.isFalse(confuse(f1315) is F1315<bool>);
+ Expect.equals(tIsDynamic, m1315 is F1315<bool>);
+ Expect.equals(tIsDynamic, confuse(m1315) is F1315<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1315 = (f1315 as dynamic); });
+ Expect.throws(() { x1315 = confuse(f1315); });
+ List<T> Function(int x1) Function<B extends core.int>(int x) l1315;
+ Expect.throws(() { l1315 = (f1315 as dynamic); });
+ Expect.throws(() { l1315 = confuse(f1315); });
+ }
+ List<T> Function(int x1) Function<B extends core.int>(int x) l1315 = m1315;
+ // In checked mode, verifies the type.
+ x1315 = m1315;
+ x1315 = confuse(m1315);
+ }
+ }
+
+ void testF1415() {
+ // List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1415 is F1415);
+ Expect.isTrue(confuse(f1415) is F1415);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l1415;
+ // The static function f1415 sets `T` to `int`.
+ if (!tIsBool) {
+ x1415 = f1415 as dynamic;
+ l1415 = f1415 as dynamic;
+ x1415 = confuse(f1415);
+ l1415 = confuse(f1415);
+ }
+
+ Expect.isTrue(m1415 is F1415);
+ Expect.isTrue(m1415 is List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1415) is F1415);
+ // In checked mode, verifies the type.
+ x1415 = m1415;
+ l1415 = m1415;
+ x1415 = confuse(m1415);
+ l1415 = confuse(m1415);
+ if (!tIsBool) {
+ Expect.isTrue(f1415 is F1415<int>);
+ Expect.isFalse(f1415 is F1415<bool>);
+ Expect.isTrue(confuse(f1415) is F1415<int>);
+ Expect.isFalse(confuse(f1415) is F1415<bool>);
+ Expect.equals(tIsDynamic, m1415 is F1415<bool>);
+ Expect.equals(tIsDynamic, confuse(m1415) is F1415<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1415 = (f1415 as dynamic); });
+ Expect.throws(() { x1415 = confuse(f1415); });
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l1415;
+ Expect.throws(() { l1415 = (f1415 as dynamic); });
+ Expect.throws(() { l1415 = confuse(f1415); });
+ }
+ List<T> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l1415 = m1415;
+ // In checked mode, verifies the type.
+ x1415 = m1415;
+ x1415 = confuse(m1415);
+ }
+ }
+
+ void testF1515() {
+ // List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1515 is F1515);
+ Expect.isTrue(confuse(f1515) is F1515);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1515;
+ // The static function f1515 sets `T` to `int`.
+ if (!tIsBool) {
+ x1515 = f1515 as dynamic;
+ l1515 = f1515 as dynamic;
+ x1515 = confuse(f1515);
+ l1515 = confuse(f1515);
+ }
+
+ Expect.isTrue(m1515 is F1515);
+ Expect.isTrue(m1515 is List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1515) is F1515);
+ // In checked mode, verifies the type.
+ x1515 = m1515;
+ l1515 = m1515;
+ x1515 = confuse(m1515);
+ l1515 = confuse(m1515);
+ if (!tIsBool) {
+ Expect.isTrue(f1515 is F1515<int>);
+ Expect.isFalse(f1515 is F1515<bool>);
+ Expect.isTrue(confuse(f1515) is F1515<int>);
+ Expect.isFalse(confuse(f1515) is F1515<bool>);
+ Expect.equals(tIsDynamic, m1515 is F1515<bool>);
+ Expect.equals(tIsDynamic, confuse(m1515) is F1515<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1515 = (f1515 as dynamic); });
+ Expect.throws(() { x1515 = confuse(f1515); });
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1515;
+ Expect.throws(() { l1515 = (f1515 as dynamic); });
+ Expect.throws(() { l1515 = confuse(f1515); });
+ }
+ List<T> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1515 = m1515;
+ // In checked mode, verifies the type.
+ x1515 = m1515;
+ x1515 = confuse(m1515);
+ }
+ }
+
+ void testF1615() {
+ // Function([List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1615 is F1615);
+ Expect.isTrue(confuse(f1615) is F1615);
+ // In checked mode, verifies the type.
+ Function([List<Function> x]) Function<B extends core.int>(int x) l1615;
+ // The static function f1615 sets `T` to `int`.
+ if (!tIsBool) {
+ x1615 = f1615 as dynamic;
+ l1615 = f1615 as dynamic;
+ x1615 = confuse(f1615);
+ l1615 = confuse(f1615);
+ }
+
+ Expect.isTrue(m1615 is F1615);
+ Expect.isTrue(m1615 is Function([List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1615) is F1615);
+ // In checked mode, verifies the type.
+ x1615 = m1615;
+ l1615 = m1615;
+ x1615 = confuse(m1615);
+ l1615 = confuse(m1615);
+
+ }
+
+ void testF1715() {
+ // Function(List<T> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1715 is F1715);
+ Expect.isTrue(confuse(f1715) is F1715);
+ // In checked mode, verifies the type.
+ Function(List<T> x1) Function<B extends core.int>(int x) l1715;
+ // The static function f1715 sets `T` to `int`.
+ if (!tIsBool) {
+ x1715 = f1715 as dynamic;
+ l1715 = f1715 as dynamic;
+ x1715 = confuse(f1715);
+ l1715 = confuse(f1715);
+ }
+
+ Expect.isTrue(m1715 is F1715);
+ Expect.isTrue(m1715 is Function(List<T> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1715) is F1715);
+ // In checked mode, verifies the type.
+ x1715 = m1715;
+ l1715 = m1715;
+ x1715 = confuse(m1715);
+ l1715 = confuse(m1715);
+ if (!tIsBool) {
+ Expect.isTrue(f1715 is F1715<int>);
+ Expect.isFalse(f1715 is F1715<bool>);
+ Expect.isTrue(confuse(f1715) is F1715<int>);
+ Expect.isFalse(confuse(f1715) is F1715<bool>);
+ Expect.equals(tIsDynamic, m1715 is F1715<bool>);
+ Expect.equals(tIsDynamic, confuse(m1715) is F1715<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1715 = (f1715 as dynamic); });
+ Expect.throws(() { x1715 = confuse(f1715); });
+ Function(List<T> x1) Function<B extends core.int>(int x) l1715;
+ Expect.throws(() { l1715 = (f1715 as dynamic); });
+ Expect.throws(() { l1715 = confuse(f1715); });
+ }
+ Function(List<T> x1) Function<B extends core.int>(int x) l1715 = m1715;
+ // In checked mode, verifies the type.
+ x1715 = m1715;
+ x1715 = confuse(m1715);
+ }
+ }
+
+ void testF1815() {
+ // List<Function> Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1815 is F1815);
+ Expect.isTrue(confuse(f1815) is F1815);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(Function x) Function<B extends core.int>(int x) l1815;
+ // The static function f1815 sets `T` to `int`.
+ if (!tIsBool) {
+ x1815 = f1815 as dynamic;
+ l1815 = f1815 as dynamic;
+ x1815 = confuse(f1815);
+ l1815 = confuse(f1815);
+ }
+
+ Expect.isTrue(m1815 is F1815);
+ Expect.isTrue(m1815 is List<Function> Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1815) is F1815);
+ // In checked mode, verifies the type.
+ x1815 = m1815;
+ l1815 = m1815;
+ x1815 = confuse(m1815);
+ l1815 = confuse(m1815);
+
+ }
+
+ void testF1915() {
+ // Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1915 is F1915);
+ Expect.isTrue(confuse(f1915) is F1915);
+ // In checked mode, verifies the type.
+ Function<A>(List<Function> x) Function<B extends core.int>(int x) l1915;
+ // The static function f1915 sets `T` to `int`.
+ if (!tIsBool) {
+ x1915 = f1915 as dynamic;
+ l1915 = f1915 as dynamic;
+ x1915 = confuse(f1915);
+ l1915 = confuse(f1915);
+ }
+
+ Expect.isTrue(m1915 is F1915);
+ Expect.isTrue(m1915 is Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1915) is F1915);
+ // In checked mode, verifies the type.
+ x1915 = m1915;
+ l1915 = m1915;
+ x1915 = confuse(m1915);
+ l1915 = confuse(m1915);
+
+ }
+
+ void testF2015() {
+ // List<B> Function(B x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2015 is F2015);
+ Expect.isTrue(confuse(f2015) is F2015);
+ // In checked mode, verifies the type.
+ List<B> Function(B x) Function<B extends core.int>(int x) l2015;
+ // The static function f2015 sets `T` to `int`.
+ if (!tIsBool) {
+ x2015 = f2015 as dynamic;
+ l2015 = f2015 as dynamic;
+ x2015 = confuse(f2015);
+ l2015 = confuse(f2015);
+ }
+
+ Expect.isTrue(m2015 is F2015);
+ Expect.isTrue(m2015 is List<B> Function(B x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2015) is F2015);
+ // In checked mode, verifies the type.
+ x2015 = m2015;
+ l2015 = m2015;
+ x2015 = confuse(m2015);
+ l2015 = confuse(m2015);
+
+ }
+
+
+}
+
+class C16<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([Function x1]) x16;
+ List<Function> Function(int x0) x116;
+ core.List<core.int> Function(List<T> x0) x216;
+ Function(int y, [core.List<core.int> x]) x316;
+ int Function(int x0) Function() x416;
+ int Function(int x, [List<Function> x2]) Function() x516;
+ int Function(int y, {List<T> x}) Function() x616;
+ Function Function([List<Function> x]) Function() x716;
+ Function Function(List<T> x0) Function() x816;
+ List<Function> Function(int x1, [Function x2]) Function() x916;
+ List<Function> Function(int x0, {core.List<core.int> x}) Function() x1016;
+ core.List<core.int> Function(Function x) Function() x1116;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function() x1216;
+ List<T> Function([int x1]) Function() x1316;
+ List<T> Function({List<Function> x}) Function() x1416;
+ List<T> Function() Function() x1516;
+ Function(int x0, [List<Function> x]) Function() x1616;
+ Function([List<T> x1]) Function() x1716;
+ List<Function> Function<A>(List<Function> x) Function() x1816;
+ Function<A>(core.List<core.int> x) Function() x1916;
+ B Function(int x) Function<B extends core.int>() x2016;
+
+
+ C16({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m16([Function x0]) => null;
+ List<Function> m116(int x0) => null;
+ core.List<core.int> m216(List<T> x0) => null;
+ m316(int y, [core.List<core.int> x]) => null;
+ int Function(int x0) m416() => null;
+ int Function(int x, [List<Function> x0]) m516() => null;
+ int Function(int y, {List<T> x}) m616() => null;
+ Function Function([List<Function> x]) m716() => null;
+ Function Function(List<T> x0) m816() => null;
+ List<Function> Function(int x0, [Function x1]) m916() => null;
+ List<Function> Function(int x0, {core.List<core.int> x}) m1016() => null;
+ core.List<core.int> Function(Function x) m1116() => null;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) m1216() => null;
+ List<T> Function([int x0]) m1316() => null;
+ List<T> Function({List<Function> x}) m1416() => null;
+ List<T> Function() m1516() => null;
+ Function(int x0, [List<Function> x]) m1616() => null;
+ Function([List<T> x0]) m1716() => null;
+ List<Function> Function<A>(List<Function> x) m1816() => null;
+ Function<A>(core.List<core.int> x) m1916() => null;
+ B Function(int x) m2016<B extends core.int>() => null;
+
+
+ runTests() {
+ testF16();
+ testF116();
+ testF216();
+ testF316();
+ testF416();
+ testF516();
+ testF616();
+ testF716();
+ testF816();
+ testF916();
+ testF1016();
+ testF1116();
+ testF1216();
+ testF1316();
+ testF1416();
+ testF1516();
+ testF1616();
+ testF1716();
+ testF1816();
+ testF1916();
+ testF2016();
+ }
+
+ void testF16() {
+ // int Function([Function x1])
+ Expect.isTrue(f16 is F16);
+ Expect.isTrue(confuse(f16) is F16);
+ // In checked mode, verifies the type.
+ int Function([Function x1]) l16;
+ // The static function f16 sets `T` to `int`.
+ if (!tIsBool) {
+ x16 = f16 as dynamic;
+ l16 = f16 as dynamic;
+ x16 = confuse(f16);
+ l16 = confuse(f16);
+ }
+
+ Expect.isTrue(m16 is F16);
+ Expect.isTrue(m16 is int Function([Function x1]));
+ Expect.isTrue(confuse(m16) is F16);
+ // In checked mode, verifies the type.
+ x16 = m16;
+ l16 = m16;
+ x16 = confuse(m16);
+ l16 = confuse(m16);
+
+ }
+
+ void testF116() {
+ // List<Function> Function(int x0)
+ Expect.isTrue(f116 is F116);
+ Expect.isTrue(confuse(f116) is F116);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0) l116;
+ // The static function f116 sets `T` to `int`.
+ if (!tIsBool) {
+ x116 = f116 as dynamic;
+ l116 = f116 as dynamic;
+ x116 = confuse(f116);
+ l116 = confuse(f116);
+ }
+
+ Expect.isTrue(m116 is F116);
+ Expect.isTrue(m116 is List<Function> Function(int x0));
+ Expect.isTrue(confuse(m116) is F116);
+ // In checked mode, verifies the type.
+ x116 = m116;
+ l116 = m116;
+ x116 = confuse(m116);
+ l116 = confuse(m116);
+
+ }
+
+ void testF216() {
+ // core.List<core.int> Function(List<T> x0)
+ Expect.isTrue(f216 is F216);
+ Expect.isTrue(confuse(f216) is F216);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x0) l216;
+ // The static function f216 sets `T` to `int`.
+ if (!tIsBool) {
+ x216 = f216 as dynamic;
+ l216 = f216 as dynamic;
+ x216 = confuse(f216);
+ l216 = confuse(f216);
+ }
+
+ Expect.isTrue(m216 is F216);
+ Expect.isTrue(m216 is core.List<core.int> Function(List<T> x0));
+ Expect.isTrue(confuse(m216) is F216);
+ // In checked mode, verifies the type.
+ x216 = m216;
+ l216 = m216;
+ x216 = confuse(m216);
+ l216 = confuse(m216);
+ if (!tIsBool) {
+ Expect.isTrue(f216 is F216<int>);
+ Expect.isFalse(f216 is F216<bool>);
+ Expect.isTrue(confuse(f216) is F216<int>);
+ Expect.isFalse(confuse(f216) is F216<bool>);
+ Expect.equals(tIsDynamic, m216 is F216<bool>);
+ Expect.equals(tIsDynamic, confuse(m216) is F216<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x216 = (f216 as dynamic); });
+ Expect.throws(() { x216 = confuse(f216); });
+ core.List<core.int> Function(List<T> x0) l216;
+ Expect.throws(() { l216 = (f216 as dynamic); });
+ Expect.throws(() { l216 = confuse(f216); });
+ }
+ core.List<core.int> Function(List<T> x0) l216 = m216;
+ // In checked mode, verifies the type.
+ x216 = m216;
+ x216 = confuse(m216);
+ }
+ }
+
+ void testF316() {
+ // Function(int y, [core.List<core.int> x])
+ Expect.isTrue(f316 is F316);
+ Expect.isTrue(confuse(f316) is F316);
+ // In checked mode, verifies the type.
+ Function(int y, [core.List<core.int> x]) l316;
+ // The static function f316 sets `T` to `int`.
+ if (!tIsBool) {
+ x316 = f316 as dynamic;
+ l316 = f316 as dynamic;
+ x316 = confuse(f316);
+ l316 = confuse(f316);
+ }
+
+ Expect.isTrue(m316 is F316);
+ Expect.isTrue(m316 is Function(int y, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m316) is F316);
+ // In checked mode, verifies the type.
+ x316 = m316;
+ l316 = m316;
+ x316 = confuse(m316);
+ l316 = confuse(m316);
+
+ }
+
+ void testF416() {
+ // int Function(int x0) Function()
+ Expect.isTrue(f416 is F416);
+ Expect.isTrue(confuse(f416) is F416);
+ // In checked mode, verifies the type.
+ int Function(int x0) Function() l416;
+ // The static function f416 sets `T` to `int`.
+ if (!tIsBool) {
+ x416 = f416 as dynamic;
+ l416 = f416 as dynamic;
+ x416 = confuse(f416);
+ l416 = confuse(f416);
+ }
+
+ Expect.isTrue(m416 is F416);
+ Expect.isTrue(m416 is int Function(int x0) Function());
+ Expect.isTrue(confuse(m416) is F416);
+ // In checked mode, verifies the type.
+ x416 = m416;
+ l416 = m416;
+ x416 = confuse(m416);
+ l416 = confuse(m416);
+
+ }
+
+ void testF516() {
+ // int Function(int x, [List<Function> x2]) Function()
+ Expect.isTrue(f516 is F516);
+ Expect.isTrue(confuse(f516) is F516);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<Function> x2]) Function() l516;
+ // The static function f516 sets `T` to `int`.
+ if (!tIsBool) {
+ x516 = f516 as dynamic;
+ l516 = f516 as dynamic;
+ x516 = confuse(f516);
+ l516 = confuse(f516);
+ }
+
+ Expect.isTrue(m516 is F516);
+ Expect.isTrue(m516 is int Function(int x, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m516) is F516);
+ // In checked mode, verifies the type.
+ x516 = m516;
+ l516 = m516;
+ x516 = confuse(m516);
+ l516 = confuse(m516);
+
+ }
+
+ void testF616() {
+ // int Function(int y, {List<T> x}) Function()
+ Expect.isTrue(f616 is F616);
+ Expect.isTrue(confuse(f616) is F616);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<T> x}) Function() l616;
+ // The static function f616 sets `T` to `int`.
+ if (!tIsBool) {
+ x616 = f616 as dynamic;
+ l616 = f616 as dynamic;
+ x616 = confuse(f616);
+ l616 = confuse(f616);
+ }
+
+ Expect.isTrue(m616 is F616);
+ Expect.isTrue(m616 is int Function(int y, {List<T> x}) Function());
+ Expect.isTrue(confuse(m616) is F616);
+ // In checked mode, verifies the type.
+ x616 = m616;
+ l616 = m616;
+ x616 = confuse(m616);
+ l616 = confuse(m616);
+ if (!tIsBool) {
+ Expect.isTrue(f616 is F616<int>);
+ Expect.isFalse(f616 is F616<bool>);
+ Expect.isTrue(confuse(f616) is F616<int>);
+ Expect.isFalse(confuse(f616) is F616<bool>);
+ Expect.equals(tIsDynamic, m616 is F616<bool>);
+ Expect.equals(tIsDynamic, confuse(m616) is F616<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x616 = (f616 as dynamic); });
+ Expect.throws(() { x616 = confuse(f616); });
+ int Function(int y, {List<T> x}) Function() l616;
+ Expect.throws(() { l616 = (f616 as dynamic); });
+ Expect.throws(() { l616 = confuse(f616); });
+ }
+ int Function(int y, {List<T> x}) Function() l616 = m616;
+ // In checked mode, verifies the type.
+ x616 = m616;
+ x616 = confuse(m616);
+ }
+ }
+
+ void testF716() {
+ // Function Function([List<Function> x]) Function()
+ Expect.isTrue(f716 is F716);
+ Expect.isTrue(confuse(f716) is F716);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x]) Function() l716;
+ // The static function f716 sets `T` to `int`.
+ if (!tIsBool) {
+ x716 = f716 as dynamic;
+ l716 = f716 as dynamic;
+ x716 = confuse(f716);
+ l716 = confuse(f716);
+ }
+
+ Expect.isTrue(m716 is F716);
+ Expect.isTrue(m716 is Function Function([List<Function> x]) Function());
+ Expect.isTrue(confuse(m716) is F716);
+ // In checked mode, verifies the type.
+ x716 = m716;
+ l716 = m716;
+ x716 = confuse(m716);
+ l716 = confuse(m716);
+
+ }
+
+ void testF816() {
+ // Function Function(List<T> x0) Function()
+ Expect.isTrue(f816 is F816);
+ Expect.isTrue(confuse(f816) is F816);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x0) Function() l816;
+ // The static function f816 sets `T` to `int`.
+ if (!tIsBool) {
+ x816 = f816 as dynamic;
+ l816 = f816 as dynamic;
+ x816 = confuse(f816);
+ l816 = confuse(f816);
+ }
+
+ Expect.isTrue(m816 is F816);
+ Expect.isTrue(m816 is Function Function(List<T> x0) Function());
+ Expect.isTrue(confuse(m816) is F816);
+ // In checked mode, verifies the type.
+ x816 = m816;
+ l816 = m816;
+ x816 = confuse(m816);
+ l816 = confuse(m816);
+ if (!tIsBool) {
+ Expect.isTrue(f816 is F816<int>);
+ Expect.isFalse(f816 is F816<bool>);
+ Expect.isTrue(confuse(f816) is F816<int>);
+ Expect.isFalse(confuse(f816) is F816<bool>);
+ Expect.equals(tIsDynamic, m816 is F816<bool>);
+ Expect.equals(tIsDynamic, confuse(m816) is F816<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x816 = (f816 as dynamic); });
+ Expect.throws(() { x816 = confuse(f816); });
+ Function Function(List<T> x0) Function() l816;
+ Expect.throws(() { l816 = (f816 as dynamic); });
+ Expect.throws(() { l816 = confuse(f816); });
+ }
+ Function Function(List<T> x0) Function() l816 = m816;
+ // In checked mode, verifies the type.
+ x816 = m816;
+ x816 = confuse(m816);
+ }
+ }
+
+ void testF916() {
+ // List<Function> Function(int x1, [Function x2]) Function()
+ Expect.isTrue(f916 is F916);
+ Expect.isTrue(confuse(f916) is F916);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [Function x2]) Function() l916;
+ // The static function f916 sets `T` to `int`.
+ if (!tIsBool) {
+ x916 = f916 as dynamic;
+ l916 = f916 as dynamic;
+ x916 = confuse(f916);
+ l916 = confuse(f916);
+ }
+
+ Expect.isTrue(m916 is F916);
+ Expect.isTrue(m916 is List<Function> Function(int x1, [Function x2]) Function());
+ Expect.isTrue(confuse(m916) is F916);
+ // In checked mode, verifies the type.
+ x916 = m916;
+ l916 = m916;
+ x916 = confuse(m916);
+ l916 = confuse(m916);
+
+ }
+
+ void testF1016() {
+ // List<Function> Function(int x0, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1016 is F1016);
+ Expect.isTrue(confuse(f1016) is F1016);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {core.List<core.int> x}) Function() l1016;
+ // The static function f1016 sets `T` to `int`.
+ if (!tIsBool) {
+ x1016 = f1016 as dynamic;
+ l1016 = f1016 as dynamic;
+ x1016 = confuse(f1016);
+ l1016 = confuse(f1016);
+ }
+
+ Expect.isTrue(m1016 is F1016);
+ Expect.isTrue(m1016 is List<Function> Function(int x0, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1016) is F1016);
+ // In checked mode, verifies the type.
+ x1016 = m1016;
+ l1016 = m1016;
+ x1016 = confuse(m1016);
+ l1016 = confuse(m1016);
+
+ }
+
+ void testF1116() {
+ // core.List<core.int> Function(Function x) Function()
+ Expect.isTrue(f1116 is F1116);
+ Expect.isTrue(confuse(f1116) is F1116);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x) Function() l1116;
+ // The static function f1116 sets `T` to `int`.
+ if (!tIsBool) {
+ x1116 = f1116 as dynamic;
+ l1116 = f1116 as dynamic;
+ x1116 = confuse(f1116);
+ l1116 = confuse(f1116);
+ }
+
+ Expect.isTrue(m1116 is F1116);
+ Expect.isTrue(m1116 is core.List<core.int> Function(Function x) Function());
+ Expect.isTrue(confuse(m1116) is F1116);
+ // In checked mode, verifies the type.
+ x1116 = m1116;
+ l1116 = m1116;
+ x1116 = confuse(m1116);
+ l1116 = confuse(m1116);
+
+ }
+
+ void testF1216() {
+ // core.List<core.int> Function(int y, [core.List<core.int> x]) Function()
+ Expect.isTrue(f1216 is F1216);
+ Expect.isTrue(confuse(f1216) is F1216);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function() l1216;
+ // The static function f1216 sets `T` to `int`.
+ if (!tIsBool) {
+ x1216 = f1216 as dynamic;
+ l1216 = f1216 as dynamic;
+ x1216 = confuse(f1216);
+ l1216 = confuse(f1216);
+ }
+
+ Expect.isTrue(m1216 is F1216);
+ Expect.isTrue(m1216 is core.List<core.int> Function(int y, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1216) is F1216);
+ // In checked mode, verifies the type.
+ x1216 = m1216;
+ l1216 = m1216;
+ x1216 = confuse(m1216);
+ l1216 = confuse(m1216);
+
+ }
+
+ void testF1316() {
+ // List<T> Function([int x1]) Function()
+ Expect.isTrue(f1316 is F1316);
+ Expect.isTrue(confuse(f1316) is F1316);
+ // In checked mode, verifies the type.
+ List<T> Function([int x1]) Function() l1316;
+ // The static function f1316 sets `T` to `int`.
+ if (!tIsBool) {
+ x1316 = f1316 as dynamic;
+ l1316 = f1316 as dynamic;
+ x1316 = confuse(f1316);
+ l1316 = confuse(f1316);
+ }
+
+ Expect.isTrue(m1316 is F1316);
+ Expect.isTrue(m1316 is List<T> Function([int x1]) Function());
+ Expect.isTrue(confuse(m1316) is F1316);
+ // In checked mode, verifies the type.
+ x1316 = m1316;
+ l1316 = m1316;
+ x1316 = confuse(m1316);
+ l1316 = confuse(m1316);
+ if (!tIsBool) {
+ Expect.isTrue(f1316 is F1316<int>);
+ Expect.isFalse(f1316 is F1316<bool>);
+ Expect.isTrue(confuse(f1316) is F1316<int>);
+ Expect.isFalse(confuse(f1316) is F1316<bool>);
+ Expect.equals(tIsDynamic, m1316 is F1316<bool>);
+ Expect.equals(tIsDynamic, confuse(m1316) is F1316<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1316 = (f1316 as dynamic); });
+ Expect.throws(() { x1316 = confuse(f1316); });
+ List<T> Function([int x1]) Function() l1316;
+ Expect.throws(() { l1316 = (f1316 as dynamic); });
+ Expect.throws(() { l1316 = confuse(f1316); });
+ }
+ List<T> Function([int x1]) Function() l1316 = m1316;
+ // In checked mode, verifies the type.
+ x1316 = m1316;
+ x1316 = confuse(m1316);
+ }
+ }
+
+ void testF1416() {
+ // List<T> Function({List<Function> x}) Function()
+ Expect.isTrue(f1416 is F1416);
+ Expect.isTrue(confuse(f1416) is F1416);
+ // In checked mode, verifies the type.
+ List<T> Function({List<Function> x}) Function() l1416;
+ // The static function f1416 sets `T` to `int`.
+ if (!tIsBool) {
+ x1416 = f1416 as dynamic;
+ l1416 = f1416 as dynamic;
+ x1416 = confuse(f1416);
+ l1416 = confuse(f1416);
+ }
+
+ Expect.isTrue(m1416 is F1416);
+ Expect.isTrue(m1416 is List<T> Function({List<Function> x}) Function());
+ Expect.isTrue(confuse(m1416) is F1416);
+ // In checked mode, verifies the type.
+ x1416 = m1416;
+ l1416 = m1416;
+ x1416 = confuse(m1416);
+ l1416 = confuse(m1416);
+ if (!tIsBool) {
+ Expect.isTrue(f1416 is F1416<int>);
+ Expect.isFalse(f1416 is F1416<bool>);
+ Expect.isTrue(confuse(f1416) is F1416<int>);
+ Expect.isFalse(confuse(f1416) is F1416<bool>);
+ Expect.equals(tIsDynamic, m1416 is F1416<bool>);
+ Expect.equals(tIsDynamic, confuse(m1416) is F1416<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1416 = (f1416 as dynamic); });
+ Expect.throws(() { x1416 = confuse(f1416); });
+ List<T> Function({List<Function> x}) Function() l1416;
+ Expect.throws(() { l1416 = (f1416 as dynamic); });
+ Expect.throws(() { l1416 = confuse(f1416); });
+ }
+ List<T> Function({List<Function> x}) Function() l1416 = m1416;
+ // In checked mode, verifies the type.
+ x1416 = m1416;
+ x1416 = confuse(m1416);
+ }
+ }
+
+ void testF1516() {
+ // List<T> Function() Function()
+ Expect.isTrue(f1516 is F1516);
+ Expect.isTrue(confuse(f1516) is F1516);
+ // In checked mode, verifies the type.
+ List<T> Function() Function() l1516;
+ // The static function f1516 sets `T` to `int`.
+ if (!tIsBool) {
+ x1516 = f1516 as dynamic;
+ l1516 = f1516 as dynamic;
+ x1516 = confuse(f1516);
+ l1516 = confuse(f1516);
+ }
+
+ Expect.isTrue(m1516 is F1516);
+ Expect.isTrue(m1516 is List<T> Function() Function());
+ Expect.isTrue(confuse(m1516) is F1516);
+ // In checked mode, verifies the type.
+ x1516 = m1516;
+ l1516 = m1516;
+ x1516 = confuse(m1516);
+ l1516 = confuse(m1516);
+ if (!tIsBool) {
+ Expect.isTrue(f1516 is F1516<int>);
+ Expect.isFalse(f1516 is F1516<bool>);
+ Expect.isTrue(confuse(f1516) is F1516<int>);
+ Expect.isFalse(confuse(f1516) is F1516<bool>);
+ Expect.equals(tIsDynamic, m1516 is F1516<bool>);
+ Expect.equals(tIsDynamic, confuse(m1516) is F1516<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1516 = (f1516 as dynamic); });
+ Expect.throws(() { x1516 = confuse(f1516); });
+ List<T> Function() Function() l1516;
+ Expect.throws(() { l1516 = (f1516 as dynamic); });
+ Expect.throws(() { l1516 = confuse(f1516); });
+ }
+ List<T> Function() Function() l1516 = m1516;
+ // In checked mode, verifies the type.
+ x1516 = m1516;
+ x1516 = confuse(m1516);
+ }
+ }
+
+ void testF1616() {
+ // Function(int x0, [List<Function> x]) Function()
+ Expect.isTrue(f1616 is F1616);
+ Expect.isTrue(confuse(f1616) is F1616);
+ // In checked mode, verifies the type.
+ Function(int x0, [List<Function> x]) Function() l1616;
+ // The static function f1616 sets `T` to `int`.
+ if (!tIsBool) {
+ x1616 = f1616 as dynamic;
+ l1616 = f1616 as dynamic;
+ x1616 = confuse(f1616);
+ l1616 = confuse(f1616);
+ }
+
+ Expect.isTrue(m1616 is F1616);
+ Expect.isTrue(m1616 is Function(int x0, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m1616) is F1616);
+ // In checked mode, verifies the type.
+ x1616 = m1616;
+ l1616 = m1616;
+ x1616 = confuse(m1616);
+ l1616 = confuse(m1616);
+
+ }
+
+ void testF1716() {
+ // Function([List<T> x1]) Function()
+ Expect.isTrue(f1716 is F1716);
+ Expect.isTrue(confuse(f1716) is F1716);
+ // In checked mode, verifies the type.
+ Function([List<T> x1]) Function() l1716;
+ // The static function f1716 sets `T` to `int`.
+ if (!tIsBool) {
+ x1716 = f1716 as dynamic;
+ l1716 = f1716 as dynamic;
+ x1716 = confuse(f1716);
+ l1716 = confuse(f1716);
+ }
+
+ Expect.isTrue(m1716 is F1716);
+ Expect.isTrue(m1716 is Function([List<T> x1]) Function());
+ Expect.isTrue(confuse(m1716) is F1716);
+ // In checked mode, verifies the type.
+ x1716 = m1716;
+ l1716 = m1716;
+ x1716 = confuse(m1716);
+ l1716 = confuse(m1716);
+ if (!tIsBool) {
+ Expect.isTrue(f1716 is F1716<int>);
+ Expect.isFalse(f1716 is F1716<bool>);
+ Expect.isTrue(confuse(f1716) is F1716<int>);
+ Expect.isFalse(confuse(f1716) is F1716<bool>);
+ Expect.equals(tIsDynamic, m1716 is F1716<bool>);
+ Expect.equals(tIsDynamic, confuse(m1716) is F1716<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1716 = (f1716 as dynamic); });
+ Expect.throws(() { x1716 = confuse(f1716); });
+ Function([List<T> x1]) Function() l1716;
+ Expect.throws(() { l1716 = (f1716 as dynamic); });
+ Expect.throws(() { l1716 = confuse(f1716); });
+ }
+ Function([List<T> x1]) Function() l1716 = m1716;
+ // In checked mode, verifies the type.
+ x1716 = m1716;
+ x1716 = confuse(m1716);
+ }
+ }
+
+ void testF1816() {
+ // List<Function> Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1816 is F1816);
+ Expect.isTrue(confuse(f1816) is F1816);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<Function> x) Function() l1816;
+ // The static function f1816 sets `T` to `int`.
+ if (!tIsBool) {
+ x1816 = f1816 as dynamic;
+ l1816 = f1816 as dynamic;
+ x1816 = confuse(f1816);
+ l1816 = confuse(f1816);
+ }
+
+ Expect.isTrue(m1816 is F1816);
+ Expect.isTrue(m1816 is List<Function> Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1816) is F1816);
+ // In checked mode, verifies the type.
+ x1816 = m1816;
+ l1816 = m1816;
+ x1816 = confuse(m1816);
+ l1816 = confuse(m1816);
+
+ }
+
+ void testF1916() {
+ // Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1916 is F1916);
+ Expect.isTrue(confuse(f1916) is F1916);
+ // In checked mode, verifies the type.
+ Function<A>(core.List<core.int> x) Function() l1916;
+ // The static function f1916 sets `T` to `int`.
+ if (!tIsBool) {
+ x1916 = f1916 as dynamic;
+ l1916 = f1916 as dynamic;
+ x1916 = confuse(f1916);
+ l1916 = confuse(f1916);
+ }
+
+ Expect.isTrue(m1916 is F1916);
+ Expect.isTrue(m1916 is Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1916) is F1916);
+ // In checked mode, verifies the type.
+ x1916 = m1916;
+ l1916 = m1916;
+ x1916 = confuse(m1916);
+ l1916 = confuse(m1916);
+
+ }
+
+ void testF2016() {
+ // B Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f2016 is F2016);
+ Expect.isTrue(confuse(f2016) is F2016);
+ // In checked mode, verifies the type.
+ B Function(int x) Function<B extends core.int>() l2016;
+ // The static function f2016 sets `T` to `int`.
+ if (!tIsBool) {
+ x2016 = f2016 as dynamic;
+ l2016 = f2016 as dynamic;
+ x2016 = confuse(f2016);
+ l2016 = confuse(f2016);
+ }
+
+ Expect.isTrue(m2016 is F2016);
+ Expect.isTrue(m2016 is B Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2016) is F2016);
+ // In checked mode, verifies the type.
+ x2016 = m2016;
+ l2016 = m2016;
+ x2016 = confuse(m2016);
+ l2016 = confuse(m2016);
+
+ }
+
+
+}
+
+class C17<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x1, [Function x2]) x17;
+ List<Function> Function([int x1]) x117;
+ core.List<core.int> Function([List<T> x1]) x217;
+ Function(core.List<core.int> x0) x317;
+ int Function(int x1) Function(int x) x417;
+ int Function(int x, [List<Function> x1]) Function(int x) x517;
+ int Function(int y, {List<T> x}) Function(int x) x617;
+ Function Function([List<Function> x]) Function(int x) x717;
+ Function Function(List<T> x1) Function(int x) x817;
+ List<Function> Function(int x2, [Function x3]) Function(int x) x917;
+ List<Function> Function(int x1, {core.List<core.int> x}) Function(int x) x1017;
+ core.List<core.int> Function(Function x) Function(int x) x1117;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function(int x) x1217;
+ List<T> Function([int x1]) Function(int x) x1317;
+ List<T> Function({List<Function> x}) Function(int x) x1417;
+ List<T> Function() Function(int x) x1517;
+ Function(int x1, [List<Function> x]) Function(int x) x1617;
+ Function([List<T> x1]) Function(int x) x1717;
+ List<Function> Function<A>(List<Function> x) Function(int x) x1817;
+ Function<A>(core.List<core.int> x) Function(int x) x1917;
+ B Function(int x) Function<B extends core.int>(int x) x2017;
+
+
+ C17({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m17(int x0, [Function x1]) => null;
+ List<Function> m117([int x0]) => null;
+ core.List<core.int> m217([List<T> x0]) => null;
+ m317(core.List<core.int> x0) => null;
+ int Function(int x0) m417(int x) => null;
+ int Function(int x, [List<Function> x0]) m517(int x) => null;
+ int Function(int y, {List<T> x}) m617(int x) => null;
+ Function Function([List<Function> x]) m717(int x) => null;
+ Function Function(List<T> x0) m817(int x) => null;
+ List<Function> Function(int x0, [Function x1]) m917(int x) => null;
+ List<Function> Function(int x0, {core.List<core.int> x}) m1017(int x) => null;
+ core.List<core.int> Function(Function x) m1117(int x) => null;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) m1217(int x) => null;
+ List<T> Function([int x0]) m1317(int x) => null;
+ List<T> Function({List<Function> x}) m1417(int x) => null;
+ List<T> Function() m1517(int x) => null;
+ Function(int x0, [List<Function> x]) m1617(int x) => null;
+ Function([List<T> x0]) m1717(int x) => null;
+ List<Function> Function<A>(List<Function> x) m1817(int x) => null;
+ Function<A>(core.List<core.int> x) m1917(int x) => null;
+ B Function(int x) m2017<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF17();
+ testF117();
+ testF217();
+ testF317();
+ testF417();
+ testF517();
+ testF617();
+ testF717();
+ testF817();
+ testF917();
+ testF1017();
+ testF1117();
+ testF1217();
+ testF1317();
+ testF1417();
+ testF1517();
+ testF1617();
+ testF1717();
+ testF1817();
+ testF1917();
+ testF2017();
+ }
+
+ void testF17() {
+ // int Function(int x1, [Function x2])
+ Expect.isTrue(f17 is F17);
+ Expect.isTrue(confuse(f17) is F17);
+ // In checked mode, verifies the type.
+ int Function(int x1, [Function x2]) l17;
+ // The static function f17 sets `T` to `int`.
+ if (!tIsBool) {
+ x17 = f17 as dynamic;
+ l17 = f17 as dynamic;
+ x17 = confuse(f17);
+ l17 = confuse(f17);
+ }
+
+ Expect.isTrue(m17 is F17);
+ Expect.isTrue(m17 is int Function(int x1, [Function x2]));
+ Expect.isTrue(confuse(m17) is F17);
+ // In checked mode, verifies the type.
+ x17 = m17;
+ l17 = m17;
+ x17 = confuse(m17);
+ l17 = confuse(m17);
+
+ }
+
+ void testF117() {
+ // List<Function> Function([int x1])
+ Expect.isTrue(f117 is F117);
+ Expect.isTrue(confuse(f117) is F117);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x1]) l117;
+ // The static function f117 sets `T` to `int`.
+ if (!tIsBool) {
+ x117 = f117 as dynamic;
+ l117 = f117 as dynamic;
+ x117 = confuse(f117);
+ l117 = confuse(f117);
+ }
+
+ Expect.isTrue(m117 is F117);
+ Expect.isTrue(m117 is List<Function> Function([int x1]));
+ Expect.isTrue(confuse(m117) is F117);
+ // In checked mode, verifies the type.
+ x117 = m117;
+ l117 = m117;
+ x117 = confuse(m117);
+ l117 = confuse(m117);
+
+ }
+
+ void testF217() {
+ // core.List<core.int> Function([List<T> x1])
+ Expect.isTrue(f217 is F217);
+ Expect.isTrue(confuse(f217) is F217);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x1]) l217;
+ // The static function f217 sets `T` to `int`.
+ if (!tIsBool) {
+ x217 = f217 as dynamic;
+ l217 = f217 as dynamic;
+ x217 = confuse(f217);
+ l217 = confuse(f217);
+ }
+
+ Expect.isTrue(m217 is F217);
+ Expect.isTrue(m217 is core.List<core.int> Function([List<T> x1]));
+ Expect.isTrue(confuse(m217) is F217);
+ // In checked mode, verifies the type.
+ x217 = m217;
+ l217 = m217;
+ x217 = confuse(m217);
+ l217 = confuse(m217);
+ if (!tIsBool) {
+ Expect.isTrue(f217 is F217<int>);
+ Expect.isFalse(f217 is F217<bool>);
+ Expect.isTrue(confuse(f217) is F217<int>);
+ Expect.isFalse(confuse(f217) is F217<bool>);
+ Expect.equals(tIsDynamic, m217 is F217<bool>);
+ Expect.equals(tIsDynamic, confuse(m217) is F217<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x217 = (f217 as dynamic); });
+ Expect.throws(() { x217 = confuse(f217); });
+ core.List<core.int> Function([List<T> x1]) l217;
+ Expect.throws(() { l217 = (f217 as dynamic); });
+ Expect.throws(() { l217 = confuse(f217); });
+ }
+ core.List<core.int> Function([List<T> x1]) l217 = m217;
+ // In checked mode, verifies the type.
+ x217 = m217;
+ x217 = confuse(m217);
+ }
+ }
+
+ void testF317() {
+ // Function(core.List<core.int> x0)
+ Expect.isTrue(f317 is F317);
+ Expect.isTrue(confuse(f317) is F317);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x0) l317;
+ // The static function f317 sets `T` to `int`.
+ if (!tIsBool) {
+ x317 = f317 as dynamic;
+ l317 = f317 as dynamic;
+ x317 = confuse(f317);
+ l317 = confuse(f317);
+ }
+
+ Expect.isTrue(m317 is F317);
+ Expect.isTrue(m317 is Function(core.List<core.int> x0));
+ Expect.isTrue(confuse(m317) is F317);
+ // In checked mode, verifies the type.
+ x317 = m317;
+ l317 = m317;
+ x317 = confuse(m317);
+ l317 = confuse(m317);
+
+ }
+
+ void testF417() {
+ // int Function(int x1) Function(int x)
+ Expect.isTrue(f417 is F417);
+ Expect.isTrue(confuse(f417) is F417);
+ // In checked mode, verifies the type.
+ int Function(int x1) Function(int x) l417;
+ // The static function f417 sets `T` to `int`.
+ if (!tIsBool) {
+ x417 = f417 as dynamic;
+ l417 = f417 as dynamic;
+ x417 = confuse(f417);
+ l417 = confuse(f417);
+ }
+
+ Expect.isTrue(m417 is F417);
+ Expect.isTrue(m417 is int Function(int x1) Function(int x));
+ Expect.isTrue(confuse(m417) is F417);
+ // In checked mode, verifies the type.
+ x417 = m417;
+ l417 = m417;
+ x417 = confuse(m417);
+ l417 = confuse(m417);
+
+ }
+
+ void testF517() {
+ // int Function(int x, [List<Function> x1]) Function(int x)
+ Expect.isTrue(f517 is F517);
+ Expect.isTrue(confuse(f517) is F517);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<Function> x1]) Function(int x) l517;
+ // The static function f517 sets `T` to `int`.
+ if (!tIsBool) {
+ x517 = f517 as dynamic;
+ l517 = f517 as dynamic;
+ x517 = confuse(f517);
+ l517 = confuse(f517);
+ }
+
+ Expect.isTrue(m517 is F517);
+ Expect.isTrue(m517 is int Function(int x, [List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m517) is F517);
+ // In checked mode, verifies the type.
+ x517 = m517;
+ l517 = m517;
+ x517 = confuse(m517);
+ l517 = confuse(m517);
+
+ }
+
+ void testF617() {
+ // int Function(int y, {List<T> x}) Function(int x)
+ Expect.isTrue(f617 is F617);
+ Expect.isTrue(confuse(f617) is F617);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<T> x}) Function(int x) l617;
+ // The static function f617 sets `T` to `int`.
+ if (!tIsBool) {
+ x617 = f617 as dynamic;
+ l617 = f617 as dynamic;
+ x617 = confuse(f617);
+ l617 = confuse(f617);
+ }
+
+ Expect.isTrue(m617 is F617);
+ Expect.isTrue(m617 is int Function(int y, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m617) is F617);
+ // In checked mode, verifies the type.
+ x617 = m617;
+ l617 = m617;
+ x617 = confuse(m617);
+ l617 = confuse(m617);
+ if (!tIsBool) {
+ Expect.isTrue(f617 is F617<int>);
+ Expect.isFalse(f617 is F617<bool>);
+ Expect.isTrue(confuse(f617) is F617<int>);
+ Expect.isFalse(confuse(f617) is F617<bool>);
+ Expect.equals(tIsDynamic, m617 is F617<bool>);
+ Expect.equals(tIsDynamic, confuse(m617) is F617<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x617 = (f617 as dynamic); });
+ Expect.throws(() { x617 = confuse(f617); });
+ int Function(int y, {List<T> x}) Function(int x) l617;
+ Expect.throws(() { l617 = (f617 as dynamic); });
+ Expect.throws(() { l617 = confuse(f617); });
+ }
+ int Function(int y, {List<T> x}) Function(int x) l617 = m617;
+ // In checked mode, verifies the type.
+ x617 = m617;
+ x617 = confuse(m617);
+ }
+ }
+
+ void testF717() {
+ // Function Function([List<Function> x]) Function(int x)
+ Expect.isTrue(f717 is F717);
+ Expect.isTrue(confuse(f717) is F717);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x]) Function(int x) l717;
+ // The static function f717 sets `T` to `int`.
+ if (!tIsBool) {
+ x717 = f717 as dynamic;
+ l717 = f717 as dynamic;
+ x717 = confuse(f717);
+ l717 = confuse(f717);
+ }
+
+ Expect.isTrue(m717 is F717);
+ Expect.isTrue(m717 is Function Function([List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m717) is F717);
+ // In checked mode, verifies the type.
+ x717 = m717;
+ l717 = m717;
+ x717 = confuse(m717);
+ l717 = confuse(m717);
+
+ }
+
+ void testF817() {
+ // Function Function(List<T> x1) Function(int x)
+ Expect.isTrue(f817 is F817);
+ Expect.isTrue(confuse(f817) is F817);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x1) Function(int x) l817;
+ // The static function f817 sets `T` to `int`.
+ if (!tIsBool) {
+ x817 = f817 as dynamic;
+ l817 = f817 as dynamic;
+ x817 = confuse(f817);
+ l817 = confuse(f817);
+ }
+
+ Expect.isTrue(m817 is F817);
+ Expect.isTrue(m817 is Function Function(List<T> x1) Function(int x));
+ Expect.isTrue(confuse(m817) is F817);
+ // In checked mode, verifies the type.
+ x817 = m817;
+ l817 = m817;
+ x817 = confuse(m817);
+ l817 = confuse(m817);
+ if (!tIsBool) {
+ Expect.isTrue(f817 is F817<int>);
+ Expect.isFalse(f817 is F817<bool>);
+ Expect.isTrue(confuse(f817) is F817<int>);
+ Expect.isFalse(confuse(f817) is F817<bool>);
+ Expect.equals(tIsDynamic, m817 is F817<bool>);
+ Expect.equals(tIsDynamic, confuse(m817) is F817<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x817 = (f817 as dynamic); });
+ Expect.throws(() { x817 = confuse(f817); });
+ Function Function(List<T> x1) Function(int x) l817;
+ Expect.throws(() { l817 = (f817 as dynamic); });
+ Expect.throws(() { l817 = confuse(f817); });
+ }
+ Function Function(List<T> x1) Function(int x) l817 = m817;
+ // In checked mode, verifies the type.
+ x817 = m817;
+ x817 = confuse(m817);
+ }
+ }
+
+ void testF917() {
+ // List<Function> Function(int x2, [Function x3]) Function(int x)
+ Expect.isTrue(f917 is F917);
+ Expect.isTrue(confuse(f917) is F917);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [Function x3]) Function(int x) l917;
+ // The static function f917 sets `T` to `int`.
+ if (!tIsBool) {
+ x917 = f917 as dynamic;
+ l917 = f917 as dynamic;
+ x917 = confuse(f917);
+ l917 = confuse(f917);
+ }
+
+ Expect.isTrue(m917 is F917);
+ Expect.isTrue(m917 is List<Function> Function(int x2, [Function x3]) Function(int x));
+ Expect.isTrue(confuse(m917) is F917);
+ // In checked mode, verifies the type.
+ x917 = m917;
+ l917 = m917;
+ x917 = confuse(m917);
+ l917 = confuse(m917);
+
+ }
+
+ void testF1017() {
+ // List<Function> Function(int x1, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1017 is F1017);
+ Expect.isTrue(confuse(f1017) is F1017);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {core.List<core.int> x}) Function(int x) l1017;
+ // The static function f1017 sets `T` to `int`.
+ if (!tIsBool) {
+ x1017 = f1017 as dynamic;
+ l1017 = f1017 as dynamic;
+ x1017 = confuse(f1017);
+ l1017 = confuse(f1017);
+ }
+
+ Expect.isTrue(m1017 is F1017);
+ Expect.isTrue(m1017 is List<Function> Function(int x1, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1017) is F1017);
+ // In checked mode, verifies the type.
+ x1017 = m1017;
+ l1017 = m1017;
+ x1017 = confuse(m1017);
+ l1017 = confuse(m1017);
+
+ }
+
+ void testF1117() {
+ // core.List<core.int> Function(Function x) Function(int x)
+ Expect.isTrue(f1117 is F1117);
+ Expect.isTrue(confuse(f1117) is F1117);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x) Function(int x) l1117;
+ // The static function f1117 sets `T` to `int`.
+ if (!tIsBool) {
+ x1117 = f1117 as dynamic;
+ l1117 = f1117 as dynamic;
+ x1117 = confuse(f1117);
+ l1117 = confuse(f1117);
+ }
+
+ Expect.isTrue(m1117 is F1117);
+ Expect.isTrue(m1117 is core.List<core.int> Function(Function x) Function(int x));
+ Expect.isTrue(confuse(m1117) is F1117);
+ // In checked mode, verifies the type.
+ x1117 = m1117;
+ l1117 = m1117;
+ x1117 = confuse(m1117);
+ l1117 = confuse(m1117);
+
+ }
+
+ void testF1217() {
+ // core.List<core.int> Function(int y, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1217 is F1217);
+ Expect.isTrue(confuse(f1217) is F1217);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function(int x) l1217;
+ // The static function f1217 sets `T` to `int`.
+ if (!tIsBool) {
+ x1217 = f1217 as dynamic;
+ l1217 = f1217 as dynamic;
+ x1217 = confuse(f1217);
+ l1217 = confuse(f1217);
+ }
+
+ Expect.isTrue(m1217 is F1217);
+ Expect.isTrue(m1217 is core.List<core.int> Function(int y, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1217) is F1217);
+ // In checked mode, verifies the type.
+ x1217 = m1217;
+ l1217 = m1217;
+ x1217 = confuse(m1217);
+ l1217 = confuse(m1217);
+
+ }
+
+ void testF1317() {
+ // List<T> Function([int x1]) Function(int x)
+ Expect.isTrue(f1317 is F1317);
+ Expect.isTrue(confuse(f1317) is F1317);
+ // In checked mode, verifies the type.
+ List<T> Function([int x1]) Function(int x) l1317;
+ // The static function f1317 sets `T` to `int`.
+ if (!tIsBool) {
+ x1317 = f1317 as dynamic;
+ l1317 = f1317 as dynamic;
+ x1317 = confuse(f1317);
+ l1317 = confuse(f1317);
+ }
+
+ Expect.isTrue(m1317 is F1317);
+ Expect.isTrue(m1317 is List<T> Function([int x1]) Function(int x));
+ Expect.isTrue(confuse(m1317) is F1317);
+ // In checked mode, verifies the type.
+ x1317 = m1317;
+ l1317 = m1317;
+ x1317 = confuse(m1317);
+ l1317 = confuse(m1317);
+ if (!tIsBool) {
+ Expect.isTrue(f1317 is F1317<int>);
+ Expect.isFalse(f1317 is F1317<bool>);
+ Expect.isTrue(confuse(f1317) is F1317<int>);
+ Expect.isFalse(confuse(f1317) is F1317<bool>);
+ Expect.equals(tIsDynamic, m1317 is F1317<bool>);
+ Expect.equals(tIsDynamic, confuse(m1317) is F1317<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1317 = (f1317 as dynamic); });
+ Expect.throws(() { x1317 = confuse(f1317); });
+ List<T> Function([int x1]) Function(int x) l1317;
+ Expect.throws(() { l1317 = (f1317 as dynamic); });
+ Expect.throws(() { l1317 = confuse(f1317); });
+ }
+ List<T> Function([int x1]) Function(int x) l1317 = m1317;
+ // In checked mode, verifies the type.
+ x1317 = m1317;
+ x1317 = confuse(m1317);
+ }
+ }
+
+ void testF1417() {
+ // List<T> Function({List<Function> x}) Function(int x)
+ Expect.isTrue(f1417 is F1417);
+ Expect.isTrue(confuse(f1417) is F1417);
+ // In checked mode, verifies the type.
+ List<T> Function({List<Function> x}) Function(int x) l1417;
+ // The static function f1417 sets `T` to `int`.
+ if (!tIsBool) {
+ x1417 = f1417 as dynamic;
+ l1417 = f1417 as dynamic;
+ x1417 = confuse(f1417);
+ l1417 = confuse(f1417);
+ }
+
+ Expect.isTrue(m1417 is F1417);
+ Expect.isTrue(m1417 is List<T> Function({List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1417) is F1417);
+ // In checked mode, verifies the type.
+ x1417 = m1417;
+ l1417 = m1417;
+ x1417 = confuse(m1417);
+ l1417 = confuse(m1417);
+ if (!tIsBool) {
+ Expect.isTrue(f1417 is F1417<int>);
+ Expect.isFalse(f1417 is F1417<bool>);
+ Expect.isTrue(confuse(f1417) is F1417<int>);
+ Expect.isFalse(confuse(f1417) is F1417<bool>);
+ Expect.equals(tIsDynamic, m1417 is F1417<bool>);
+ Expect.equals(tIsDynamic, confuse(m1417) is F1417<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1417 = (f1417 as dynamic); });
+ Expect.throws(() { x1417 = confuse(f1417); });
+ List<T> Function({List<Function> x}) Function(int x) l1417;
+ Expect.throws(() { l1417 = (f1417 as dynamic); });
+ Expect.throws(() { l1417 = confuse(f1417); });
+ }
+ List<T> Function({List<Function> x}) Function(int x) l1417 = m1417;
+ // In checked mode, verifies the type.
+ x1417 = m1417;
+ x1417 = confuse(m1417);
+ }
+ }
+
+ void testF1517() {
+ // List<T> Function() Function(int x)
+ Expect.isTrue(f1517 is F1517);
+ Expect.isTrue(confuse(f1517) is F1517);
+ // In checked mode, verifies the type.
+ List<T> Function() Function(int x) l1517;
+ // The static function f1517 sets `T` to `int`.
+ if (!tIsBool) {
+ x1517 = f1517 as dynamic;
+ l1517 = f1517 as dynamic;
+ x1517 = confuse(f1517);
+ l1517 = confuse(f1517);
+ }
+
+ Expect.isTrue(m1517 is F1517);
+ Expect.isTrue(m1517 is List<T> Function() Function(int x));
+ Expect.isTrue(confuse(m1517) is F1517);
+ // In checked mode, verifies the type.
+ x1517 = m1517;
+ l1517 = m1517;
+ x1517 = confuse(m1517);
+ l1517 = confuse(m1517);
+ if (!tIsBool) {
+ Expect.isTrue(f1517 is F1517<int>);
+ Expect.isFalse(f1517 is F1517<bool>);
+ Expect.isTrue(confuse(f1517) is F1517<int>);
+ Expect.isFalse(confuse(f1517) is F1517<bool>);
+ Expect.equals(tIsDynamic, m1517 is F1517<bool>);
+ Expect.equals(tIsDynamic, confuse(m1517) is F1517<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1517 = (f1517 as dynamic); });
+ Expect.throws(() { x1517 = confuse(f1517); });
+ List<T> Function() Function(int x) l1517;
+ Expect.throws(() { l1517 = (f1517 as dynamic); });
+ Expect.throws(() { l1517 = confuse(f1517); });
+ }
+ List<T> Function() Function(int x) l1517 = m1517;
+ // In checked mode, verifies the type.
+ x1517 = m1517;
+ x1517 = confuse(m1517);
+ }
+ }
+
+ void testF1617() {
+ // Function(int x1, [List<Function> x]) Function(int x)
+ Expect.isTrue(f1617 is F1617);
+ Expect.isTrue(confuse(f1617) is F1617);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<Function> x]) Function(int x) l1617;
+ // The static function f1617 sets `T` to `int`.
+ if (!tIsBool) {
+ x1617 = f1617 as dynamic;
+ l1617 = f1617 as dynamic;
+ x1617 = confuse(f1617);
+ l1617 = confuse(f1617);
+ }
+
+ Expect.isTrue(m1617 is F1617);
+ Expect.isTrue(m1617 is Function(int x1, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1617) is F1617);
+ // In checked mode, verifies the type.
+ x1617 = m1617;
+ l1617 = m1617;
+ x1617 = confuse(m1617);
+ l1617 = confuse(m1617);
+
+ }
+
+ void testF1717() {
+ // Function([List<T> x1]) Function(int x)
+ Expect.isTrue(f1717 is F1717);
+ Expect.isTrue(confuse(f1717) is F1717);
+ // In checked mode, verifies the type.
+ Function([List<T> x1]) Function(int x) l1717;
+ // The static function f1717 sets `T` to `int`.
+ if (!tIsBool) {
+ x1717 = f1717 as dynamic;
+ l1717 = f1717 as dynamic;
+ x1717 = confuse(f1717);
+ l1717 = confuse(f1717);
+ }
+
+ Expect.isTrue(m1717 is F1717);
+ Expect.isTrue(m1717 is Function([List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1717) is F1717);
+ // In checked mode, verifies the type.
+ x1717 = m1717;
+ l1717 = m1717;
+ x1717 = confuse(m1717);
+ l1717 = confuse(m1717);
+ if (!tIsBool) {
+ Expect.isTrue(f1717 is F1717<int>);
+ Expect.isFalse(f1717 is F1717<bool>);
+ Expect.isTrue(confuse(f1717) is F1717<int>);
+ Expect.isFalse(confuse(f1717) is F1717<bool>);
+ Expect.equals(tIsDynamic, m1717 is F1717<bool>);
+ Expect.equals(tIsDynamic, confuse(m1717) is F1717<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1717 = (f1717 as dynamic); });
+ Expect.throws(() { x1717 = confuse(f1717); });
+ Function([List<T> x1]) Function(int x) l1717;
+ Expect.throws(() { l1717 = (f1717 as dynamic); });
+ Expect.throws(() { l1717 = confuse(f1717); });
+ }
+ Function([List<T> x1]) Function(int x) l1717 = m1717;
+ // In checked mode, verifies the type.
+ x1717 = m1717;
+ x1717 = confuse(m1717);
+ }
+ }
+
+ void testF1817() {
+ // List<Function> Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1817 is F1817);
+ Expect.isTrue(confuse(f1817) is F1817);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<Function> x) Function(int x) l1817;
+ // The static function f1817 sets `T` to `int`.
+ if (!tIsBool) {
+ x1817 = f1817 as dynamic;
+ l1817 = f1817 as dynamic;
+ x1817 = confuse(f1817);
+ l1817 = confuse(f1817);
+ }
+
+ Expect.isTrue(m1817 is F1817);
+ Expect.isTrue(m1817 is List<Function> Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1817) is F1817);
+ // In checked mode, verifies the type.
+ x1817 = m1817;
+ l1817 = m1817;
+ x1817 = confuse(m1817);
+ l1817 = confuse(m1817);
+
+ }
+
+ void testF1917() {
+ // Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1917 is F1917);
+ Expect.isTrue(confuse(f1917) is F1917);
+ // In checked mode, verifies the type.
+ Function<A>(core.List<core.int> x) Function(int x) l1917;
+ // The static function f1917 sets `T` to `int`.
+ if (!tIsBool) {
+ x1917 = f1917 as dynamic;
+ l1917 = f1917 as dynamic;
+ x1917 = confuse(f1917);
+ l1917 = confuse(f1917);
+ }
+
+ Expect.isTrue(m1917 is F1917);
+ Expect.isTrue(m1917 is Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1917) is F1917);
+ // In checked mode, verifies the type.
+ x1917 = m1917;
+ l1917 = m1917;
+ x1917 = confuse(m1917);
+ l1917 = confuse(m1917);
+
+ }
+
+ void testF2017() {
+ // B Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2017 is F2017);
+ Expect.isTrue(confuse(f2017) is F2017);
+ // In checked mode, verifies the type.
+ B Function(int x) Function<B extends core.int>(int x) l2017;
+ // The static function f2017 sets `T` to `int`.
+ if (!tIsBool) {
+ x2017 = f2017 as dynamic;
+ l2017 = f2017 as dynamic;
+ x2017 = confuse(f2017);
+ l2017 = confuse(f2017);
+ }
+
+ Expect.isTrue(m2017 is F2017);
+ Expect.isTrue(m2017 is B Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2017) is F2017);
+ // In checked mode, verifies the type.
+ x2017 = m2017;
+ l2017 = m2017;
+ x2017 = confuse(m2017);
+ l2017 = confuse(m2017);
+
+ }
+
+
+}
+
+class C18<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x, [Function x2]) x18;
+ List<Function> Function(int x1, [int x2]) x118;
+ core.List<core.int> Function(int x1, [List<T> x2]) x218;
+ Function([core.List<core.int> x1]) x318;
+ int Function(int x1) Function<B extends core.int>() x418;
+ int Function(int x, [List<Function> x1]) Function<B extends core.int>() x518;
+ int Function(int y, {List<T> x}) Function<B extends core.int>() x618;
+ Function Function([List<Function> x]) Function<B extends core.int>() x718;
+ Function Function(List<T> x1) Function<B extends core.int>() x818;
+ List<Function> Function(int x2, [Function x3]) Function<B extends core.int>() x918;
+ List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() x1018;
+ core.List<core.int> Function(Function x) Function<B extends core.int>() x1118;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() x1218;
+ List<T> Function([int x1]) Function<B extends core.int>() x1318;
+ List<T> Function({List<Function> x}) Function<B extends core.int>() x1418;
+ List<T> Function() Function<B extends core.int>() x1518;
+ Function(int x1, [List<Function> x]) Function<B extends core.int>() x1618;
+ Function([List<T> x1]) Function<B extends core.int>() x1718;
+ List<Function> Function<A>(List<Function> x) Function<B extends core.int>() x1818;
+ Function<A>(core.List<core.int> x) Function<B extends core.int>() x1918;
+ B Function(Function x) Function<B extends core.int>() x2018;
+
+
+ C18({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m18(int x, [Function x0]) => null;
+ List<Function> m118(int x0, [int x1]) => null;
+ core.List<core.int> m218(int x0, [List<T> x1]) => null;
+ m318([core.List<core.int> x0]) => null;
+ int Function(int x0) m418<B extends core.int>() => null;
+ int Function(int x, [List<Function> x0]) m518<B extends core.int>() => null;
+ int Function(int y, {List<T> x}) m618<B extends core.int>() => null;
+ Function Function([List<Function> x]) m718<B extends core.int>() => null;
+ Function Function(List<T> x0) m818<B extends core.int>() => null;
+ List<Function> Function(int x0, [Function x1]) m918<B extends core.int>() => null;
+ List<Function> Function(int x0, {core.List<core.int> x}) m1018<B extends core.int>() => null;
+ core.List<core.int> Function(Function x) m1118<B extends core.int>() => null;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) m1218<B extends core.int>() => null;
+ List<T> Function([int x0]) m1318<B extends core.int>() => null;
+ List<T> Function({List<Function> x}) m1418<B extends core.int>() => null;
+ List<T> Function() m1518<B extends core.int>() => null;
+ Function(int x0, [List<Function> x]) m1618<B extends core.int>() => null;
+ Function([List<T> x0]) m1718<B extends core.int>() => null;
+ List<Function> Function<A>(List<Function> x) m1818<B extends core.int>() => null;
+ Function<A>(core.List<core.int> x) m1918<B extends core.int>() => null;
+ B Function(Function x) m2018<B extends core.int>() => null;
+
+
+ runTests() {
+ testF18();
+ testF118();
+ testF218();
+ testF318();
+ testF418();
+ testF518();
+ testF618();
+ testF718();
+ testF818();
+ testF918();
+ testF1018();
+ testF1118();
+ testF1218();
+ testF1318();
+ testF1418();
+ testF1518();
+ testF1618();
+ testF1718();
+ testF1818();
+ testF1918();
+ testF2018();
+ }
+
+ void testF18() {
+ // int Function(int x, [Function x2])
+ Expect.isTrue(f18 is F18);
+ Expect.isTrue(confuse(f18) is F18);
+ // In checked mode, verifies the type.
+ int Function(int x, [Function x2]) l18;
+ // The static function f18 sets `T` to `int`.
+ if (!tIsBool) {
+ x18 = f18 as dynamic;
+ l18 = f18 as dynamic;
+ x18 = confuse(f18);
+ l18 = confuse(f18);
+ }
+
+ Expect.isTrue(m18 is F18);
+ Expect.isTrue(m18 is int Function(int x, [Function x2]));
+ Expect.isTrue(confuse(m18) is F18);
+ // In checked mode, verifies the type.
+ x18 = m18;
+ l18 = m18;
+ x18 = confuse(m18);
+ l18 = confuse(m18);
+
+ }
+
+ void testF118() {
+ // List<Function> Function(int x1, [int x2])
+ Expect.isTrue(f118 is F118);
+ Expect.isTrue(confuse(f118) is F118);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [int x2]) l118;
+ // The static function f118 sets `T` to `int`.
+ if (!tIsBool) {
+ x118 = f118 as dynamic;
+ l118 = f118 as dynamic;
+ x118 = confuse(f118);
+ l118 = confuse(f118);
+ }
+
+ Expect.isTrue(m118 is F118);
+ Expect.isTrue(m118 is List<Function> Function(int x1, [int x2]));
+ Expect.isTrue(confuse(m118) is F118);
+ // In checked mode, verifies the type.
+ x118 = m118;
+ l118 = m118;
+ x118 = confuse(m118);
+ l118 = confuse(m118);
+
+ }
+
+ void testF218() {
+ // core.List<core.int> Function(int x1, [List<T> x2])
+ Expect.isTrue(f218 is F218);
+ Expect.isTrue(confuse(f218) is F218);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<T> x2]) l218;
+ // The static function f218 sets `T` to `int`.
+ if (!tIsBool) {
+ x218 = f218 as dynamic;
+ l218 = f218 as dynamic;
+ x218 = confuse(f218);
+ l218 = confuse(f218);
+ }
+
+ Expect.isTrue(m218 is F218);
+ Expect.isTrue(m218 is core.List<core.int> Function(int x1, [List<T> x2]));
+ Expect.isTrue(confuse(m218) is F218);
+ // In checked mode, verifies the type.
+ x218 = m218;
+ l218 = m218;
+ x218 = confuse(m218);
+ l218 = confuse(m218);
+ if (!tIsBool) {
+ Expect.isTrue(f218 is F218<int>);
+ Expect.isFalse(f218 is F218<bool>);
+ Expect.isTrue(confuse(f218) is F218<int>);
+ Expect.isFalse(confuse(f218) is F218<bool>);
+ Expect.equals(tIsDynamic, m218 is F218<bool>);
+ Expect.equals(tIsDynamic, confuse(m218) is F218<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x218 = (f218 as dynamic); });
+ Expect.throws(() { x218 = confuse(f218); });
+ core.List<core.int> Function(int x1, [List<T> x2]) l218;
+ Expect.throws(() { l218 = (f218 as dynamic); });
+ Expect.throws(() { l218 = confuse(f218); });
+ }
+ core.List<core.int> Function(int x1, [List<T> x2]) l218 = m218;
+ // In checked mode, verifies the type.
+ x218 = m218;
+ x218 = confuse(m218);
+ }
+ }
+
+ void testF318() {
+ // Function([core.List<core.int> x1])
+ Expect.isTrue(f318 is F318);
+ Expect.isTrue(confuse(f318) is F318);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x1]) l318;
+ // The static function f318 sets `T` to `int`.
+ if (!tIsBool) {
+ x318 = f318 as dynamic;
+ l318 = f318 as dynamic;
+ x318 = confuse(f318);
+ l318 = confuse(f318);
+ }
+
+ Expect.isTrue(m318 is F318);
+ Expect.isTrue(m318 is Function([core.List<core.int> x1]));
+ Expect.isTrue(confuse(m318) is F318);
+ // In checked mode, verifies the type.
+ x318 = m318;
+ l318 = m318;
+ x318 = confuse(m318);
+ l318 = confuse(m318);
+
+ }
+
+ void testF418() {
+ // int Function(int x1) Function<B extends core.int>()
+ Expect.isTrue(f418 is F418);
+ Expect.isTrue(confuse(f418) is F418);
+ // In checked mode, verifies the type.
+ int Function(int x1) Function<B extends core.int>() l418;
+ // The static function f418 sets `T` to `int`.
+ if (!tIsBool) {
+ x418 = f418 as dynamic;
+ l418 = f418 as dynamic;
+ x418 = confuse(f418);
+ l418 = confuse(f418);
+ }
+
+ Expect.isTrue(m418 is F418);
+ Expect.isTrue(m418 is int Function(int x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m418) is F418);
+ // In checked mode, verifies the type.
+ x418 = m418;
+ l418 = m418;
+ x418 = confuse(m418);
+ l418 = confuse(m418);
+
+ }
+
+ void testF518() {
+ // int Function(int x, [List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f518 is F518);
+ Expect.isTrue(confuse(f518) is F518);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<Function> x1]) Function<B extends core.int>() l518;
+ // The static function f518 sets `T` to `int`.
+ if (!tIsBool) {
+ x518 = f518 as dynamic;
+ l518 = f518 as dynamic;
+ x518 = confuse(f518);
+ l518 = confuse(f518);
+ }
+
+ Expect.isTrue(m518 is F518);
+ Expect.isTrue(m518 is int Function(int x, [List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m518) is F518);
+ // In checked mode, verifies the type.
+ x518 = m518;
+ l518 = m518;
+ x518 = confuse(m518);
+ l518 = confuse(m518);
+
+ }
+
+ void testF618() {
+ // int Function(int y, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f618 is F618);
+ Expect.isTrue(confuse(f618) is F618);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<T> x}) Function<B extends core.int>() l618;
+ // The static function f618 sets `T` to `int`.
+ if (!tIsBool) {
+ x618 = f618 as dynamic;
+ l618 = f618 as dynamic;
+ x618 = confuse(f618);
+ l618 = confuse(f618);
+ }
+
+ Expect.isTrue(m618 is F618);
+ Expect.isTrue(m618 is int Function(int y, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m618) is F618);
+ // In checked mode, verifies the type.
+ x618 = m618;
+ l618 = m618;
+ x618 = confuse(m618);
+ l618 = confuse(m618);
+ if (!tIsBool) {
+ Expect.isTrue(f618 is F618<int>);
+ Expect.isFalse(f618 is F618<bool>);
+ Expect.isTrue(confuse(f618) is F618<int>);
+ Expect.isFalse(confuse(f618) is F618<bool>);
+ Expect.equals(tIsDynamic, m618 is F618<bool>);
+ Expect.equals(tIsDynamic, confuse(m618) is F618<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x618 = (f618 as dynamic); });
+ Expect.throws(() { x618 = confuse(f618); });
+ int Function(int y, {List<T> x}) Function<B extends core.int>() l618;
+ Expect.throws(() { l618 = (f618 as dynamic); });
+ Expect.throws(() { l618 = confuse(f618); });
+ }
+ int Function(int y, {List<T> x}) Function<B extends core.int>() l618 = m618;
+ // In checked mode, verifies the type.
+ x618 = m618;
+ x618 = confuse(m618);
+ }
+ }
+
+ void testF718() {
+ // Function Function([List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f718 is F718);
+ Expect.isTrue(confuse(f718) is F718);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x]) Function<B extends core.int>() l718;
+ // The static function f718 sets `T` to `int`.
+ if (!tIsBool) {
+ x718 = f718 as dynamic;
+ l718 = f718 as dynamic;
+ x718 = confuse(f718);
+ l718 = confuse(f718);
+ }
+
+ Expect.isTrue(m718 is F718);
+ Expect.isTrue(m718 is Function Function([List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m718) is F718);
+ // In checked mode, verifies the type.
+ x718 = m718;
+ l718 = m718;
+ x718 = confuse(m718);
+ l718 = confuse(m718);
+
+ }
+
+ void testF818() {
+ // Function Function(List<T> x1) Function<B extends core.int>()
+ Expect.isTrue(f818 is F818);
+ Expect.isTrue(confuse(f818) is F818);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x1) Function<B extends core.int>() l818;
+ // The static function f818 sets `T` to `int`.
+ if (!tIsBool) {
+ x818 = f818 as dynamic;
+ l818 = f818 as dynamic;
+ x818 = confuse(f818);
+ l818 = confuse(f818);
+ }
+
+ Expect.isTrue(m818 is F818);
+ Expect.isTrue(m818 is Function Function(List<T> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m818) is F818);
+ // In checked mode, verifies the type.
+ x818 = m818;
+ l818 = m818;
+ x818 = confuse(m818);
+ l818 = confuse(m818);
+ if (!tIsBool) {
+ Expect.isTrue(f818 is F818<int>);
+ Expect.isFalse(f818 is F818<bool>);
+ Expect.isTrue(confuse(f818) is F818<int>);
+ Expect.isFalse(confuse(f818) is F818<bool>);
+ Expect.equals(tIsDynamic, m818 is F818<bool>);
+ Expect.equals(tIsDynamic, confuse(m818) is F818<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x818 = (f818 as dynamic); });
+ Expect.throws(() { x818 = confuse(f818); });
+ Function Function(List<T> x1) Function<B extends core.int>() l818;
+ Expect.throws(() { l818 = (f818 as dynamic); });
+ Expect.throws(() { l818 = confuse(f818); });
+ }
+ Function Function(List<T> x1) Function<B extends core.int>() l818 = m818;
+ // In checked mode, verifies the type.
+ x818 = m818;
+ x818 = confuse(m818);
+ }
+ }
+
+ void testF918() {
+ // List<Function> Function(int x2, [Function x3]) Function<B extends core.int>()
+ Expect.isTrue(f918 is F918);
+ Expect.isTrue(confuse(f918) is F918);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [Function x3]) Function<B extends core.int>() l918;
+ // The static function f918 sets `T` to `int`.
+ if (!tIsBool) {
+ x918 = f918 as dynamic;
+ l918 = f918 as dynamic;
+ x918 = confuse(f918);
+ l918 = confuse(f918);
+ }
+
+ Expect.isTrue(m918 is F918);
+ Expect.isTrue(m918 is List<Function> Function(int x2, [Function x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m918) is F918);
+ // In checked mode, verifies the type.
+ x918 = m918;
+ l918 = m918;
+ x918 = confuse(m918);
+ l918 = confuse(m918);
+
+ }
+
+ void testF1018() {
+ // List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1018 is F1018);
+ Expect.isTrue(confuse(f1018) is F1018);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l1018;
+ // The static function f1018 sets `T` to `int`.
+ if (!tIsBool) {
+ x1018 = f1018 as dynamic;
+ l1018 = f1018 as dynamic;
+ x1018 = confuse(f1018);
+ l1018 = confuse(f1018);
+ }
+
+ Expect.isTrue(m1018 is F1018);
+ Expect.isTrue(m1018 is List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1018) is F1018);
+ // In checked mode, verifies the type.
+ x1018 = m1018;
+ l1018 = m1018;
+ x1018 = confuse(m1018);
+ l1018 = confuse(m1018);
+
+ }
+
+ void testF1118() {
+ // core.List<core.int> Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1118 is F1118);
+ Expect.isTrue(confuse(f1118) is F1118);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x) Function<B extends core.int>() l1118;
+ // The static function f1118 sets `T` to `int`.
+ if (!tIsBool) {
+ x1118 = f1118 as dynamic;
+ l1118 = f1118 as dynamic;
+ x1118 = confuse(f1118);
+ l1118 = confuse(f1118);
+ }
+
+ Expect.isTrue(m1118 is F1118);
+ Expect.isTrue(m1118 is core.List<core.int> Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1118) is F1118);
+ // In checked mode, verifies the type.
+ x1118 = m1118;
+ l1118 = m1118;
+ x1118 = confuse(m1118);
+ l1118 = confuse(m1118);
+
+ }
+
+ void testF1218() {
+ // core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1218 is F1218);
+ Expect.isTrue(confuse(f1218) is F1218);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l1218;
+ // The static function f1218 sets `T` to `int`.
+ if (!tIsBool) {
+ x1218 = f1218 as dynamic;
+ l1218 = f1218 as dynamic;
+ x1218 = confuse(f1218);
+ l1218 = confuse(f1218);
+ }
+
+ Expect.isTrue(m1218 is F1218);
+ Expect.isTrue(m1218 is core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1218) is F1218);
+ // In checked mode, verifies the type.
+ x1218 = m1218;
+ l1218 = m1218;
+ x1218 = confuse(m1218);
+ l1218 = confuse(m1218);
+
+ }
+
+ void testF1318() {
+ // List<T> Function([int x1]) Function<B extends core.int>()
+ Expect.isTrue(f1318 is F1318);
+ Expect.isTrue(confuse(f1318) is F1318);
+ // In checked mode, verifies the type.
+ List<T> Function([int x1]) Function<B extends core.int>() l1318;
+ // The static function f1318 sets `T` to `int`.
+ if (!tIsBool) {
+ x1318 = f1318 as dynamic;
+ l1318 = f1318 as dynamic;
+ x1318 = confuse(f1318);
+ l1318 = confuse(f1318);
+ }
+
+ Expect.isTrue(m1318 is F1318);
+ Expect.isTrue(m1318 is List<T> Function([int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1318) is F1318);
+ // In checked mode, verifies the type.
+ x1318 = m1318;
+ l1318 = m1318;
+ x1318 = confuse(m1318);
+ l1318 = confuse(m1318);
+ if (!tIsBool) {
+ Expect.isTrue(f1318 is F1318<int>);
+ Expect.isFalse(f1318 is F1318<bool>);
+ Expect.isTrue(confuse(f1318) is F1318<int>);
+ Expect.isFalse(confuse(f1318) is F1318<bool>);
+ Expect.equals(tIsDynamic, m1318 is F1318<bool>);
+ Expect.equals(tIsDynamic, confuse(m1318) is F1318<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1318 = (f1318 as dynamic); });
+ Expect.throws(() { x1318 = confuse(f1318); });
+ List<T> Function([int x1]) Function<B extends core.int>() l1318;
+ Expect.throws(() { l1318 = (f1318 as dynamic); });
+ Expect.throws(() { l1318 = confuse(f1318); });
+ }
+ List<T> Function([int x1]) Function<B extends core.int>() l1318 = m1318;
+ // In checked mode, verifies the type.
+ x1318 = m1318;
+ x1318 = confuse(m1318);
+ }
+ }
+
+ void testF1418() {
+ // List<T> Function({List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1418 is F1418);
+ Expect.isTrue(confuse(f1418) is F1418);
+ // In checked mode, verifies the type.
+ List<T> Function({List<Function> x}) Function<B extends core.int>() l1418;
+ // The static function f1418 sets `T` to `int`.
+ if (!tIsBool) {
+ x1418 = f1418 as dynamic;
+ l1418 = f1418 as dynamic;
+ x1418 = confuse(f1418);
+ l1418 = confuse(f1418);
+ }
+
+ Expect.isTrue(m1418 is F1418);
+ Expect.isTrue(m1418 is List<T> Function({List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1418) is F1418);
+ // In checked mode, verifies the type.
+ x1418 = m1418;
+ l1418 = m1418;
+ x1418 = confuse(m1418);
+ l1418 = confuse(m1418);
+ if (!tIsBool) {
+ Expect.isTrue(f1418 is F1418<int>);
+ Expect.isFalse(f1418 is F1418<bool>);
+ Expect.isTrue(confuse(f1418) is F1418<int>);
+ Expect.isFalse(confuse(f1418) is F1418<bool>);
+ Expect.equals(tIsDynamic, m1418 is F1418<bool>);
+ Expect.equals(tIsDynamic, confuse(m1418) is F1418<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1418 = (f1418 as dynamic); });
+ Expect.throws(() { x1418 = confuse(f1418); });
+ List<T> Function({List<Function> x}) Function<B extends core.int>() l1418;
+ Expect.throws(() { l1418 = (f1418 as dynamic); });
+ Expect.throws(() { l1418 = confuse(f1418); });
+ }
+ List<T> Function({List<Function> x}) Function<B extends core.int>() l1418 = m1418;
+ // In checked mode, verifies the type.
+ x1418 = m1418;
+ x1418 = confuse(m1418);
+ }
+ }
+
+ void testF1518() {
+ // List<T> Function() Function<B extends core.int>()
+ Expect.isTrue(f1518 is F1518);
+ Expect.isTrue(confuse(f1518) is F1518);
+ // In checked mode, verifies the type.
+ List<T> Function() Function<B extends core.int>() l1518;
+ // The static function f1518 sets `T` to `int`.
+ if (!tIsBool) {
+ x1518 = f1518 as dynamic;
+ l1518 = f1518 as dynamic;
+ x1518 = confuse(f1518);
+ l1518 = confuse(f1518);
+ }
+
+ Expect.isTrue(m1518 is F1518);
+ Expect.isTrue(m1518 is List<T> Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1518) is F1518);
+ // In checked mode, verifies the type.
+ x1518 = m1518;
+ l1518 = m1518;
+ x1518 = confuse(m1518);
+ l1518 = confuse(m1518);
+ if (!tIsBool) {
+ Expect.isTrue(f1518 is F1518<int>);
+ Expect.isFalse(f1518 is F1518<bool>);
+ Expect.isTrue(confuse(f1518) is F1518<int>);
+ Expect.isFalse(confuse(f1518) is F1518<bool>);
+ Expect.equals(tIsDynamic, m1518 is F1518<bool>);
+ Expect.equals(tIsDynamic, confuse(m1518) is F1518<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1518 = (f1518 as dynamic); });
+ Expect.throws(() { x1518 = confuse(f1518); });
+ List<T> Function() Function<B extends core.int>() l1518;
+ Expect.throws(() { l1518 = (f1518 as dynamic); });
+ Expect.throws(() { l1518 = confuse(f1518); });
+ }
+ List<T> Function() Function<B extends core.int>() l1518 = m1518;
+ // In checked mode, verifies the type.
+ x1518 = m1518;
+ x1518 = confuse(m1518);
+ }
+ }
+
+ void testF1618() {
+ // Function(int x1, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1618 is F1618);
+ Expect.isTrue(confuse(f1618) is F1618);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<Function> x]) Function<B extends core.int>() l1618;
+ // The static function f1618 sets `T` to `int`.
+ if (!tIsBool) {
+ x1618 = f1618 as dynamic;
+ l1618 = f1618 as dynamic;
+ x1618 = confuse(f1618);
+ l1618 = confuse(f1618);
+ }
+
+ Expect.isTrue(m1618 is F1618);
+ Expect.isTrue(m1618 is Function(int x1, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1618) is F1618);
+ // In checked mode, verifies the type.
+ x1618 = m1618;
+ l1618 = m1618;
+ x1618 = confuse(m1618);
+ l1618 = confuse(m1618);
+
+ }
+
+ void testF1718() {
+ // Function([List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1718 is F1718);
+ Expect.isTrue(confuse(f1718) is F1718);
+ // In checked mode, verifies the type.
+ Function([List<T> x1]) Function<B extends core.int>() l1718;
+ // The static function f1718 sets `T` to `int`.
+ if (!tIsBool) {
+ x1718 = f1718 as dynamic;
+ l1718 = f1718 as dynamic;
+ x1718 = confuse(f1718);
+ l1718 = confuse(f1718);
+ }
+
+ Expect.isTrue(m1718 is F1718);
+ Expect.isTrue(m1718 is Function([List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1718) is F1718);
+ // In checked mode, verifies the type.
+ x1718 = m1718;
+ l1718 = m1718;
+ x1718 = confuse(m1718);
+ l1718 = confuse(m1718);
+ if (!tIsBool) {
+ Expect.isTrue(f1718 is F1718<int>);
+ Expect.isFalse(f1718 is F1718<bool>);
+ Expect.isTrue(confuse(f1718) is F1718<int>);
+ Expect.isFalse(confuse(f1718) is F1718<bool>);
+ Expect.equals(tIsDynamic, m1718 is F1718<bool>);
+ Expect.equals(tIsDynamic, confuse(m1718) is F1718<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1718 = (f1718 as dynamic); });
+ Expect.throws(() { x1718 = confuse(f1718); });
+ Function([List<T> x1]) Function<B extends core.int>() l1718;
+ Expect.throws(() { l1718 = (f1718 as dynamic); });
+ Expect.throws(() { l1718 = confuse(f1718); });
+ }
+ Function([List<T> x1]) Function<B extends core.int>() l1718 = m1718;
+ // In checked mode, verifies the type.
+ x1718 = m1718;
+ x1718 = confuse(m1718);
+ }
+ }
+
+ void testF1818() {
+ // List<Function> Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1818 is F1818);
+ Expect.isTrue(confuse(f1818) is F1818);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<Function> x) Function<B extends core.int>() l1818;
+ // The static function f1818 sets `T` to `int`.
+ if (!tIsBool) {
+ x1818 = f1818 as dynamic;
+ l1818 = f1818 as dynamic;
+ x1818 = confuse(f1818);
+ l1818 = confuse(f1818);
+ }
+
+ Expect.isTrue(m1818 is F1818);
+ Expect.isTrue(m1818 is List<Function> Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1818) is F1818);
+ // In checked mode, verifies the type.
+ x1818 = m1818;
+ l1818 = m1818;
+ x1818 = confuse(m1818);
+ l1818 = confuse(m1818);
+
+ }
+
+ void testF1918() {
+ // Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1918 is F1918);
+ Expect.isTrue(confuse(f1918) is F1918);
+ // In checked mode, verifies the type.
+ Function<A>(core.List<core.int> x) Function<B extends core.int>() l1918;
+ // The static function f1918 sets `T` to `int`.
+ if (!tIsBool) {
+ x1918 = f1918 as dynamic;
+ l1918 = f1918 as dynamic;
+ x1918 = confuse(f1918);
+ l1918 = confuse(f1918);
+ }
+
+ Expect.isTrue(m1918 is F1918);
+ Expect.isTrue(m1918 is Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1918) is F1918);
+ // In checked mode, verifies the type.
+ x1918 = m1918;
+ l1918 = m1918;
+ x1918 = confuse(m1918);
+ l1918 = confuse(m1918);
+
+ }
+
+ void testF2018() {
+ // B Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f2018 is F2018);
+ Expect.isTrue(confuse(f2018) is F2018);
+ // In checked mode, verifies the type.
+ B Function(Function x) Function<B extends core.int>() l2018;
+ // The static function f2018 sets `T` to `int`.
+ if (!tIsBool) {
+ x2018 = f2018 as dynamic;
+ l2018 = f2018 as dynamic;
+ x2018 = confuse(f2018);
+ l2018 = confuse(f2018);
+ }
+
+ Expect.isTrue(m2018 is F2018);
+ Expect.isTrue(m2018 is B Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2018) is F2018);
+ // In checked mode, verifies the type.
+ x2018 = m2018;
+ l2018 = m2018;
+ x2018 = confuse(m2018);
+ l2018 = confuse(m2018);
+
+ }
+
+
+}
+
+class C19<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function({Function x}) x19;
+ List<Function> Function(int x, [int x2]) x119;
+ core.List<core.int> Function(int x, [List<T> x2]) x219;
+ Function(int x1, [core.List<core.int> x2]) x319;
+ int Function(int x1) Function<B extends core.int>(int x) x419;
+ int Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) x519;
+ int Function(int y, {List<T> x}) Function<B extends core.int>(int x) x619;
+ Function Function([List<Function> x]) Function<B extends core.int>(int x) x719;
+ Function Function(List<T> x1) Function<B extends core.int>(int x) x819;
+ List<Function> Function(int x2, [Function x3]) Function<B extends core.int>(int x) x919;
+ List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) x1019;
+ core.List<core.int> Function(Function x) Function<B extends core.int>(int x) x1119;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) x1219;
+ List<T> Function([int x1]) Function<B extends core.int>(int x) x1319;
+ List<T> Function({List<Function> x}) Function<B extends core.int>(int x) x1419;
+ List<T> Function() Function<B extends core.int>(int x) x1519;
+ Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) x1619;
+ Function([List<T> x1]) Function<B extends core.int>(int x) x1719;
+ List<Function> Function<A>(List<Function> x) Function<B extends core.int>(int x) x1819;
+ Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1919;
+ B Function(Function x) Function<B extends core.int>(int x) x2019;
+
+
+ C19({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m19({Function x}) => null;
+ List<Function> m119(int x, [int x0]) => null;
+ core.List<core.int> m219(int x, [List<T> x0]) => null;
+ m319(int x0, [core.List<core.int> x1]) => null;
+ int Function(int x0) m419<B extends core.int>(int x) => null;
+ int Function(int x, [List<Function> x0]) m519<B extends core.int>(int x) => null;
+ int Function(int y, {List<T> x}) m619<B extends core.int>(int x) => null;
+ Function Function([List<Function> x]) m719<B extends core.int>(int x) => null;
+ Function Function(List<T> x0) m819<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [Function x1]) m919<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, {core.List<core.int> x}) m1019<B extends core.int>(int x) => null;
+ core.List<core.int> Function(Function x) m1119<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, [core.List<core.int> x]) m1219<B extends core.int>(int x) => null;
+ List<T> Function([int x0]) m1319<B extends core.int>(int x) => null;
+ List<T> Function({List<Function> x}) m1419<B extends core.int>(int x) => null;
+ List<T> Function() m1519<B extends core.int>(int x) => null;
+ Function(int x0, [List<Function> x]) m1619<B extends core.int>(int x) => null;
+ Function([List<T> x0]) m1719<B extends core.int>(int x) => null;
+ List<Function> Function<A>(List<Function> x) m1819<B extends core.int>(int x) => null;
+ Function<A>(core.List<core.int> x) m1919<B extends core.int>(int x) => null;
+ B Function(Function x) m2019<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF19();
+ testF119();
+ testF219();
+ testF319();
+ testF419();
+ testF519();
+ testF619();
+ testF719();
+ testF819();
+ testF919();
+ testF1019();
+ testF1119();
+ testF1219();
+ testF1319();
+ testF1419();
+ testF1519();
+ testF1619();
+ testF1719();
+ testF1819();
+ testF1919();
+ testF2019();
+ }
+
+ void testF19() {
+ // int Function({Function x})
+ Expect.isTrue(f19 is F19);
+ Expect.isTrue(confuse(f19) is F19);
+ // In checked mode, verifies the type.
+ int Function({Function x}) l19;
+ // The static function f19 sets `T` to `int`.
+ if (!tIsBool) {
+ x19 = f19 as dynamic;
+ l19 = f19 as dynamic;
+ x19 = confuse(f19);
+ l19 = confuse(f19);
+ }
+
+ Expect.isTrue(m19 is F19);
+ Expect.isTrue(m19 is int Function({Function x}));
+ Expect.isTrue(confuse(m19) is F19);
+ // In checked mode, verifies the type.
+ x19 = m19;
+ l19 = m19;
+ x19 = confuse(m19);
+ l19 = confuse(m19);
+
+ }
+
+ void testF119() {
+ // List<Function> Function(int x, [int x2])
+ Expect.isTrue(f119 is F119);
+ Expect.isTrue(confuse(f119) is F119);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [int x2]) l119;
+ // The static function f119 sets `T` to `int`.
+ if (!tIsBool) {
+ x119 = f119 as dynamic;
+ l119 = f119 as dynamic;
+ x119 = confuse(f119);
+ l119 = confuse(f119);
+ }
+
+ Expect.isTrue(m119 is F119);
+ Expect.isTrue(m119 is List<Function> Function(int x, [int x2]));
+ Expect.isTrue(confuse(m119) is F119);
+ // In checked mode, verifies the type.
+ x119 = m119;
+ l119 = m119;
+ x119 = confuse(m119);
+ l119 = confuse(m119);
+
+ }
+
+ void testF219() {
+ // core.List<core.int> Function(int x, [List<T> x2])
+ Expect.isTrue(f219 is F219);
+ Expect.isTrue(confuse(f219) is F219);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<T> x2]) l219;
+ // The static function f219 sets `T` to `int`.
+ if (!tIsBool) {
+ x219 = f219 as dynamic;
+ l219 = f219 as dynamic;
+ x219 = confuse(f219);
+ l219 = confuse(f219);
+ }
+
+ Expect.isTrue(m219 is F219);
+ Expect.isTrue(m219 is core.List<core.int> Function(int x, [List<T> x2]));
+ Expect.isTrue(confuse(m219) is F219);
+ // In checked mode, verifies the type.
+ x219 = m219;
+ l219 = m219;
+ x219 = confuse(m219);
+ l219 = confuse(m219);
+ if (!tIsBool) {
+ Expect.isTrue(f219 is F219<int>);
+ Expect.isFalse(f219 is F219<bool>);
+ Expect.isTrue(confuse(f219) is F219<int>);
+ Expect.isFalse(confuse(f219) is F219<bool>);
+ Expect.equals(tIsDynamic, m219 is F219<bool>);
+ Expect.equals(tIsDynamic, confuse(m219) is F219<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x219 = (f219 as dynamic); });
+ Expect.throws(() { x219 = confuse(f219); });
+ core.List<core.int> Function(int x, [List<T> x2]) l219;
+ Expect.throws(() { l219 = (f219 as dynamic); });
+ Expect.throws(() { l219 = confuse(f219); });
+ }
+ core.List<core.int> Function(int x, [List<T> x2]) l219 = m219;
+ // In checked mode, verifies the type.
+ x219 = m219;
+ x219 = confuse(m219);
+ }
+ }
+
+ void testF319() {
+ // Function(int x1, [core.List<core.int> x2])
+ Expect.isTrue(f319 is F319);
+ Expect.isTrue(confuse(f319) is F319);
+ // In checked mode, verifies the type.
+ Function(int x1, [core.List<core.int> x2]) l319;
+ // The static function f319 sets `T` to `int`.
+ if (!tIsBool) {
+ x319 = f319 as dynamic;
+ l319 = f319 as dynamic;
+ x319 = confuse(f319);
+ l319 = confuse(f319);
+ }
+
+ Expect.isTrue(m319 is F319);
+ Expect.isTrue(m319 is Function(int x1, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m319) is F319);
+ // In checked mode, verifies the type.
+ x319 = m319;
+ l319 = m319;
+ x319 = confuse(m319);
+ l319 = confuse(m319);
+
+ }
+
+ void testF419() {
+ // int Function(int x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f419 is F419);
+ Expect.isTrue(confuse(f419) is F419);
+ // In checked mode, verifies the type.
+ int Function(int x1) Function<B extends core.int>(int x) l419;
+ // The static function f419 sets `T` to `int`.
+ if (!tIsBool) {
+ x419 = f419 as dynamic;
+ l419 = f419 as dynamic;
+ x419 = confuse(f419);
+ l419 = confuse(f419);
+ }
+
+ Expect.isTrue(m419 is F419);
+ Expect.isTrue(m419 is int Function(int x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m419) is F419);
+ // In checked mode, verifies the type.
+ x419 = m419;
+ l419 = m419;
+ x419 = confuse(m419);
+ l419 = confuse(m419);
+
+ }
+
+ void testF519() {
+ // int Function(int x, [List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f519 is F519);
+ Expect.isTrue(confuse(f519) is F519);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l519;
+ // The static function f519 sets `T` to `int`.
+ if (!tIsBool) {
+ x519 = f519 as dynamic;
+ l519 = f519 as dynamic;
+ x519 = confuse(f519);
+ l519 = confuse(f519);
+ }
+
+ Expect.isTrue(m519 is F519);
+ Expect.isTrue(m519 is int Function(int x, [List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m519) is F519);
+ // In checked mode, verifies the type.
+ x519 = m519;
+ l519 = m519;
+ x519 = confuse(m519);
+ l519 = confuse(m519);
+
+ }
+
+ void testF619() {
+ // int Function(int y, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f619 is F619);
+ Expect.isTrue(confuse(f619) is F619);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<T> x}) Function<B extends core.int>(int x) l619;
+ // The static function f619 sets `T` to `int`.
+ if (!tIsBool) {
+ x619 = f619 as dynamic;
+ l619 = f619 as dynamic;
+ x619 = confuse(f619);
+ l619 = confuse(f619);
+ }
+
+ Expect.isTrue(m619 is F619);
+ Expect.isTrue(m619 is int Function(int y, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m619) is F619);
+ // In checked mode, verifies the type.
+ x619 = m619;
+ l619 = m619;
+ x619 = confuse(m619);
+ l619 = confuse(m619);
+ if (!tIsBool) {
+ Expect.isTrue(f619 is F619<int>);
+ Expect.isFalse(f619 is F619<bool>);
+ Expect.isTrue(confuse(f619) is F619<int>);
+ Expect.isFalse(confuse(f619) is F619<bool>);
+ Expect.equals(tIsDynamic, m619 is F619<bool>);
+ Expect.equals(tIsDynamic, confuse(m619) is F619<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x619 = (f619 as dynamic); });
+ Expect.throws(() { x619 = confuse(f619); });
+ int Function(int y, {List<T> x}) Function<B extends core.int>(int x) l619;
+ Expect.throws(() { l619 = (f619 as dynamic); });
+ Expect.throws(() { l619 = confuse(f619); });
+ }
+ int Function(int y, {List<T> x}) Function<B extends core.int>(int x) l619 = m619;
+ // In checked mode, verifies the type.
+ x619 = m619;
+ x619 = confuse(m619);
+ }
+ }
+
+ void testF719() {
+ // Function Function([List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f719 is F719);
+ Expect.isTrue(confuse(f719) is F719);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x]) Function<B extends core.int>(int x) l719;
+ // The static function f719 sets `T` to `int`.
+ if (!tIsBool) {
+ x719 = f719 as dynamic;
+ l719 = f719 as dynamic;
+ x719 = confuse(f719);
+ l719 = confuse(f719);
+ }
+
+ Expect.isTrue(m719 is F719);
+ Expect.isTrue(m719 is Function Function([List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m719) is F719);
+ // In checked mode, verifies the type.
+ x719 = m719;
+ l719 = m719;
+ x719 = confuse(m719);
+ l719 = confuse(m719);
+
+ }
+
+ void testF819() {
+ // Function Function(List<T> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f819 is F819);
+ Expect.isTrue(confuse(f819) is F819);
+ // In checked mode, verifies the type.
+ Function Function(List<T> x1) Function<B extends core.int>(int x) l819;
+ // The static function f819 sets `T` to `int`.
+ if (!tIsBool) {
+ x819 = f819 as dynamic;
+ l819 = f819 as dynamic;
+ x819 = confuse(f819);
+ l819 = confuse(f819);
+ }
+
+ Expect.isTrue(m819 is F819);
+ Expect.isTrue(m819 is Function Function(List<T> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m819) is F819);
+ // In checked mode, verifies the type.
+ x819 = m819;
+ l819 = m819;
+ x819 = confuse(m819);
+ l819 = confuse(m819);
+ if (!tIsBool) {
+ Expect.isTrue(f819 is F819<int>);
+ Expect.isFalse(f819 is F819<bool>);
+ Expect.isTrue(confuse(f819) is F819<int>);
+ Expect.isFalse(confuse(f819) is F819<bool>);
+ Expect.equals(tIsDynamic, m819 is F819<bool>);
+ Expect.equals(tIsDynamic, confuse(m819) is F819<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x819 = (f819 as dynamic); });
+ Expect.throws(() { x819 = confuse(f819); });
+ Function Function(List<T> x1) Function<B extends core.int>(int x) l819;
+ Expect.throws(() { l819 = (f819 as dynamic); });
+ Expect.throws(() { l819 = confuse(f819); });
+ }
+ Function Function(List<T> x1) Function<B extends core.int>(int x) l819 = m819;
+ // In checked mode, verifies the type.
+ x819 = m819;
+ x819 = confuse(m819);
+ }
+ }
+
+ void testF919() {
+ // List<Function> Function(int x2, [Function x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f919 is F919);
+ Expect.isTrue(confuse(f919) is F919);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [Function x3]) Function<B extends core.int>(int x) l919;
+ // The static function f919 sets `T` to `int`.
+ if (!tIsBool) {
+ x919 = f919 as dynamic;
+ l919 = f919 as dynamic;
+ x919 = confuse(f919);
+ l919 = confuse(f919);
+ }
+
+ Expect.isTrue(m919 is F919);
+ Expect.isTrue(m919 is List<Function> Function(int x2, [Function x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m919) is F919);
+ // In checked mode, verifies the type.
+ x919 = m919;
+ l919 = m919;
+ x919 = confuse(m919);
+ l919 = confuse(m919);
+
+ }
+
+ void testF1019() {
+ // List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1019 is F1019);
+ Expect.isTrue(confuse(f1019) is F1019);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l1019;
+ // The static function f1019 sets `T` to `int`.
+ if (!tIsBool) {
+ x1019 = f1019 as dynamic;
+ l1019 = f1019 as dynamic;
+ x1019 = confuse(f1019);
+ l1019 = confuse(f1019);
+ }
+
+ Expect.isTrue(m1019 is F1019);
+ Expect.isTrue(m1019 is List<Function> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1019) is F1019);
+ // In checked mode, verifies the type.
+ x1019 = m1019;
+ l1019 = m1019;
+ x1019 = confuse(m1019);
+ l1019 = confuse(m1019);
+
+ }
+
+ void testF1119() {
+ // core.List<core.int> Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1119 is F1119);
+ Expect.isTrue(confuse(f1119) is F1119);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x) Function<B extends core.int>(int x) l1119;
+ // The static function f1119 sets `T` to `int`.
+ if (!tIsBool) {
+ x1119 = f1119 as dynamic;
+ l1119 = f1119 as dynamic;
+ x1119 = confuse(f1119);
+ l1119 = confuse(f1119);
+ }
+
+ Expect.isTrue(m1119 is F1119);
+ Expect.isTrue(m1119 is core.List<core.int> Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1119) is F1119);
+ // In checked mode, verifies the type.
+ x1119 = m1119;
+ l1119 = m1119;
+ x1119 = confuse(m1119);
+ l1119 = confuse(m1119);
+
+ }
+
+ void testF1219() {
+ // core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1219 is F1219);
+ Expect.isTrue(confuse(f1219) is F1219);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l1219;
+ // The static function f1219 sets `T` to `int`.
+ if (!tIsBool) {
+ x1219 = f1219 as dynamic;
+ l1219 = f1219 as dynamic;
+ x1219 = confuse(f1219);
+ l1219 = confuse(f1219);
+ }
+
+ Expect.isTrue(m1219 is F1219);
+ Expect.isTrue(m1219 is core.List<core.int> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1219) is F1219);
+ // In checked mode, verifies the type.
+ x1219 = m1219;
+ l1219 = m1219;
+ x1219 = confuse(m1219);
+ l1219 = confuse(m1219);
+
+ }
+
+ void testF1319() {
+ // List<T> Function([int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1319 is F1319);
+ Expect.isTrue(confuse(f1319) is F1319);
+ // In checked mode, verifies the type.
+ List<T> Function([int x1]) Function<B extends core.int>(int x) l1319;
+ // The static function f1319 sets `T` to `int`.
+ if (!tIsBool) {
+ x1319 = f1319 as dynamic;
+ l1319 = f1319 as dynamic;
+ x1319 = confuse(f1319);
+ l1319 = confuse(f1319);
+ }
+
+ Expect.isTrue(m1319 is F1319);
+ Expect.isTrue(m1319 is List<T> Function([int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1319) is F1319);
+ // In checked mode, verifies the type.
+ x1319 = m1319;
+ l1319 = m1319;
+ x1319 = confuse(m1319);
+ l1319 = confuse(m1319);
+ if (!tIsBool) {
+ Expect.isTrue(f1319 is F1319<int>);
+ Expect.isFalse(f1319 is F1319<bool>);
+ Expect.isTrue(confuse(f1319) is F1319<int>);
+ Expect.isFalse(confuse(f1319) is F1319<bool>);
+ Expect.equals(tIsDynamic, m1319 is F1319<bool>);
+ Expect.equals(tIsDynamic, confuse(m1319) is F1319<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1319 = (f1319 as dynamic); });
+ Expect.throws(() { x1319 = confuse(f1319); });
+ List<T> Function([int x1]) Function<B extends core.int>(int x) l1319;
+ Expect.throws(() { l1319 = (f1319 as dynamic); });
+ Expect.throws(() { l1319 = confuse(f1319); });
+ }
+ List<T> Function([int x1]) Function<B extends core.int>(int x) l1319 = m1319;
+ // In checked mode, verifies the type.
+ x1319 = m1319;
+ x1319 = confuse(m1319);
+ }
+ }
+
+ void testF1419() {
+ // List<T> Function({List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1419 is F1419);
+ Expect.isTrue(confuse(f1419) is F1419);
+ // In checked mode, verifies the type.
+ List<T> Function({List<Function> x}) Function<B extends core.int>(int x) l1419;
+ // The static function f1419 sets `T` to `int`.
+ if (!tIsBool) {
+ x1419 = f1419 as dynamic;
+ l1419 = f1419 as dynamic;
+ x1419 = confuse(f1419);
+ l1419 = confuse(f1419);
+ }
+
+ Expect.isTrue(m1419 is F1419);
+ Expect.isTrue(m1419 is List<T> Function({List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1419) is F1419);
+ // In checked mode, verifies the type.
+ x1419 = m1419;
+ l1419 = m1419;
+ x1419 = confuse(m1419);
+ l1419 = confuse(m1419);
+ if (!tIsBool) {
+ Expect.isTrue(f1419 is F1419<int>);
+ Expect.isFalse(f1419 is F1419<bool>);
+ Expect.isTrue(confuse(f1419) is F1419<int>);
+ Expect.isFalse(confuse(f1419) is F1419<bool>);
+ Expect.equals(tIsDynamic, m1419 is F1419<bool>);
+ Expect.equals(tIsDynamic, confuse(m1419) is F1419<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1419 = (f1419 as dynamic); });
+ Expect.throws(() { x1419 = confuse(f1419); });
+ List<T> Function({List<Function> x}) Function<B extends core.int>(int x) l1419;
+ Expect.throws(() { l1419 = (f1419 as dynamic); });
+ Expect.throws(() { l1419 = confuse(f1419); });
+ }
+ List<T> Function({List<Function> x}) Function<B extends core.int>(int x) l1419 = m1419;
+ // In checked mode, verifies the type.
+ x1419 = m1419;
+ x1419 = confuse(m1419);
+ }
+ }
+
+ void testF1519() {
+ // List<T> Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f1519 is F1519);
+ Expect.isTrue(confuse(f1519) is F1519);
+ // In checked mode, verifies the type.
+ List<T> Function() Function<B extends core.int>(int x) l1519;
+ // The static function f1519 sets `T` to `int`.
+ if (!tIsBool) {
+ x1519 = f1519 as dynamic;
+ l1519 = f1519 as dynamic;
+ x1519 = confuse(f1519);
+ l1519 = confuse(f1519);
+ }
+
+ Expect.isTrue(m1519 is F1519);
+ Expect.isTrue(m1519 is List<T> Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1519) is F1519);
+ // In checked mode, verifies the type.
+ x1519 = m1519;
+ l1519 = m1519;
+ x1519 = confuse(m1519);
+ l1519 = confuse(m1519);
+ if (!tIsBool) {
+ Expect.isTrue(f1519 is F1519<int>);
+ Expect.isFalse(f1519 is F1519<bool>);
+ Expect.isTrue(confuse(f1519) is F1519<int>);
+ Expect.isFalse(confuse(f1519) is F1519<bool>);
+ Expect.equals(tIsDynamic, m1519 is F1519<bool>);
+ Expect.equals(tIsDynamic, confuse(m1519) is F1519<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1519 = (f1519 as dynamic); });
+ Expect.throws(() { x1519 = confuse(f1519); });
+ List<T> Function() Function<B extends core.int>(int x) l1519;
+ Expect.throws(() { l1519 = (f1519 as dynamic); });
+ Expect.throws(() { l1519 = confuse(f1519); });
+ }
+ List<T> Function() Function<B extends core.int>(int x) l1519 = m1519;
+ // In checked mode, verifies the type.
+ x1519 = m1519;
+ x1519 = confuse(m1519);
+ }
+ }
+
+ void testF1619() {
+ // Function(int x1, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1619 is F1619);
+ Expect.isTrue(confuse(f1619) is F1619);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l1619;
+ // The static function f1619 sets `T` to `int`.
+ if (!tIsBool) {
+ x1619 = f1619 as dynamic;
+ l1619 = f1619 as dynamic;
+ x1619 = confuse(f1619);
+ l1619 = confuse(f1619);
+ }
+
+ Expect.isTrue(m1619 is F1619);
+ Expect.isTrue(m1619 is Function(int x1, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1619) is F1619);
+ // In checked mode, verifies the type.
+ x1619 = m1619;
+ l1619 = m1619;
+ x1619 = confuse(m1619);
+ l1619 = confuse(m1619);
+
+ }
+
+ void testF1719() {
+ // Function([List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1719 is F1719);
+ Expect.isTrue(confuse(f1719) is F1719);
+ // In checked mode, verifies the type.
+ Function([List<T> x1]) Function<B extends core.int>(int x) l1719;
+ // The static function f1719 sets `T` to `int`.
+ if (!tIsBool) {
+ x1719 = f1719 as dynamic;
+ l1719 = f1719 as dynamic;
+ x1719 = confuse(f1719);
+ l1719 = confuse(f1719);
+ }
+
+ Expect.isTrue(m1719 is F1719);
+ Expect.isTrue(m1719 is Function([List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1719) is F1719);
+ // In checked mode, verifies the type.
+ x1719 = m1719;
+ l1719 = m1719;
+ x1719 = confuse(m1719);
+ l1719 = confuse(m1719);
+ if (!tIsBool) {
+ Expect.isTrue(f1719 is F1719<int>);
+ Expect.isFalse(f1719 is F1719<bool>);
+ Expect.isTrue(confuse(f1719) is F1719<int>);
+ Expect.isFalse(confuse(f1719) is F1719<bool>);
+ Expect.equals(tIsDynamic, m1719 is F1719<bool>);
+ Expect.equals(tIsDynamic, confuse(m1719) is F1719<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1719 = (f1719 as dynamic); });
+ Expect.throws(() { x1719 = confuse(f1719); });
+ Function([List<T> x1]) Function<B extends core.int>(int x) l1719;
+ Expect.throws(() { l1719 = (f1719 as dynamic); });
+ Expect.throws(() { l1719 = confuse(f1719); });
+ }
+ Function([List<T> x1]) Function<B extends core.int>(int x) l1719 = m1719;
+ // In checked mode, verifies the type.
+ x1719 = m1719;
+ x1719 = confuse(m1719);
+ }
+ }
+
+ void testF1819() {
+ // List<Function> Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1819 is F1819);
+ Expect.isTrue(confuse(f1819) is F1819);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<Function> x) Function<B extends core.int>(int x) l1819;
+ // The static function f1819 sets `T` to `int`.
+ if (!tIsBool) {
+ x1819 = f1819 as dynamic;
+ l1819 = f1819 as dynamic;
+ x1819 = confuse(f1819);
+ l1819 = confuse(f1819);
+ }
+
+ Expect.isTrue(m1819 is F1819);
+ Expect.isTrue(m1819 is List<Function> Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1819) is F1819);
+ // In checked mode, verifies the type.
+ x1819 = m1819;
+ l1819 = m1819;
+ x1819 = confuse(m1819);
+ l1819 = confuse(m1819);
+
+ }
+
+ void testF1919() {
+ // Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1919 is F1919);
+ Expect.isTrue(confuse(f1919) is F1919);
+ // In checked mode, verifies the type.
+ Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1919;
+ // The static function f1919 sets `T` to `int`.
+ if (!tIsBool) {
+ x1919 = f1919 as dynamic;
+ l1919 = f1919 as dynamic;
+ x1919 = confuse(f1919);
+ l1919 = confuse(f1919);
+ }
+
+ Expect.isTrue(m1919 is F1919);
+ Expect.isTrue(m1919 is Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1919) is F1919);
+ // In checked mode, verifies the type.
+ x1919 = m1919;
+ l1919 = m1919;
+ x1919 = confuse(m1919);
+ l1919 = confuse(m1919);
+
+ }
+
+ void testF2019() {
+ // B Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2019 is F2019);
+ Expect.isTrue(confuse(f2019) is F2019);
+ // In checked mode, verifies the type.
+ B Function(Function x) Function<B extends core.int>(int x) l2019;
+ // The static function f2019 sets `T` to `int`.
+ if (!tIsBool) {
+ x2019 = f2019 as dynamic;
+ l2019 = f2019 as dynamic;
+ x2019 = confuse(f2019);
+ l2019 = confuse(f2019);
+ }
+
+ Expect.isTrue(m2019 is F2019);
+ Expect.isTrue(m2019 is B Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2019) is F2019);
+ // In checked mode, verifies the type.
+ x2019 = m2019;
+ l2019 = m2019;
+ x2019 = confuse(m2019);
+ l2019 = confuse(m2019);
+
+ }
+
+
+}
+
+class C20<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, {Function x}) x20;
+ List<Function> Function({int x}) x120;
+ core.List<core.int> Function({List<T> x}) x220;
+ Function(int x, [core.List<core.int> x2]) x320;
+ int Function([int x1]) Function() x420;
+ int Function({List<Function> x}) Function() x520;
+ int Function() Function() x620;
+ Function Function(int x0, [List<Function> x]) Function() x720;
+ Function Function([List<T> x1]) Function() x820;
+ List<Function> Function(int x, [Function x2]) Function() x920;
+ List<Function> Function(int y, {core.List<core.int> x}) Function() x1020;
+ core.List<core.int> Function([Function x]) Function() x1120;
+ core.List<core.int> Function(core.List<core.int> x0) Function() x1220;
+ List<T> Function(int x1, [int x2]) Function() x1320;
+ List<T> Function(int x0, {List<Function> x}) Function() x1420;
+ Function(int x) Function() x1520;
+ Function(int y, [List<Function> x]) Function() x1620;
+ Function(int x1, [List<T> x2]) Function() x1720;
+ List<Function> Function<A>(core.List<core.int> x) Function() x1820;
+ Function<A>(List<T> x) Function() x1920;
+ B Function(List<Function> x) Function<B extends core.int>() x2020;
+
+
+ C20({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m20(int x0, {Function x}) => null;
+ List<Function> m120({int x}) => null;
+ core.List<core.int> m220({List<T> x}) => null;
+ m320(int x, [core.List<core.int> x0]) => null;
+ int Function([int x0]) m420() => null;
+ int Function({List<Function> x}) m520() => null;
+ int Function() m620() => null;
+ Function Function(int x0, [List<Function> x]) m720() => null;
+ Function Function([List<T> x0]) m820() => null;
+ List<Function> Function(int x, [Function x0]) m920() => null;
+ List<Function> Function(int y, {core.List<core.int> x}) m1020() => null;
+ core.List<core.int> Function([Function x]) m1120() => null;
+ core.List<core.int> Function(core.List<core.int> x0) m1220() => null;
+ List<T> Function(int x0, [int x1]) m1320() => null;
+ List<T> Function(int x0, {List<Function> x}) m1420() => null;
+ Function(int x) m1520() => null;
+ Function(int y, [List<Function> x]) m1620() => null;
+ Function(int x0, [List<T> x1]) m1720() => null;
+ List<Function> Function<A>(core.List<core.int> x) m1820() => null;
+ Function<A>(List<T> x) m1920() => null;
+ B Function(List<Function> x) m2020<B extends core.int>() => null;
+
+
+ runTests() {
+ testF20();
+ testF120();
+ testF220();
+ testF320();
+ testF420();
+ testF520();
+ testF620();
+ testF720();
+ testF820();
+ testF920();
+ testF1020();
+ testF1120();
+ testF1220();
+ testF1320();
+ testF1420();
+ testF1520();
+ testF1620();
+ testF1720();
+ testF1820();
+ testF1920();
+ testF2020();
+ }
+
+ void testF20() {
+ // int Function(int x0, {Function x})
+ Expect.isTrue(f20 is F20);
+ Expect.isTrue(confuse(f20) is F20);
+ // In checked mode, verifies the type.
+ int Function(int x0, {Function x}) l20;
+ // The static function f20 sets `T` to `int`.
+ if (!tIsBool) {
+ 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(int x0, {Function x}));
+ Expect.isTrue(confuse(m20) is F20);
+ // In checked mode, verifies the type.
+ x20 = m20;
+ l20 = m20;
+ x20 = confuse(m20);
+ l20 = confuse(m20);
+
+ }
+
+ void testF120() {
+ // List<Function> Function({int x})
+ Expect.isTrue(f120 is F120);
+ Expect.isTrue(confuse(f120) is F120);
+ // In checked mode, verifies the type.
+ List<Function> Function({int x}) l120;
+ // The static function f120 sets `T` to `int`.
+ if (!tIsBool) {
+ x120 = f120 as dynamic;
+ l120 = f120 as dynamic;
+ x120 = confuse(f120);
+ l120 = confuse(f120);
+ }
+
+ Expect.isTrue(m120 is F120);
+ Expect.isTrue(m120 is List<Function> Function({int x}));
+ Expect.isTrue(confuse(m120) is F120);
+ // In checked mode, verifies the type.
+ x120 = m120;
+ l120 = m120;
+ x120 = confuse(m120);
+ l120 = confuse(m120);
+
+ }
+
+ void testF220() {
+ // core.List<core.int> Function({List<T> x})
+ Expect.isTrue(f220 is F220);
+ Expect.isTrue(confuse(f220) is F220);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<T> x}) l220;
+ // The static function f220 sets `T` to `int`.
+ if (!tIsBool) {
+ x220 = f220 as dynamic;
+ l220 = f220 as dynamic;
+ x220 = confuse(f220);
+ l220 = confuse(f220);
+ }
+
+ Expect.isTrue(m220 is F220);
+ Expect.isTrue(m220 is core.List<core.int> Function({List<T> x}));
+ Expect.isTrue(confuse(m220) is F220);
+ // In checked mode, verifies the type.
+ x220 = m220;
+ l220 = m220;
+ x220 = confuse(m220);
+ l220 = confuse(m220);
+ if (!tIsBool) {
+ Expect.isTrue(f220 is F220<int>);
+ Expect.isFalse(f220 is F220<bool>);
+ Expect.isTrue(confuse(f220) is F220<int>);
+ Expect.isFalse(confuse(f220) is F220<bool>);
+ Expect.equals(tIsDynamic, m220 is F220<bool>);
+ Expect.equals(tIsDynamic, confuse(m220) is F220<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x220 = (f220 as dynamic); });
+ Expect.throws(() { x220 = confuse(f220); });
+ core.List<core.int> Function({List<T> x}) l220;
+ Expect.throws(() { l220 = (f220 as dynamic); });
+ Expect.throws(() { l220 = confuse(f220); });
+ }
+ core.List<core.int> Function({List<T> x}) l220 = m220;
+ // In checked mode, verifies the type.
+ x220 = m220;
+ x220 = confuse(m220);
+ }
+ }
+
+ void testF320() {
+ // Function(int x, [core.List<core.int> x2])
+ Expect.isTrue(f320 is F320);
+ Expect.isTrue(confuse(f320) is F320);
+ // In checked mode, verifies the type.
+ Function(int x, [core.List<core.int> x2]) l320;
+ // The static function f320 sets `T` to `int`.
+ if (!tIsBool) {
+ x320 = f320 as dynamic;
+ l320 = f320 as dynamic;
+ x320 = confuse(f320);
+ l320 = confuse(f320);
+ }
+
+ Expect.isTrue(m320 is F320);
+ Expect.isTrue(m320 is Function(int x, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m320) is F320);
+ // In checked mode, verifies the type.
+ x320 = m320;
+ l320 = m320;
+ x320 = confuse(m320);
+ l320 = confuse(m320);
+
+ }
+
+ void testF420() {
+ // int Function([int x1]) Function()
+ Expect.isTrue(f420 is F420);
+ Expect.isTrue(confuse(f420) is F420);
+ // In checked mode, verifies the type.
+ int Function([int x1]) Function() l420;
+ // The static function f420 sets `T` to `int`.
+ if (!tIsBool) {
+ x420 = f420 as dynamic;
+ l420 = f420 as dynamic;
+ x420 = confuse(f420);
+ l420 = confuse(f420);
+ }
+
+ Expect.isTrue(m420 is F420);
+ Expect.isTrue(m420 is int Function([int x1]) Function());
+ Expect.isTrue(confuse(m420) is F420);
+ // In checked mode, verifies the type.
+ x420 = m420;
+ l420 = m420;
+ x420 = confuse(m420);
+ l420 = confuse(m420);
+
+ }
+
+ void testF520() {
+ // int Function({List<Function> x}) Function()
+ Expect.isTrue(f520 is F520);
+ Expect.isTrue(confuse(f520) is F520);
+ // In checked mode, verifies the type.
+ int Function({List<Function> x}) Function() l520;
+ // The static function f520 sets `T` to `int`.
+ if (!tIsBool) {
+ x520 = f520 as dynamic;
+ l520 = f520 as dynamic;
+ x520 = confuse(f520);
+ l520 = confuse(f520);
+ }
+
+ Expect.isTrue(m520 is F520);
+ Expect.isTrue(m520 is int Function({List<Function> x}) Function());
+ Expect.isTrue(confuse(m520) is F520);
+ // In checked mode, verifies the type.
+ x520 = m520;
+ l520 = m520;
+ x520 = confuse(m520);
+ l520 = confuse(m520);
+
+ }
+
+ void testF620() {
+ // int Function() Function()
+ Expect.isTrue(f620 is F620);
+ Expect.isTrue(confuse(f620) is F620);
+ // In checked mode, verifies the type.
+ int Function() Function() l620;
+ // The static function f620 sets `T` to `int`.
+ if (!tIsBool) {
+ x620 = f620 as dynamic;
+ l620 = f620 as dynamic;
+ x620 = confuse(f620);
+ l620 = confuse(f620);
+ }
+
+ Expect.isTrue(m620 is F620);
+ Expect.isTrue(m620 is int Function() Function());
+ Expect.isTrue(confuse(m620) is F620);
+ // In checked mode, verifies the type.
+ x620 = m620;
+ l620 = m620;
+ x620 = confuse(m620);
+ l620 = confuse(m620);
+
+ }
+
+ void testF720() {
+ // Function Function(int x0, [List<Function> x]) Function()
+ Expect.isTrue(f720 is F720);
+ Expect.isTrue(confuse(f720) is F720);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [List<Function> x]) Function() l720;
+ // The static function f720 sets `T` to `int`.
+ if (!tIsBool) {
+ x720 = f720 as dynamic;
+ l720 = f720 as dynamic;
+ x720 = confuse(f720);
+ l720 = confuse(f720);
+ }
+
+ Expect.isTrue(m720 is F720);
+ Expect.isTrue(m720 is Function Function(int x0, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m720) is F720);
+ // In checked mode, verifies the type.
+ x720 = m720;
+ l720 = m720;
+ x720 = confuse(m720);
+ l720 = confuse(m720);
+
+ }
+
+ void testF820() {
+ // Function Function([List<T> x1]) Function()
+ Expect.isTrue(f820 is F820);
+ Expect.isTrue(confuse(f820) is F820);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x1]) Function() l820;
+ // The static function f820 sets `T` to `int`.
+ if (!tIsBool) {
+ x820 = f820 as dynamic;
+ l820 = f820 as dynamic;
+ x820 = confuse(f820);
+ l820 = confuse(f820);
+ }
+
+ Expect.isTrue(m820 is F820);
+ Expect.isTrue(m820 is Function Function([List<T> x1]) Function());
+ Expect.isTrue(confuse(m820) is F820);
+ // In checked mode, verifies the type.
+ x820 = m820;
+ l820 = m820;
+ x820 = confuse(m820);
+ l820 = confuse(m820);
+ if (!tIsBool) {
+ Expect.isTrue(f820 is F820<int>);
+ Expect.isFalse(f820 is F820<bool>);
+ Expect.isTrue(confuse(f820) is F820<int>);
+ Expect.isFalse(confuse(f820) is F820<bool>);
+ Expect.equals(tIsDynamic, m820 is F820<bool>);
+ Expect.equals(tIsDynamic, confuse(m820) is F820<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x820 = (f820 as dynamic); });
+ Expect.throws(() { x820 = confuse(f820); });
+ Function Function([List<T> x1]) Function() l820;
+ Expect.throws(() { l820 = (f820 as dynamic); });
+ Expect.throws(() { l820 = confuse(f820); });
+ }
+ Function Function([List<T> x1]) Function() l820 = m820;
+ // In checked mode, verifies the type.
+ x820 = m820;
+ x820 = confuse(m820);
+ }
+ }
+
+ void testF920() {
+ // List<Function> Function(int x, [Function x2]) Function()
+ Expect.isTrue(f920 is F920);
+ Expect.isTrue(confuse(f920) is F920);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [Function x2]) Function() l920;
+ // The static function f920 sets `T` to `int`.
+ if (!tIsBool) {
+ x920 = f920 as dynamic;
+ l920 = f920 as dynamic;
+ x920 = confuse(f920);
+ l920 = confuse(f920);
+ }
+
+ Expect.isTrue(m920 is F920);
+ Expect.isTrue(m920 is List<Function> Function(int x, [Function x2]) Function());
+ Expect.isTrue(confuse(m920) is F920);
+ // In checked mode, verifies the type.
+ x920 = m920;
+ l920 = m920;
+ x920 = confuse(m920);
+ l920 = confuse(m920);
+
+ }
+
+ void testF1020() {
+ // List<Function> Function(int y, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1020 is F1020);
+ Expect.isTrue(confuse(f1020) is F1020);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {core.List<core.int> x}) Function() l1020;
+ // The static function f1020 sets `T` to `int`.
+ if (!tIsBool) {
+ x1020 = f1020 as dynamic;
+ l1020 = f1020 as dynamic;
+ x1020 = confuse(f1020);
+ l1020 = confuse(f1020);
+ }
+
+ Expect.isTrue(m1020 is F1020);
+ Expect.isTrue(m1020 is List<Function> Function(int y, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1020) is F1020);
+ // In checked mode, verifies the type.
+ x1020 = m1020;
+ l1020 = m1020;
+ x1020 = confuse(m1020);
+ l1020 = confuse(m1020);
+
+ }
+
+ void testF1120() {
+ // core.List<core.int> Function([Function x]) Function()
+ Expect.isTrue(f1120 is F1120);
+ Expect.isTrue(confuse(f1120) is F1120);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x]) Function() l1120;
+ // The static function f1120 sets `T` to `int`.
+ if (!tIsBool) {
+ x1120 = f1120 as dynamic;
+ l1120 = f1120 as dynamic;
+ x1120 = confuse(f1120);
+ l1120 = confuse(f1120);
+ }
+
+ Expect.isTrue(m1120 is F1120);
+ Expect.isTrue(m1120 is core.List<core.int> Function([Function x]) Function());
+ Expect.isTrue(confuse(m1120) is F1120);
+ // In checked mode, verifies the type.
+ x1120 = m1120;
+ l1120 = m1120;
+ x1120 = confuse(m1120);
+ l1120 = confuse(m1120);
+
+ }
+
+ void testF1220() {
+ // core.List<core.int> Function(core.List<core.int> x0) Function()
+ Expect.isTrue(f1220 is F1220);
+ Expect.isTrue(confuse(f1220) is F1220);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x0) Function() l1220;
+ // The static function f1220 sets `T` to `int`.
+ if (!tIsBool) {
+ x1220 = f1220 as dynamic;
+ l1220 = f1220 as dynamic;
+ x1220 = confuse(f1220);
+ l1220 = confuse(f1220);
+ }
+
+ Expect.isTrue(m1220 is F1220);
+ Expect.isTrue(m1220 is core.List<core.int> Function(core.List<core.int> x0) Function());
+ Expect.isTrue(confuse(m1220) is F1220);
+ // In checked mode, verifies the type.
+ x1220 = m1220;
+ l1220 = m1220;
+ x1220 = confuse(m1220);
+ l1220 = confuse(m1220);
+
+ }
+
+ void testF1320() {
+ // List<T> Function(int x1, [int x2]) Function()
+ Expect.isTrue(f1320 is F1320);
+ Expect.isTrue(confuse(f1320) is F1320);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [int x2]) Function() l1320;
+ // The static function f1320 sets `T` to `int`.
+ if (!tIsBool) {
+ x1320 = f1320 as dynamic;
+ l1320 = f1320 as dynamic;
+ x1320 = confuse(f1320);
+ l1320 = confuse(f1320);
+ }
+
+ Expect.isTrue(m1320 is F1320);
+ Expect.isTrue(m1320 is List<T> Function(int x1, [int x2]) Function());
+ Expect.isTrue(confuse(m1320) is F1320);
+ // In checked mode, verifies the type.
+ x1320 = m1320;
+ l1320 = m1320;
+ x1320 = confuse(m1320);
+ l1320 = confuse(m1320);
+ if (!tIsBool) {
+ Expect.isTrue(f1320 is F1320<int>);
+ Expect.isFalse(f1320 is F1320<bool>);
+ Expect.isTrue(confuse(f1320) is F1320<int>);
+ Expect.isFalse(confuse(f1320) is F1320<bool>);
+ Expect.equals(tIsDynamic, m1320 is F1320<bool>);
+ Expect.equals(tIsDynamic, confuse(m1320) is F1320<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1320 = (f1320 as dynamic); });
+ Expect.throws(() { x1320 = confuse(f1320); });
+ List<T> Function(int x1, [int x2]) Function() l1320;
+ Expect.throws(() { l1320 = (f1320 as dynamic); });
+ Expect.throws(() { l1320 = confuse(f1320); });
+ }
+ List<T> Function(int x1, [int x2]) Function() l1320 = m1320;
+ // In checked mode, verifies the type.
+ x1320 = m1320;
+ x1320 = confuse(m1320);
+ }
+ }
+
+ void testF1420() {
+ // List<T> Function(int x0, {List<Function> x}) Function()
+ Expect.isTrue(f1420 is F1420);
+ Expect.isTrue(confuse(f1420) is F1420);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {List<Function> x}) Function() l1420;
+ // The static function f1420 sets `T` to `int`.
+ if (!tIsBool) {
+ x1420 = f1420 as dynamic;
+ l1420 = f1420 as dynamic;
+ x1420 = confuse(f1420);
+ l1420 = confuse(f1420);
+ }
+
+ Expect.isTrue(m1420 is F1420);
+ Expect.isTrue(m1420 is List<T> Function(int x0, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m1420) is F1420);
+ // In checked mode, verifies the type.
+ x1420 = m1420;
+ l1420 = m1420;
+ x1420 = confuse(m1420);
+ l1420 = confuse(m1420);
+ if (!tIsBool) {
+ Expect.isTrue(f1420 is F1420<int>);
+ Expect.isFalse(f1420 is F1420<bool>);
+ Expect.isTrue(confuse(f1420) is F1420<int>);
+ Expect.isFalse(confuse(f1420) is F1420<bool>);
+ Expect.equals(tIsDynamic, m1420 is F1420<bool>);
+ Expect.equals(tIsDynamic, confuse(m1420) is F1420<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1420 = (f1420 as dynamic); });
+ Expect.throws(() { x1420 = confuse(f1420); });
+ List<T> Function(int x0, {List<Function> x}) Function() l1420;
+ Expect.throws(() { l1420 = (f1420 as dynamic); });
+ Expect.throws(() { l1420 = confuse(f1420); });
+ }
+ List<T> Function(int x0, {List<Function> x}) Function() l1420 = m1420;
+ // In checked mode, verifies the type.
+ x1420 = m1420;
+ x1420 = confuse(m1420);
+ }
+ }
+
+ void testF1520() {
+ // Function(int x) Function()
+ Expect.isTrue(f1520 is F1520);
+ Expect.isTrue(confuse(f1520) is F1520);
+ // In checked mode, verifies the type.
+ Function(int x) Function() l1520;
+ // The static function f1520 sets `T` to `int`.
+ if (!tIsBool) {
+ x1520 = f1520 as dynamic;
+ l1520 = f1520 as dynamic;
+ x1520 = confuse(f1520);
+ l1520 = confuse(f1520);
+ }
+
+ Expect.isTrue(m1520 is F1520);
+ Expect.isTrue(m1520 is Function(int x) Function());
+ Expect.isTrue(confuse(m1520) is F1520);
+ // In checked mode, verifies the type.
+ x1520 = m1520;
+ l1520 = m1520;
+ x1520 = confuse(m1520);
+ l1520 = confuse(m1520);
+
+ }
+
+ void testF1620() {
+ // Function(int y, [List<Function> x]) Function()
+ Expect.isTrue(f1620 is F1620);
+ Expect.isTrue(confuse(f1620) is F1620);
+ // In checked mode, verifies the type.
+ Function(int y, [List<Function> x]) Function() l1620;
+ // The static function f1620 sets `T` to `int`.
+ if (!tIsBool) {
+ x1620 = f1620 as dynamic;
+ l1620 = f1620 as dynamic;
+ x1620 = confuse(f1620);
+ l1620 = confuse(f1620);
+ }
+
+ Expect.isTrue(m1620 is F1620);
+ Expect.isTrue(m1620 is Function(int y, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m1620) is F1620);
+ // In checked mode, verifies the type.
+ x1620 = m1620;
+ l1620 = m1620;
+ x1620 = confuse(m1620);
+ l1620 = confuse(m1620);
+
+ }
+
+ void testF1720() {
+ // Function(int x1, [List<T> x2]) Function()
+ Expect.isTrue(f1720 is F1720);
+ Expect.isTrue(confuse(f1720) is F1720);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<T> x2]) Function() l1720;
+ // The static function f1720 sets `T` to `int`.
+ if (!tIsBool) {
+ x1720 = f1720 as dynamic;
+ l1720 = f1720 as dynamic;
+ x1720 = confuse(f1720);
+ l1720 = confuse(f1720);
+ }
+
+ Expect.isTrue(m1720 is F1720);
+ Expect.isTrue(m1720 is Function(int x1, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1720) is F1720);
+ // In checked mode, verifies the type.
+ x1720 = m1720;
+ l1720 = m1720;
+ x1720 = confuse(m1720);
+ l1720 = confuse(m1720);
+ if (!tIsBool) {
+ Expect.isTrue(f1720 is F1720<int>);
+ Expect.isFalse(f1720 is F1720<bool>);
+ Expect.isTrue(confuse(f1720) is F1720<int>);
+ Expect.isFalse(confuse(f1720) is F1720<bool>);
+ Expect.equals(tIsDynamic, m1720 is F1720<bool>);
+ Expect.equals(tIsDynamic, confuse(m1720) is F1720<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1720 = (f1720 as dynamic); });
+ Expect.throws(() { x1720 = confuse(f1720); });
+ Function(int x1, [List<T> x2]) Function() l1720;
+ Expect.throws(() { l1720 = (f1720 as dynamic); });
+ Expect.throws(() { l1720 = confuse(f1720); });
+ }
+ Function(int x1, [List<T> x2]) Function() l1720 = m1720;
+ // In checked mode, verifies the type.
+ x1720 = m1720;
+ x1720 = confuse(m1720);
+ }
+ }
+
+ void testF1820() {
+ // List<Function> Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1820 is F1820);
+ Expect.isTrue(confuse(f1820) is F1820);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(core.List<core.int> x) Function() l1820;
+ // The static function f1820 sets `T` to `int`.
+ if (!tIsBool) {
+ x1820 = f1820 as dynamic;
+ l1820 = f1820 as dynamic;
+ x1820 = confuse(f1820);
+ l1820 = confuse(f1820);
+ }
+
+ Expect.isTrue(m1820 is F1820);
+ Expect.isTrue(m1820 is List<Function> Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1820) is F1820);
+ // In checked mode, verifies the type.
+ x1820 = m1820;
+ l1820 = m1820;
+ x1820 = confuse(m1820);
+ l1820 = confuse(m1820);
+
+ }
+
+ void testF1920() {
+ // Function<A>(List<T> x) Function()
+ Expect.isTrue(f1920 is F1920);
+ Expect.isTrue(confuse(f1920) is F1920);
+ // In checked mode, verifies the type.
+ Function<A>(List<T> x) Function() l1920;
+ // The static function f1920 sets `T` to `int`.
+ if (!tIsBool) {
+ x1920 = f1920 as dynamic;
+ l1920 = f1920 as dynamic;
+ x1920 = confuse(f1920);
+ l1920 = confuse(f1920);
+ }
+
+ Expect.isTrue(m1920 is F1920);
+ Expect.isTrue(m1920 is Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1920) is F1920);
+ // In checked mode, verifies the type.
+ x1920 = m1920;
+ l1920 = m1920;
+ x1920 = confuse(m1920);
+ l1920 = confuse(m1920);
+ if (!tIsBool) {
+ Expect.isTrue(f1920 is F1920<int>);
+ Expect.isFalse(f1920 is F1920<bool>);
+ Expect.isTrue(confuse(f1920) is F1920<int>);
+ Expect.isFalse(confuse(f1920) is F1920<bool>);
+ Expect.equals(tIsDynamic, m1920 is F1920<bool>);
+ Expect.equals(tIsDynamic, confuse(m1920) is F1920<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1920 = (f1920 as dynamic); });
+ Expect.throws(() { x1920 = confuse(f1920); });
+ Function<A>(List<T> x) Function() l1920;
+ Expect.throws(() { l1920 = (f1920 as dynamic); });
+ Expect.throws(() { l1920 = confuse(f1920); });
+ }
+ Function<A>(List<T> x) Function() l1920 = m1920;
+ // In checked mode, verifies the type.
+ x1920 = m1920;
+ x1920 = confuse(m1920);
+ }
+ }
+
+ void testF2020() {
+ // B Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f2020 is F2020);
+ Expect.isTrue(confuse(f2020) is F2020);
+ // In checked mode, verifies the type.
+ B Function(List<Function> x) Function<B extends core.int>() l2020;
+ // The static function f2020 sets `T` to `int`.
+ if (!tIsBool) {
+ x2020 = f2020 as dynamic;
+ l2020 = f2020 as dynamic;
+ x2020 = confuse(f2020);
+ l2020 = confuse(f2020);
+ }
+
+ Expect.isTrue(m2020 is F2020);
+ Expect.isTrue(m2020 is B Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2020) is F2020);
+ // In checked mode, verifies the type.
+ x2020 = m2020;
+ l2020 = m2020;
+ x2020 = confuse(m2020);
+ l2020 = confuse(m2020);
+
+ }
+
+
+}
+
+class C21<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, {Function x}) x21;
+ List<Function> Function(int x0, {int x}) x121;
+ core.List<core.int> Function(int x0, {List<T> x}) x221;
+ Function({core.List<core.int> x}) x321;
+ int Function([int x1]) Function(int x) x421;
+ int Function({List<Function> x}) Function(int x) x521;
+ int Function() Function(int x) x621;
+ Function Function(int x1, [List<Function> x]) Function(int x) x721;
+ Function Function([List<T> x1]) Function(int x) x821;
+ List<Function> Function(int x, [Function x1]) Function(int x) x921;
+ List<Function> Function(int y, {core.List<core.int> x}) Function(int x) x1021;
+ core.List<core.int> Function([Function x]) Function(int x) x1121;
+ core.List<core.int> Function(core.List<core.int> x1) Function(int x) x1221;
+ List<T> Function(int x2, [int x3]) Function(int x) x1321;
+ List<T> Function(int x1, {List<Function> x}) Function(int x) x1421;
+ Function(int x) Function(int x) x1521;
+ Function(int y, [List<Function> x]) Function(int x) x1621;
+ Function(int x2, [List<T> x3]) Function(int x) x1721;
+ List<Function> Function<A>(core.List<core.int> x) Function(int x) x1821;
+ Function<A>(List<T> x) Function(int x) x1921;
+ B Function(List<Function> x) Function<B extends core.int>(int x) x2021;
+
+
+ C21({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m21(int y, {Function x}) => null;
+ List<Function> m121(int x0, {int x}) => null;
+ core.List<core.int> m221(int x0, {List<T> x}) => null;
+ m321({core.List<core.int> x}) => null;
+ int Function([int x0]) m421(int x) => null;
+ int Function({List<Function> x}) m521(int x) => null;
+ int Function() m621(int x) => null;
+ Function Function(int x0, [List<Function> x]) m721(int x) => null;
+ Function Function([List<T> x0]) m821(int x) => null;
+ List<Function> Function(int x, [Function x0]) m921(int x) => null;
+ List<Function> Function(int y, {core.List<core.int> x}) m1021(int x) => null;
+ core.List<core.int> Function([Function x]) m1121(int x) => null;
+ core.List<core.int> Function(core.List<core.int> x0) m1221(int x) => null;
+ List<T> Function(int x0, [int x1]) m1321(int x) => null;
+ List<T> Function(int x0, {List<Function> x}) m1421(int x) => null;
+ Function(int x) m1521(int x) => null;
+ Function(int y, [List<Function> x]) m1621(int x) => null;
+ Function(int x0, [List<T> x1]) m1721(int x) => null;
+ List<Function> Function<A>(core.List<core.int> x) m1821(int x) => null;
+ Function<A>(List<T> x) m1921(int x) => null;
+ B Function(List<Function> x) m2021<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF21();
+ testF121();
+ testF221();
+ testF321();
+ testF421();
+ testF521();
+ testF621();
+ testF721();
+ testF821();
+ testF921();
+ testF1021();
+ testF1121();
+ testF1221();
+ testF1321();
+ testF1421();
+ testF1521();
+ testF1621();
+ testF1721();
+ testF1821();
+ testF1921();
+ testF2021();
+ }
+
+ void testF21() {
+ // int Function(int y, {Function x})
+ Expect.isTrue(f21 is F21);
+ Expect.isTrue(confuse(f21) is F21);
+ // In checked mode, verifies the type.
+ int Function(int y, {Function x}) l21;
+ // The static function f21 sets `T` to `int`.
+ if (!tIsBool) {
+ x21 = f21 as dynamic;
+ l21 = f21 as dynamic;
+ x21 = confuse(f21);
+ l21 = confuse(f21);
+ }
+
+ Expect.isTrue(m21 is F21);
+ Expect.isTrue(m21 is int Function(int y, {Function x}));
+ Expect.isTrue(confuse(m21) is F21);
+ // In checked mode, verifies the type.
+ x21 = m21;
+ l21 = m21;
+ x21 = confuse(m21);
+ l21 = confuse(m21);
+
+ }
+
+ void testF121() {
+ // List<Function> Function(int x0, {int x})
+ Expect.isTrue(f121 is F121);
+ Expect.isTrue(confuse(f121) is F121);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {int x}) l121;
+ // The static function f121 sets `T` to `int`.
+ if (!tIsBool) {
+ x121 = f121 as dynamic;
+ l121 = f121 as dynamic;
+ x121 = confuse(f121);
+ l121 = confuse(f121);
+ }
+
+ Expect.isTrue(m121 is F121);
+ Expect.isTrue(m121 is List<Function> Function(int x0, {int x}));
+ Expect.isTrue(confuse(m121) is F121);
+ // In checked mode, verifies the type.
+ x121 = m121;
+ l121 = m121;
+ x121 = confuse(m121);
+ l121 = confuse(m121);
+
+ }
+
+ void testF221() {
+ // core.List<core.int> Function(int x0, {List<T> x})
+ Expect.isTrue(f221 is F221);
+ Expect.isTrue(confuse(f221) is F221);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {List<T> x}) l221;
+ // The static function f221 sets `T` to `int`.
+ if (!tIsBool) {
+ x221 = f221 as dynamic;
+ l221 = f221 as dynamic;
+ x221 = confuse(f221);
+ l221 = confuse(f221);
+ }
+
+ Expect.isTrue(m221 is F221);
+ Expect.isTrue(m221 is core.List<core.int> Function(int x0, {List<T> x}));
+ Expect.isTrue(confuse(m221) is F221);
+ // In checked mode, verifies the type.
+ x221 = m221;
+ l221 = m221;
+ x221 = confuse(m221);
+ l221 = confuse(m221);
+ if (!tIsBool) {
+ Expect.isTrue(f221 is F221<int>);
+ Expect.isFalse(f221 is F221<bool>);
+ Expect.isTrue(confuse(f221) is F221<int>);
+ Expect.isFalse(confuse(f221) is F221<bool>);
+ Expect.equals(tIsDynamic, m221 is F221<bool>);
+ Expect.equals(tIsDynamic, confuse(m221) is F221<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x221 = (f221 as dynamic); });
+ Expect.throws(() { x221 = confuse(f221); });
+ core.List<core.int> Function(int x0, {List<T> x}) l221;
+ Expect.throws(() { l221 = (f221 as dynamic); });
+ Expect.throws(() { l221 = confuse(f221); });
+ }
+ core.List<core.int> Function(int x0, {List<T> x}) l221 = m221;
+ // In checked mode, verifies the type.
+ x221 = m221;
+ x221 = confuse(m221);
+ }
+ }
+
+ void testF321() {
+ // Function({core.List<core.int> x})
+ Expect.isTrue(f321 is F321);
+ Expect.isTrue(confuse(f321) is F321);
+ // In checked mode, verifies the type.
+ Function({core.List<core.int> x}) l321;
+ // The static function f321 sets `T` to `int`.
+ if (!tIsBool) {
+ x321 = f321 as dynamic;
+ l321 = f321 as dynamic;
+ x321 = confuse(f321);
+ l321 = confuse(f321);
+ }
+
+ Expect.isTrue(m321 is F321);
+ Expect.isTrue(m321 is Function({core.List<core.int> x}));
+ Expect.isTrue(confuse(m321) is F321);
+ // In checked mode, verifies the type.
+ x321 = m321;
+ l321 = m321;
+ x321 = confuse(m321);
+ l321 = confuse(m321);
+
+ }
+
+ void testF421() {
+ // int Function([int x1]) Function(int x)
+ Expect.isTrue(f421 is F421);
+ Expect.isTrue(confuse(f421) is F421);
+ // In checked mode, verifies the type.
+ int Function([int x1]) Function(int x) l421;
+ // The static function f421 sets `T` to `int`.
+ if (!tIsBool) {
+ x421 = f421 as dynamic;
+ l421 = f421 as dynamic;
+ x421 = confuse(f421);
+ l421 = confuse(f421);
+ }
+
+ Expect.isTrue(m421 is F421);
+ Expect.isTrue(m421 is int Function([int x1]) Function(int x));
+ Expect.isTrue(confuse(m421) is F421);
+ // In checked mode, verifies the type.
+ x421 = m421;
+ l421 = m421;
+ x421 = confuse(m421);
+ l421 = confuse(m421);
+
+ }
+
+ void testF521() {
+ // int Function({List<Function> x}) Function(int x)
+ Expect.isTrue(f521 is F521);
+ Expect.isTrue(confuse(f521) is F521);
+ // In checked mode, verifies the type.
+ int Function({List<Function> x}) Function(int x) l521;
+ // The static function f521 sets `T` to `int`.
+ if (!tIsBool) {
+ x521 = f521 as dynamic;
+ l521 = f521 as dynamic;
+ x521 = confuse(f521);
+ l521 = confuse(f521);
+ }
+
+ Expect.isTrue(m521 is F521);
+ Expect.isTrue(m521 is int Function({List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m521) is F521);
+ // In checked mode, verifies the type.
+ x521 = m521;
+ l521 = m521;
+ x521 = confuse(m521);
+ l521 = confuse(m521);
+
+ }
+
+ void testF621() {
+ // int Function() Function(int x)
+ Expect.isTrue(f621 is F621);
+ Expect.isTrue(confuse(f621) is F621);
+ // In checked mode, verifies the type.
+ int Function() Function(int x) l621;
+ // The static function f621 sets `T` to `int`.
+ if (!tIsBool) {
+ x621 = f621 as dynamic;
+ l621 = f621 as dynamic;
+ x621 = confuse(f621);
+ l621 = confuse(f621);
+ }
+
+ Expect.isTrue(m621 is F621);
+ Expect.isTrue(m621 is int Function() Function(int x));
+ Expect.isTrue(confuse(m621) is F621);
+ // In checked mode, verifies the type.
+ x621 = m621;
+ l621 = m621;
+ x621 = confuse(m621);
+ l621 = confuse(m621);
+
+ }
+
+ void testF721() {
+ // Function Function(int x1, [List<Function> x]) Function(int x)
+ Expect.isTrue(f721 is F721);
+ Expect.isTrue(confuse(f721) is F721);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<Function> x]) Function(int x) l721;
+ // The static function f721 sets `T` to `int`.
+ if (!tIsBool) {
+ x721 = f721 as dynamic;
+ l721 = f721 as dynamic;
+ x721 = confuse(f721);
+ l721 = confuse(f721);
+ }
+
+ Expect.isTrue(m721 is F721);
+ Expect.isTrue(m721 is Function Function(int x1, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m721) is F721);
+ // In checked mode, verifies the type.
+ x721 = m721;
+ l721 = m721;
+ x721 = confuse(m721);
+ l721 = confuse(m721);
+
+ }
+
+ void testF821() {
+ // Function Function([List<T> x1]) Function(int x)
+ Expect.isTrue(f821 is F821);
+ Expect.isTrue(confuse(f821) is F821);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x1]) Function(int x) l821;
+ // The static function f821 sets `T` to `int`.
+ if (!tIsBool) {
+ x821 = f821 as dynamic;
+ l821 = f821 as dynamic;
+ x821 = confuse(f821);
+ l821 = confuse(f821);
+ }
+
+ Expect.isTrue(m821 is F821);
+ Expect.isTrue(m821 is Function Function([List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m821) is F821);
+ // In checked mode, verifies the type.
+ x821 = m821;
+ l821 = m821;
+ x821 = confuse(m821);
+ l821 = confuse(m821);
+ if (!tIsBool) {
+ Expect.isTrue(f821 is F821<int>);
+ Expect.isFalse(f821 is F821<bool>);
+ Expect.isTrue(confuse(f821) is F821<int>);
+ Expect.isFalse(confuse(f821) is F821<bool>);
+ Expect.equals(tIsDynamic, m821 is F821<bool>);
+ Expect.equals(tIsDynamic, confuse(m821) is F821<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x821 = (f821 as dynamic); });
+ Expect.throws(() { x821 = confuse(f821); });
+ Function Function([List<T> x1]) Function(int x) l821;
+ Expect.throws(() { l821 = (f821 as dynamic); });
+ Expect.throws(() { l821 = confuse(f821); });
+ }
+ Function Function([List<T> x1]) Function(int x) l821 = m821;
+ // In checked mode, verifies the type.
+ x821 = m821;
+ x821 = confuse(m821);
+ }
+ }
+
+ void testF921() {
+ // List<Function> Function(int x, [Function x1]) Function(int x)
+ Expect.isTrue(f921 is F921);
+ Expect.isTrue(confuse(f921) is F921);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [Function x1]) Function(int x) l921;
+ // The static function f921 sets `T` to `int`.
+ if (!tIsBool) {
+ x921 = f921 as dynamic;
+ l921 = f921 as dynamic;
+ x921 = confuse(f921);
+ l921 = confuse(f921);
+ }
+
+ Expect.isTrue(m921 is F921);
+ Expect.isTrue(m921 is List<Function> Function(int x, [Function x1]) Function(int x));
+ Expect.isTrue(confuse(m921) is F921);
+ // In checked mode, verifies the type.
+ x921 = m921;
+ l921 = m921;
+ x921 = confuse(m921);
+ l921 = confuse(m921);
+
+ }
+
+ void testF1021() {
+ // List<Function> Function(int y, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1021 is F1021);
+ Expect.isTrue(confuse(f1021) is F1021);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {core.List<core.int> x}) Function(int x) l1021;
+ // The static function f1021 sets `T` to `int`.
+ if (!tIsBool) {
+ x1021 = f1021 as dynamic;
+ l1021 = f1021 as dynamic;
+ x1021 = confuse(f1021);
+ l1021 = confuse(f1021);
+ }
+
+ Expect.isTrue(m1021 is F1021);
+ Expect.isTrue(m1021 is List<Function> Function(int y, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1021) is F1021);
+ // In checked mode, verifies the type.
+ x1021 = m1021;
+ l1021 = m1021;
+ x1021 = confuse(m1021);
+ l1021 = confuse(m1021);
+
+ }
+
+ void testF1121() {
+ // core.List<core.int> Function([Function x]) Function(int x)
+ Expect.isTrue(f1121 is F1121);
+ Expect.isTrue(confuse(f1121) is F1121);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x]) Function(int x) l1121;
+ // The static function f1121 sets `T` to `int`.
+ if (!tIsBool) {
+ x1121 = f1121 as dynamic;
+ l1121 = f1121 as dynamic;
+ x1121 = confuse(f1121);
+ l1121 = confuse(f1121);
+ }
+
+ Expect.isTrue(m1121 is F1121);
+ Expect.isTrue(m1121 is core.List<core.int> Function([Function x]) Function(int x));
+ Expect.isTrue(confuse(m1121) is F1121);
+ // In checked mode, verifies the type.
+ x1121 = m1121;
+ l1121 = m1121;
+ x1121 = confuse(m1121);
+ l1121 = confuse(m1121);
+
+ }
+
+ void testF1221() {
+ // core.List<core.int> Function(core.List<core.int> x1) Function(int x)
+ Expect.isTrue(f1221 is F1221);
+ Expect.isTrue(confuse(f1221) is F1221);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x1) Function(int x) l1221;
+ // The static function f1221 sets `T` to `int`.
+ if (!tIsBool) {
+ x1221 = f1221 as dynamic;
+ l1221 = f1221 as dynamic;
+ x1221 = confuse(f1221);
+ l1221 = confuse(f1221);
+ }
+
+ Expect.isTrue(m1221 is F1221);
+ Expect.isTrue(m1221 is core.List<core.int> Function(core.List<core.int> x1) Function(int x));
+ Expect.isTrue(confuse(m1221) is F1221);
+ // In checked mode, verifies the type.
+ x1221 = m1221;
+ l1221 = m1221;
+ x1221 = confuse(m1221);
+ l1221 = confuse(m1221);
+
+ }
+
+ void testF1321() {
+ // List<T> Function(int x2, [int x3]) Function(int x)
+ Expect.isTrue(f1321 is F1321);
+ Expect.isTrue(confuse(f1321) is F1321);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [int x3]) Function(int x) l1321;
+ // The static function f1321 sets `T` to `int`.
+ if (!tIsBool) {
+ x1321 = f1321 as dynamic;
+ l1321 = f1321 as dynamic;
+ x1321 = confuse(f1321);
+ l1321 = confuse(f1321);
+ }
+
+ Expect.isTrue(m1321 is F1321);
+ Expect.isTrue(m1321 is List<T> Function(int x2, [int x3]) Function(int x));
+ Expect.isTrue(confuse(m1321) is F1321);
+ // In checked mode, verifies the type.
+ x1321 = m1321;
+ l1321 = m1321;
+ x1321 = confuse(m1321);
+ l1321 = confuse(m1321);
+ if (!tIsBool) {
+ Expect.isTrue(f1321 is F1321<int>);
+ Expect.isFalse(f1321 is F1321<bool>);
+ Expect.isTrue(confuse(f1321) is F1321<int>);
+ Expect.isFalse(confuse(f1321) is F1321<bool>);
+ Expect.equals(tIsDynamic, m1321 is F1321<bool>);
+ Expect.equals(tIsDynamic, confuse(m1321) is F1321<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1321 = (f1321 as dynamic); });
+ Expect.throws(() { x1321 = confuse(f1321); });
+ List<T> Function(int x2, [int x3]) Function(int x) l1321;
+ Expect.throws(() { l1321 = (f1321 as dynamic); });
+ Expect.throws(() { l1321 = confuse(f1321); });
+ }
+ List<T> Function(int x2, [int x3]) Function(int x) l1321 = m1321;
+ // In checked mode, verifies the type.
+ x1321 = m1321;
+ x1321 = confuse(m1321);
+ }
+ }
+
+ void testF1421() {
+ // List<T> Function(int x1, {List<Function> x}) Function(int x)
+ Expect.isTrue(f1421 is F1421);
+ Expect.isTrue(confuse(f1421) is F1421);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {List<Function> x}) Function(int x) l1421;
+ // The static function f1421 sets `T` to `int`.
+ if (!tIsBool) {
+ x1421 = f1421 as dynamic;
+ l1421 = f1421 as dynamic;
+ x1421 = confuse(f1421);
+ l1421 = confuse(f1421);
+ }
+
+ Expect.isTrue(m1421 is F1421);
+ Expect.isTrue(m1421 is List<T> Function(int x1, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1421) is F1421);
+ // In checked mode, verifies the type.
+ x1421 = m1421;
+ l1421 = m1421;
+ x1421 = confuse(m1421);
+ l1421 = confuse(m1421);
+ if (!tIsBool) {
+ Expect.isTrue(f1421 is F1421<int>);
+ Expect.isFalse(f1421 is F1421<bool>);
+ Expect.isTrue(confuse(f1421) is F1421<int>);
+ Expect.isFalse(confuse(f1421) is F1421<bool>);
+ Expect.equals(tIsDynamic, m1421 is F1421<bool>);
+ Expect.equals(tIsDynamic, confuse(m1421) is F1421<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1421 = (f1421 as dynamic); });
+ Expect.throws(() { x1421 = confuse(f1421); });
+ List<T> Function(int x1, {List<Function> x}) Function(int x) l1421;
+ Expect.throws(() { l1421 = (f1421 as dynamic); });
+ Expect.throws(() { l1421 = confuse(f1421); });
+ }
+ List<T> Function(int x1, {List<Function> x}) Function(int x) l1421 = m1421;
+ // In checked mode, verifies the type.
+ x1421 = m1421;
+ x1421 = confuse(m1421);
+ }
+ }
+
+ void testF1521() {
+ // Function(int x) Function(int x)
+ Expect.isTrue(f1521 is F1521);
+ Expect.isTrue(confuse(f1521) is F1521);
+ // In checked mode, verifies the type.
+ Function(int x) Function(int x) l1521;
+ // The static function f1521 sets `T` to `int`.
+ if (!tIsBool) {
+ x1521 = f1521 as dynamic;
+ l1521 = f1521 as dynamic;
+ x1521 = confuse(f1521);
+ l1521 = confuse(f1521);
+ }
+
+ Expect.isTrue(m1521 is F1521);
+ Expect.isTrue(m1521 is Function(int x) Function(int x));
+ Expect.isTrue(confuse(m1521) is F1521);
+ // In checked mode, verifies the type.
+ x1521 = m1521;
+ l1521 = m1521;
+ x1521 = confuse(m1521);
+ l1521 = confuse(m1521);
+
+ }
+
+ void testF1621() {
+ // Function(int y, [List<Function> x]) Function(int x)
+ Expect.isTrue(f1621 is F1621);
+ Expect.isTrue(confuse(f1621) is F1621);
+ // In checked mode, verifies the type.
+ Function(int y, [List<Function> x]) Function(int x) l1621;
+ // The static function f1621 sets `T` to `int`.
+ if (!tIsBool) {
+ x1621 = f1621 as dynamic;
+ l1621 = f1621 as dynamic;
+ x1621 = confuse(f1621);
+ l1621 = confuse(f1621);
+ }
+
+ Expect.isTrue(m1621 is F1621);
+ Expect.isTrue(m1621 is Function(int y, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1621) is F1621);
+ // In checked mode, verifies the type.
+ x1621 = m1621;
+ l1621 = m1621;
+ x1621 = confuse(m1621);
+ l1621 = confuse(m1621);
+
+ }
+
+ void testF1721() {
+ // Function(int x2, [List<T> x3]) Function(int x)
+ Expect.isTrue(f1721 is F1721);
+ Expect.isTrue(confuse(f1721) is F1721);
+ // In checked mode, verifies the type.
+ Function(int x2, [List<T> x3]) Function(int x) l1721;
+ // The static function f1721 sets `T` to `int`.
+ if (!tIsBool) {
+ x1721 = f1721 as dynamic;
+ l1721 = f1721 as dynamic;
+ x1721 = confuse(f1721);
+ l1721 = confuse(f1721);
+ }
+
+ Expect.isTrue(m1721 is F1721);
+ Expect.isTrue(m1721 is Function(int x2, [List<T> x3]) Function(int x));
+ Expect.isTrue(confuse(m1721) is F1721);
+ // In checked mode, verifies the type.
+ x1721 = m1721;
+ l1721 = m1721;
+ x1721 = confuse(m1721);
+ l1721 = confuse(m1721);
+ if (!tIsBool) {
+ Expect.isTrue(f1721 is F1721<int>);
+ Expect.isFalse(f1721 is F1721<bool>);
+ Expect.isTrue(confuse(f1721) is F1721<int>);
+ Expect.isFalse(confuse(f1721) is F1721<bool>);
+ Expect.equals(tIsDynamic, m1721 is F1721<bool>);
+ Expect.equals(tIsDynamic, confuse(m1721) is F1721<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1721 = (f1721 as dynamic); });
+ Expect.throws(() { x1721 = confuse(f1721); });
+ Function(int x2, [List<T> x3]) Function(int x) l1721;
+ Expect.throws(() { l1721 = (f1721 as dynamic); });
+ Expect.throws(() { l1721 = confuse(f1721); });
+ }
+ Function(int x2, [List<T> x3]) Function(int x) l1721 = m1721;
+ // In checked mode, verifies the type.
+ x1721 = m1721;
+ x1721 = confuse(m1721);
+ }
+ }
+
+ void testF1821() {
+ // List<Function> Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1821 is F1821);
+ Expect.isTrue(confuse(f1821) is F1821);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(core.List<core.int> x) Function(int x) l1821;
+ // The static function f1821 sets `T` to `int`.
+ if (!tIsBool) {
+ x1821 = f1821 as dynamic;
+ l1821 = f1821 as dynamic;
+ x1821 = confuse(f1821);
+ l1821 = confuse(f1821);
+ }
+
+ Expect.isTrue(m1821 is F1821);
+ Expect.isTrue(m1821 is List<Function> Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1821) is F1821);
+ // In checked mode, verifies the type.
+ x1821 = m1821;
+ l1821 = m1821;
+ x1821 = confuse(m1821);
+ l1821 = confuse(m1821);
+
+ }
+
+ void testF1921() {
+ // Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1921 is F1921);
+ Expect.isTrue(confuse(f1921) is F1921);
+ // In checked mode, verifies the type.
+ Function<A>(List<T> x) Function(int x) l1921;
+ // The static function f1921 sets `T` to `int`.
+ if (!tIsBool) {
+ x1921 = f1921 as dynamic;
+ l1921 = f1921 as dynamic;
+ x1921 = confuse(f1921);
+ l1921 = confuse(f1921);
+ }
+
+ Expect.isTrue(m1921 is F1921);
+ Expect.isTrue(m1921 is Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1921) is F1921);
+ // In checked mode, verifies the type.
+ x1921 = m1921;
+ l1921 = m1921;
+ x1921 = confuse(m1921);
+ l1921 = confuse(m1921);
+ if (!tIsBool) {
+ Expect.isTrue(f1921 is F1921<int>);
+ Expect.isFalse(f1921 is F1921<bool>);
+ Expect.isTrue(confuse(f1921) is F1921<int>);
+ Expect.isFalse(confuse(f1921) is F1921<bool>);
+ Expect.equals(tIsDynamic, m1921 is F1921<bool>);
+ Expect.equals(tIsDynamic, confuse(m1921) is F1921<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1921 = (f1921 as dynamic); });
+ Expect.throws(() { x1921 = confuse(f1921); });
+ Function<A>(List<T> x) Function(int x) l1921;
+ Expect.throws(() { l1921 = (f1921 as dynamic); });
+ Expect.throws(() { l1921 = confuse(f1921); });
+ }
+ Function<A>(List<T> x) Function(int x) l1921 = m1921;
+ // In checked mode, verifies the type.
+ x1921 = m1921;
+ x1921 = confuse(m1921);
+ }
+ }
+
+ void testF2021() {
+ // B Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2021 is F2021);
+ Expect.isTrue(confuse(f2021) is F2021);
+ // In checked mode, verifies the type.
+ B Function(List<Function> x) Function<B extends core.int>(int x) l2021;
+ // The static function f2021 sets `T` to `int`.
+ if (!tIsBool) {
+ x2021 = f2021 as dynamic;
+ l2021 = f2021 as dynamic;
+ x2021 = confuse(f2021);
+ l2021 = confuse(f2021);
+ }
+
+ Expect.isTrue(m2021 is F2021);
+ Expect.isTrue(m2021 is B Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2021) is F2021);
+ // In checked mode, verifies the type.
+ x2021 = m2021;
+ l2021 = m2021;
+ x2021 = confuse(m2021);
+ l2021 = confuse(m2021);
+
+ }
+
+
+}
+
+class C22<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(List<Function> x) x22;
+ List<Function> Function(int y, {int x}) x122;
+ core.List<core.int> Function(int y, {List<T> x}) x222;
+ Function(int x0, {core.List<core.int> x}) x322;
+ int Function([int x1]) Function<B extends core.int>() x422;
+ int Function({List<Function> x}) Function<B extends core.int>() x522;
+ int Function() Function<B extends core.int>() x622;
+ Function Function(int x1, [List<Function> x]) Function<B extends core.int>() x722;
+ Function Function([List<T> x1]) Function<B extends core.int>() x822;
+ List<Function> Function(int x, [Function x1]) Function<B extends core.int>() x922;
+ List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() x1022;
+ core.List<core.int> Function([Function x]) Function<B extends core.int>() x1122;
+ core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>() x1222;
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>() x1322;
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>() x1422;
+ Function(int x) Function<B extends core.int>() x1522;
+ Function(int y, [List<Function> x]) Function<B extends core.int>() x1622;
+ Function(int x2, [List<T> x3]) Function<B extends core.int>() x1722;
+ List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>() x1822;
+ Function<A>(List<T> x) Function<B extends core.int>() x1922;
+ B Function(core.List<core.int> x) Function<B extends core.int>() x2022;
+
+
+ C22({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m22(List<Function> x) => null;
+ List<Function> m122(int y, {int x}) => null;
+ core.List<core.int> m222(int y, {List<T> x}) => null;
+ m322(int x0, {core.List<core.int> x}) => null;
+ int Function([int x0]) m422<B extends core.int>() => null;
+ int Function({List<Function> x}) m522<B extends core.int>() => null;
+ int Function() m622<B extends core.int>() => null;
+ Function Function(int x0, [List<Function> x]) m722<B extends core.int>() => null;
+ Function Function([List<T> x0]) m822<B extends core.int>() => null;
+ List<Function> Function(int x, [Function x0]) m922<B extends core.int>() => null;
+ List<Function> Function(int y, {core.List<core.int> x}) m1022<B extends core.int>() => null;
+ core.List<core.int> Function([Function x]) m1122<B extends core.int>() => null;
+ core.List<core.int> Function(core.List<core.int> x0) m1222<B extends core.int>() => null;
+ List<T> Function(int x0, [int x1]) m1322<B extends core.int>() => null;
+ List<T> Function(int x0, {List<Function> x}) m1422<B extends core.int>() => null;
+ Function(int x) m1522<B extends core.int>() => null;
+ Function(int y, [List<Function> x]) m1622<B extends core.int>() => null;
+ Function(int x0, [List<T> x1]) m1722<B extends core.int>() => null;
+ List<Function> Function<A>(core.List<core.int> x) m1822<B extends core.int>() => null;
+ Function<A>(List<T> x) m1922<B extends core.int>() => null;
+ B Function(core.List<core.int> x) m2022<B extends core.int>() => null;
+
+
+ runTests() {
+ testF22();
+ testF122();
+ testF222();
+ testF322();
+ testF422();
+ testF522();
+ testF622();
+ testF722();
+ testF822();
+ testF922();
+ testF1022();
+ testF1122();
+ testF1222();
+ testF1322();
+ testF1422();
+ testF1522();
+ testF1622();
+ testF1722();
+ testF1822();
+ testF1922();
+ testF2022();
+ }
+
+ void testF22() {
+ // int Function(List<Function> x)
+ Expect.isTrue(f22 is F22);
+ Expect.isTrue(confuse(f22) is F22);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x) l22;
+ // The static function f22 sets `T` to `int`.
+ if (!tIsBool) {
+ x22 = f22 as dynamic;
+ l22 = f22 as dynamic;
+ x22 = confuse(f22);
+ l22 = confuse(f22);
+ }
+
+ Expect.isTrue(m22 is F22);
+ Expect.isTrue(m22 is int Function(List<Function> x));
+ Expect.isTrue(confuse(m22) is F22);
+ // In checked mode, verifies the type.
+ x22 = m22;
+ l22 = m22;
+ x22 = confuse(m22);
+ l22 = confuse(m22);
+
+ }
+
+ void testF122() {
+ // List<Function> Function(int y, {int x})
+ Expect.isTrue(f122 is F122);
+ Expect.isTrue(confuse(f122) is F122);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {int x}) l122;
+ // The static function f122 sets `T` to `int`.
+ if (!tIsBool) {
+ x122 = f122 as dynamic;
+ l122 = f122 as dynamic;
+ x122 = confuse(f122);
+ l122 = confuse(f122);
+ }
+
+ Expect.isTrue(m122 is F122);
+ Expect.isTrue(m122 is List<Function> Function(int y, {int x}));
+ Expect.isTrue(confuse(m122) is F122);
+ // In checked mode, verifies the type.
+ x122 = m122;
+ l122 = m122;
+ x122 = confuse(m122);
+ l122 = confuse(m122);
+
+ }
+
+ void testF222() {
+ // core.List<core.int> Function(int y, {List<T> x})
+ Expect.isTrue(f222 is F222);
+ Expect.isTrue(confuse(f222) is F222);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<T> x}) l222;
+ // The static function f222 sets `T` to `int`.
+ if (!tIsBool) {
+ x222 = f222 as dynamic;
+ l222 = f222 as dynamic;
+ x222 = confuse(f222);
+ l222 = confuse(f222);
+ }
+
+ Expect.isTrue(m222 is F222);
+ Expect.isTrue(m222 is core.List<core.int> Function(int y, {List<T> x}));
+ Expect.isTrue(confuse(m222) is F222);
+ // In checked mode, verifies the type.
+ x222 = m222;
+ l222 = m222;
+ x222 = confuse(m222);
+ l222 = confuse(m222);
+ if (!tIsBool) {
+ Expect.isTrue(f222 is F222<int>);
+ Expect.isFalse(f222 is F222<bool>);
+ Expect.isTrue(confuse(f222) is F222<int>);
+ Expect.isFalse(confuse(f222) is F222<bool>);
+ Expect.equals(tIsDynamic, m222 is F222<bool>);
+ Expect.equals(tIsDynamic, confuse(m222) is F222<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x222 = (f222 as dynamic); });
+ Expect.throws(() { x222 = confuse(f222); });
+ core.List<core.int> Function(int y, {List<T> x}) l222;
+ Expect.throws(() { l222 = (f222 as dynamic); });
+ Expect.throws(() { l222 = confuse(f222); });
+ }
+ core.List<core.int> Function(int y, {List<T> x}) l222 = m222;
+ // In checked mode, verifies the type.
+ x222 = m222;
+ x222 = confuse(m222);
+ }
+ }
+
+ void testF322() {
+ // Function(int x0, {core.List<core.int> x})
+ Expect.isTrue(f322 is F322);
+ Expect.isTrue(confuse(f322) is F322);
+ // In checked mode, verifies the type.
+ Function(int x0, {core.List<core.int> x}) l322;
+ // The static function f322 sets `T` to `int`.
+ if (!tIsBool) {
+ x322 = f322 as dynamic;
+ l322 = f322 as dynamic;
+ x322 = confuse(f322);
+ l322 = confuse(f322);
+ }
+
+ Expect.isTrue(m322 is F322);
+ Expect.isTrue(m322 is Function(int x0, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m322) is F322);
+ // In checked mode, verifies the type.
+ x322 = m322;
+ l322 = m322;
+ x322 = confuse(m322);
+ l322 = confuse(m322);
+
+ }
+
+ void testF422() {
+ // int Function([int x1]) Function<B extends core.int>()
+ Expect.isTrue(f422 is F422);
+ Expect.isTrue(confuse(f422) is F422);
+ // In checked mode, verifies the type.
+ int Function([int x1]) Function<B extends core.int>() l422;
+ // The static function f422 sets `T` to `int`.
+ if (!tIsBool) {
+ x422 = f422 as dynamic;
+ l422 = f422 as dynamic;
+ x422 = confuse(f422);
+ l422 = confuse(f422);
+ }
+
+ Expect.isTrue(m422 is F422);
+ Expect.isTrue(m422 is int Function([int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m422) is F422);
+ // In checked mode, verifies the type.
+ x422 = m422;
+ l422 = m422;
+ x422 = confuse(m422);
+ l422 = confuse(m422);
+
+ }
+
+ void testF522() {
+ // int Function({List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f522 is F522);
+ Expect.isTrue(confuse(f522) is F522);
+ // In checked mode, verifies the type.
+ int Function({List<Function> x}) Function<B extends core.int>() l522;
+ // The static function f522 sets `T` to `int`.
+ if (!tIsBool) {
+ x522 = f522 as dynamic;
+ l522 = f522 as dynamic;
+ x522 = confuse(f522);
+ l522 = confuse(f522);
+ }
+
+ Expect.isTrue(m522 is F522);
+ Expect.isTrue(m522 is int Function({List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m522) is F522);
+ // In checked mode, verifies the type.
+ x522 = m522;
+ l522 = m522;
+ x522 = confuse(m522);
+ l522 = confuse(m522);
+
+ }
+
+ void testF622() {
+ // int Function() Function<B extends core.int>()
+ Expect.isTrue(f622 is F622);
+ Expect.isTrue(confuse(f622) is F622);
+ // In checked mode, verifies the type.
+ int Function() Function<B extends core.int>() l622;
+ // The static function f622 sets `T` to `int`.
+ if (!tIsBool) {
+ x622 = f622 as dynamic;
+ l622 = f622 as dynamic;
+ x622 = confuse(f622);
+ l622 = confuse(f622);
+ }
+
+ Expect.isTrue(m622 is F622);
+ Expect.isTrue(m622 is int Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m622) is F622);
+ // In checked mode, verifies the type.
+ x622 = m622;
+ l622 = m622;
+ x622 = confuse(m622);
+ l622 = confuse(m622);
+
+ }
+
+ void testF722() {
+ // Function Function(int x1, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f722 is F722);
+ Expect.isTrue(confuse(f722) is F722);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<Function> x]) Function<B extends core.int>() l722;
+ // The static function f722 sets `T` to `int`.
+ if (!tIsBool) {
+ x722 = f722 as dynamic;
+ l722 = f722 as dynamic;
+ x722 = confuse(f722);
+ l722 = confuse(f722);
+ }
+
+ Expect.isTrue(m722 is F722);
+ Expect.isTrue(m722 is Function Function(int x1, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m722) is F722);
+ // In checked mode, verifies the type.
+ x722 = m722;
+ l722 = m722;
+ x722 = confuse(m722);
+ l722 = confuse(m722);
+
+ }
+
+ void testF822() {
+ // Function Function([List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f822 is F822);
+ Expect.isTrue(confuse(f822) is F822);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x1]) Function<B extends core.int>() l822;
+ // The static function f822 sets `T` to `int`.
+ if (!tIsBool) {
+ x822 = f822 as dynamic;
+ l822 = f822 as dynamic;
+ x822 = confuse(f822);
+ l822 = confuse(f822);
+ }
+
+ Expect.isTrue(m822 is F822);
+ Expect.isTrue(m822 is Function Function([List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m822) is F822);
+ // In checked mode, verifies the type.
+ x822 = m822;
+ l822 = m822;
+ x822 = confuse(m822);
+ l822 = confuse(m822);
+ if (!tIsBool) {
+ Expect.isTrue(f822 is F822<int>);
+ Expect.isFalse(f822 is F822<bool>);
+ Expect.isTrue(confuse(f822) is F822<int>);
+ Expect.isFalse(confuse(f822) is F822<bool>);
+ Expect.equals(tIsDynamic, m822 is F822<bool>);
+ Expect.equals(tIsDynamic, confuse(m822) is F822<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x822 = (f822 as dynamic); });
+ Expect.throws(() { x822 = confuse(f822); });
+ Function Function([List<T> x1]) Function<B extends core.int>() l822;
+ Expect.throws(() { l822 = (f822 as dynamic); });
+ Expect.throws(() { l822 = confuse(f822); });
+ }
+ Function Function([List<T> x1]) Function<B extends core.int>() l822 = m822;
+ // In checked mode, verifies the type.
+ x822 = m822;
+ x822 = confuse(m822);
+ }
+ }
+
+ void testF922() {
+ // List<Function> Function(int x, [Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f922 is F922);
+ Expect.isTrue(confuse(f922) is F922);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [Function x1]) Function<B extends core.int>() l922;
+ // The static function f922 sets `T` to `int`.
+ if (!tIsBool) {
+ x922 = f922 as dynamic;
+ l922 = f922 as dynamic;
+ x922 = confuse(f922);
+ l922 = confuse(f922);
+ }
+
+ Expect.isTrue(m922 is F922);
+ Expect.isTrue(m922 is List<Function> Function(int x, [Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m922) is F922);
+ // In checked mode, verifies the type.
+ x922 = m922;
+ l922 = m922;
+ x922 = confuse(m922);
+ l922 = confuse(m922);
+
+ }
+
+ void testF1022() {
+ // List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1022 is F1022);
+ Expect.isTrue(confuse(f1022) is F1022);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l1022;
+ // The static function f1022 sets `T` to `int`.
+ if (!tIsBool) {
+ x1022 = f1022 as dynamic;
+ l1022 = f1022 as dynamic;
+ x1022 = confuse(f1022);
+ l1022 = confuse(f1022);
+ }
+
+ Expect.isTrue(m1022 is F1022);
+ Expect.isTrue(m1022 is List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1022) is F1022);
+ // In checked mode, verifies the type.
+ x1022 = m1022;
+ l1022 = m1022;
+ x1022 = confuse(m1022);
+ l1022 = confuse(m1022);
+
+ }
+
+ void testF1122() {
+ // core.List<core.int> Function([Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1122 is F1122);
+ Expect.isTrue(confuse(f1122) is F1122);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x]) Function<B extends core.int>() l1122;
+ // The static function f1122 sets `T` to `int`.
+ if (!tIsBool) {
+ x1122 = f1122 as dynamic;
+ l1122 = f1122 as dynamic;
+ x1122 = confuse(f1122);
+ l1122 = confuse(f1122);
+ }
+
+ Expect.isTrue(m1122 is F1122);
+ Expect.isTrue(m1122 is core.List<core.int> Function([Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1122) is F1122);
+ // In checked mode, verifies the type.
+ x1122 = m1122;
+ l1122 = m1122;
+ x1122 = confuse(m1122);
+ l1122 = confuse(m1122);
+
+ }
+
+ void testF1222() {
+ // core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>()
+ Expect.isTrue(f1222 is F1222);
+ Expect.isTrue(confuse(f1222) is F1222);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>() l1222;
+ // The static function f1222 sets `T` to `int`.
+ if (!tIsBool) {
+ x1222 = f1222 as dynamic;
+ l1222 = f1222 as dynamic;
+ x1222 = confuse(f1222);
+ l1222 = confuse(f1222);
+ }
+
+ Expect.isTrue(m1222 is F1222);
+ Expect.isTrue(m1222 is core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1222) is F1222);
+ // In checked mode, verifies the type.
+ x1222 = m1222;
+ l1222 = m1222;
+ x1222 = confuse(m1222);
+ l1222 = confuse(m1222);
+
+ }
+
+ void testF1322() {
+ // List<T> Function(int x2, [int x3]) Function<B extends core.int>()
+ Expect.isTrue(f1322 is F1322);
+ Expect.isTrue(confuse(f1322) is F1322);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>() l1322;
+ // The static function f1322 sets `T` to `int`.
+ if (!tIsBool) {
+ x1322 = f1322 as dynamic;
+ l1322 = f1322 as dynamic;
+ x1322 = confuse(f1322);
+ l1322 = confuse(f1322);
+ }
+
+ Expect.isTrue(m1322 is F1322);
+ Expect.isTrue(m1322 is List<T> Function(int x2, [int x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1322) is F1322);
+ // In checked mode, verifies the type.
+ x1322 = m1322;
+ l1322 = m1322;
+ x1322 = confuse(m1322);
+ l1322 = confuse(m1322);
+ if (!tIsBool) {
+ Expect.isTrue(f1322 is F1322<int>);
+ Expect.isFalse(f1322 is F1322<bool>);
+ Expect.isTrue(confuse(f1322) is F1322<int>);
+ Expect.isFalse(confuse(f1322) is F1322<bool>);
+ Expect.equals(tIsDynamic, m1322 is F1322<bool>);
+ Expect.equals(tIsDynamic, confuse(m1322) is F1322<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1322 = (f1322 as dynamic); });
+ Expect.throws(() { x1322 = confuse(f1322); });
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>() l1322;
+ Expect.throws(() { l1322 = (f1322 as dynamic); });
+ Expect.throws(() { l1322 = confuse(f1322); });
+ }
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>() l1322 = m1322;
+ // In checked mode, verifies the type.
+ x1322 = m1322;
+ x1322 = confuse(m1322);
+ }
+ }
+
+ void testF1422() {
+ // List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1422 is F1422);
+ Expect.isTrue(confuse(f1422) is F1422);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>() l1422;
+ // The static function f1422 sets `T` to `int`.
+ if (!tIsBool) {
+ x1422 = f1422 as dynamic;
+ l1422 = f1422 as dynamic;
+ x1422 = confuse(f1422);
+ l1422 = confuse(f1422);
+ }
+
+ Expect.isTrue(m1422 is F1422);
+ Expect.isTrue(m1422 is List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1422) is F1422);
+ // In checked mode, verifies the type.
+ x1422 = m1422;
+ l1422 = m1422;
+ x1422 = confuse(m1422);
+ l1422 = confuse(m1422);
+ if (!tIsBool) {
+ Expect.isTrue(f1422 is F1422<int>);
+ Expect.isFalse(f1422 is F1422<bool>);
+ Expect.isTrue(confuse(f1422) is F1422<int>);
+ Expect.isFalse(confuse(f1422) is F1422<bool>);
+ Expect.equals(tIsDynamic, m1422 is F1422<bool>);
+ Expect.equals(tIsDynamic, confuse(m1422) is F1422<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1422 = (f1422 as dynamic); });
+ Expect.throws(() { x1422 = confuse(f1422); });
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>() l1422;
+ Expect.throws(() { l1422 = (f1422 as dynamic); });
+ Expect.throws(() { l1422 = confuse(f1422); });
+ }
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>() l1422 = m1422;
+ // In checked mode, verifies the type.
+ x1422 = m1422;
+ x1422 = confuse(m1422);
+ }
+ }
+
+ void testF1522() {
+ // Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f1522 is F1522);
+ Expect.isTrue(confuse(f1522) is F1522);
+ // In checked mode, verifies the type.
+ Function(int x) Function<B extends core.int>() l1522;
+ // The static function f1522 sets `T` to `int`.
+ if (!tIsBool) {
+ x1522 = f1522 as dynamic;
+ l1522 = f1522 as dynamic;
+ x1522 = confuse(f1522);
+ l1522 = confuse(f1522);
+ }
+
+ Expect.isTrue(m1522 is F1522);
+ Expect.isTrue(m1522 is Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1522) is F1522);
+ // In checked mode, verifies the type.
+ x1522 = m1522;
+ l1522 = m1522;
+ x1522 = confuse(m1522);
+ l1522 = confuse(m1522);
+
+ }
+
+ void testF1622() {
+ // Function(int y, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1622 is F1622);
+ Expect.isTrue(confuse(f1622) is F1622);
+ // In checked mode, verifies the type.
+ Function(int y, [List<Function> x]) Function<B extends core.int>() l1622;
+ // The static function f1622 sets `T` to `int`.
+ if (!tIsBool) {
+ x1622 = f1622 as dynamic;
+ l1622 = f1622 as dynamic;
+ x1622 = confuse(f1622);
+ l1622 = confuse(f1622);
+ }
+
+ Expect.isTrue(m1622 is F1622);
+ Expect.isTrue(m1622 is Function(int y, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1622) is F1622);
+ // In checked mode, verifies the type.
+ x1622 = m1622;
+ l1622 = m1622;
+ x1622 = confuse(m1622);
+ l1622 = confuse(m1622);
+
+ }
+
+ void testF1722() {
+ // Function(int x2, [List<T> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1722 is F1722);
+ Expect.isTrue(confuse(f1722) is F1722);
+ // In checked mode, verifies the type.
+ Function(int x2, [List<T> x3]) Function<B extends core.int>() l1722;
+ // The static function f1722 sets `T` to `int`.
+ if (!tIsBool) {
+ x1722 = f1722 as dynamic;
+ l1722 = f1722 as dynamic;
+ x1722 = confuse(f1722);
+ l1722 = confuse(f1722);
+ }
+
+ Expect.isTrue(m1722 is F1722);
+ Expect.isTrue(m1722 is Function(int x2, [List<T> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1722) is F1722);
+ // In checked mode, verifies the type.
+ x1722 = m1722;
+ l1722 = m1722;
+ x1722 = confuse(m1722);
+ l1722 = confuse(m1722);
+ if (!tIsBool) {
+ Expect.isTrue(f1722 is F1722<int>);
+ Expect.isFalse(f1722 is F1722<bool>);
+ Expect.isTrue(confuse(f1722) is F1722<int>);
+ Expect.isFalse(confuse(f1722) is F1722<bool>);
+ Expect.equals(tIsDynamic, m1722 is F1722<bool>);
+ Expect.equals(tIsDynamic, confuse(m1722) is F1722<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1722 = (f1722 as dynamic); });
+ Expect.throws(() { x1722 = confuse(f1722); });
+ Function(int x2, [List<T> x3]) Function<B extends core.int>() l1722;
+ Expect.throws(() { l1722 = (f1722 as dynamic); });
+ Expect.throws(() { l1722 = confuse(f1722); });
+ }
+ Function(int x2, [List<T> x3]) Function<B extends core.int>() l1722 = m1722;
+ // In checked mode, verifies the type.
+ x1722 = m1722;
+ x1722 = confuse(m1722);
+ }
+ }
+
+ void testF1822() {
+ // List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1822 is F1822);
+ Expect.isTrue(confuse(f1822) is F1822);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>() l1822;
+ // The static function f1822 sets `T` to `int`.
+ if (!tIsBool) {
+ x1822 = f1822 as dynamic;
+ l1822 = f1822 as dynamic;
+ x1822 = confuse(f1822);
+ l1822 = confuse(f1822);
+ }
+
+ Expect.isTrue(m1822 is F1822);
+ Expect.isTrue(m1822 is List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1822) is F1822);
+ // In checked mode, verifies the type.
+ x1822 = m1822;
+ l1822 = m1822;
+ x1822 = confuse(m1822);
+ l1822 = confuse(m1822);
+
+ }
+
+ void testF1922() {
+ // Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1922 is F1922);
+ Expect.isTrue(confuse(f1922) is F1922);
+ // In checked mode, verifies the type.
+ Function<A>(List<T> x) Function<B extends core.int>() l1922;
+ // The static function f1922 sets `T` to `int`.
+ if (!tIsBool) {
+ x1922 = f1922 as dynamic;
+ l1922 = f1922 as dynamic;
+ x1922 = confuse(f1922);
+ l1922 = confuse(f1922);
+ }
+
+ Expect.isTrue(m1922 is F1922);
+ Expect.isTrue(m1922 is Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1922) is F1922);
+ // In checked mode, verifies the type.
+ x1922 = m1922;
+ l1922 = m1922;
+ x1922 = confuse(m1922);
+ l1922 = confuse(m1922);
+ if (!tIsBool) {
+ Expect.isTrue(f1922 is F1922<int>);
+ Expect.isFalse(f1922 is F1922<bool>);
+ Expect.isTrue(confuse(f1922) is F1922<int>);
+ Expect.isFalse(confuse(f1922) is F1922<bool>);
+ Expect.equals(tIsDynamic, m1922 is F1922<bool>);
+ Expect.equals(tIsDynamic, confuse(m1922) is F1922<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1922 = (f1922 as dynamic); });
+ Expect.throws(() { x1922 = confuse(f1922); });
+ Function<A>(List<T> x) Function<B extends core.int>() l1922;
+ Expect.throws(() { l1922 = (f1922 as dynamic); });
+ Expect.throws(() { l1922 = confuse(f1922); });
+ }
+ Function<A>(List<T> x) Function<B extends core.int>() l1922 = m1922;
+ // In checked mode, verifies the type.
+ x1922 = m1922;
+ x1922 = confuse(m1922);
+ }
+ }
+
+ void testF2022() {
+ // B Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f2022 is F2022);
+ Expect.isTrue(confuse(f2022) is F2022);
+ // In checked mode, verifies the type.
+ B Function(core.List<core.int> x) Function<B extends core.int>() l2022;
+ // The static function f2022 sets `T` to `int`.
+ if (!tIsBool) {
+ x2022 = f2022 as dynamic;
+ l2022 = f2022 as dynamic;
+ x2022 = confuse(f2022);
+ l2022 = confuse(f2022);
+ }
+
+ Expect.isTrue(m2022 is F2022);
+ Expect.isTrue(m2022 is B Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2022) is F2022);
+ // In checked mode, verifies the type.
+ x2022 = m2022;
+ l2022 = m2022;
+ x2022 = confuse(m2022);
+ l2022 = confuse(m2022);
+
+ }
+
+
+}
+
+class C23<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([List<Function> x]) x23;
+ List<Function> Function(Function x) x123;
+ core.List<core.int> Function() x223;
+ Function(int y, {core.List<core.int> x}) x323;
+ int Function([int x1]) Function<B extends core.int>(int x) x423;
+ int Function({List<Function> x}) Function<B extends core.int>(int x) x523;
+ int Function() Function<B extends core.int>(int x) x623;
+ Function Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) x723;
+ Function Function([List<T> x1]) Function<B extends core.int>(int x) x823;
+ List<Function> Function(int x, [Function x1]) Function<B extends core.int>(int x) x923;
+ List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) x1023;
+ core.List<core.int> Function([Function x]) Function<B extends core.int>(int x) x1123;
+ core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>(int x) x1223;
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x) x1323;
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) x1423;
+ Function(int x) Function<B extends core.int>(int x) x1523;
+ Function(int y, [List<Function> x]) Function<B extends core.int>(int x) x1623;
+ Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) x1723;
+ List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1823;
+ Function<A>(List<T> x) Function<B extends core.int>(int x) x1923;
+ B Function(core.List<core.int> x) Function<B extends core.int>(int x) x2023;
+
+
+ C23({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m23([List<Function> x]) => null;
+ List<Function> m123(Function x) => null;
+ core.List<core.int> m223() => null;
+ m323(int y, {core.List<core.int> x}) => null;
+ int Function([int x0]) m423<B extends core.int>(int x) => null;
+ int Function({List<Function> x}) m523<B extends core.int>(int x) => null;
+ int Function() m623<B extends core.int>(int x) => null;
+ Function Function(int x0, [List<Function> x]) m723<B extends core.int>(int x) => null;
+ Function Function([List<T> x0]) m823<B extends core.int>(int x) => null;
+ List<Function> Function(int x, [Function x0]) m923<B extends core.int>(int x) => null;
+ List<Function> Function(int y, {core.List<core.int> x}) m1023<B extends core.int>(int x) => null;
+ core.List<core.int> Function([Function x]) m1123<B extends core.int>(int x) => null;
+ core.List<core.int> Function(core.List<core.int> x0) m1223<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [int x1]) m1323<B extends core.int>(int x) => null;
+ List<T> Function(int x0, {List<Function> x}) m1423<B extends core.int>(int x) => null;
+ Function(int x) m1523<B extends core.int>(int x) => null;
+ Function(int y, [List<Function> x]) m1623<B extends core.int>(int x) => null;
+ Function(int x0, [List<T> x1]) m1723<B extends core.int>(int x) => null;
+ List<Function> Function<A>(core.List<core.int> x) m1823<B extends core.int>(int x) => null;
+ Function<A>(List<T> x) m1923<B extends core.int>(int x) => null;
+ B Function(core.List<core.int> x) m2023<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF23();
+ testF123();
+ testF223();
+ testF323();
+ testF423();
+ testF523();
+ testF623();
+ testF723();
+ testF823();
+ testF923();
+ testF1023();
+ testF1123();
+ testF1223();
+ testF1323();
+ testF1423();
+ testF1523();
+ testF1623();
+ testF1723();
+ testF1823();
+ testF1923();
+ testF2023();
+ }
+
+ void testF23() {
+ // int Function([List<Function> x])
+ Expect.isTrue(f23 is F23);
+ Expect.isTrue(confuse(f23) is F23);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x]) l23;
+ // The static function f23 sets `T` to `int`.
+ if (!tIsBool) {
+ x23 = f23 as dynamic;
+ l23 = f23 as dynamic;
+ x23 = confuse(f23);
+ l23 = confuse(f23);
+ }
+
+ Expect.isTrue(m23 is F23);
+ Expect.isTrue(m23 is int Function([List<Function> x]));
+ Expect.isTrue(confuse(m23) is F23);
+ // In checked mode, verifies the type.
+ x23 = m23;
+ l23 = m23;
+ x23 = confuse(m23);
+ l23 = confuse(m23);
+
+ }
+
+ void testF123() {
+ // List<Function> Function(Function x)
+ Expect.isTrue(f123 is F123);
+ Expect.isTrue(confuse(f123) is F123);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x) l123;
+ // The static function f123 sets `T` to `int`.
+ if (!tIsBool) {
+ x123 = f123 as dynamic;
+ l123 = f123 as dynamic;
+ x123 = confuse(f123);
+ l123 = confuse(f123);
+ }
+
+ Expect.isTrue(m123 is F123);
+ Expect.isTrue(m123 is List<Function> Function(Function x));
+ Expect.isTrue(confuse(m123) is F123);
+ // In checked mode, verifies the type.
+ x123 = m123;
+ l123 = m123;
+ x123 = confuse(m123);
+ l123 = confuse(m123);
+
+ }
+
+ void testF223() {
+ // core.List<core.int> Function()
+ Expect.isTrue(f223 is F223);
+ Expect.isTrue(confuse(f223) is F223);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function() l223;
+ // The static function f223 sets `T` to `int`.
+ if (!tIsBool) {
+ x223 = f223 as dynamic;
+ l223 = f223 as dynamic;
+ x223 = confuse(f223);
+ l223 = confuse(f223);
+ }
+
+ Expect.isTrue(m223 is F223);
+ Expect.isTrue(m223 is core.List<core.int> Function());
+ Expect.isTrue(confuse(m223) is F223);
+ // In checked mode, verifies the type.
+ x223 = m223;
+ l223 = m223;
+ x223 = confuse(m223);
+ l223 = confuse(m223);
+
+ }
+
+ void testF323() {
+ // Function(int y, {core.List<core.int> x})
+ Expect.isTrue(f323 is F323);
+ Expect.isTrue(confuse(f323) is F323);
+ // In checked mode, verifies the type.
+ Function(int y, {core.List<core.int> x}) l323;
+ // The static function f323 sets `T` to `int`.
+ if (!tIsBool) {
+ x323 = f323 as dynamic;
+ l323 = f323 as dynamic;
+ x323 = confuse(f323);
+ l323 = confuse(f323);
+ }
+
+ Expect.isTrue(m323 is F323);
+ Expect.isTrue(m323 is Function(int y, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m323) is F323);
+ // In checked mode, verifies the type.
+ x323 = m323;
+ l323 = m323;
+ x323 = confuse(m323);
+ l323 = confuse(m323);
+
+ }
+
+ void testF423() {
+ // int Function([int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f423 is F423);
+ Expect.isTrue(confuse(f423) is F423);
+ // In checked mode, verifies the type.
+ int Function([int x1]) Function<B extends core.int>(int x) l423;
+ // The static function f423 sets `T` to `int`.
+ if (!tIsBool) {
+ x423 = f423 as dynamic;
+ l423 = f423 as dynamic;
+ x423 = confuse(f423);
+ l423 = confuse(f423);
+ }
+
+ Expect.isTrue(m423 is F423);
+ Expect.isTrue(m423 is int Function([int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m423) is F423);
+ // In checked mode, verifies the type.
+ x423 = m423;
+ l423 = m423;
+ x423 = confuse(m423);
+ l423 = confuse(m423);
+
+ }
+
+ void testF523() {
+ // int Function({List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f523 is F523);
+ Expect.isTrue(confuse(f523) is F523);
+ // In checked mode, verifies the type.
+ int Function({List<Function> x}) Function<B extends core.int>(int x) l523;
+ // The static function f523 sets `T` to `int`.
+ if (!tIsBool) {
+ x523 = f523 as dynamic;
+ l523 = f523 as dynamic;
+ x523 = confuse(f523);
+ l523 = confuse(f523);
+ }
+
+ Expect.isTrue(m523 is F523);
+ Expect.isTrue(m523 is int Function({List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m523) is F523);
+ // In checked mode, verifies the type.
+ x523 = m523;
+ l523 = m523;
+ x523 = confuse(m523);
+ l523 = confuse(m523);
+
+ }
+
+ void testF623() {
+ // int Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f623 is F623);
+ Expect.isTrue(confuse(f623) is F623);
+ // In checked mode, verifies the type.
+ int Function() Function<B extends core.int>(int x) l623;
+ // The static function f623 sets `T` to `int`.
+ if (!tIsBool) {
+ x623 = f623 as dynamic;
+ l623 = f623 as dynamic;
+ x623 = confuse(f623);
+ l623 = confuse(f623);
+ }
+
+ Expect.isTrue(m623 is F623);
+ Expect.isTrue(m623 is int Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m623) is F623);
+ // In checked mode, verifies the type.
+ x623 = m623;
+ l623 = m623;
+ x623 = confuse(m623);
+ l623 = confuse(m623);
+
+ }
+
+ void testF723() {
+ // Function Function(int x1, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f723 is F723);
+ Expect.isTrue(confuse(f723) is F723);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l723;
+ // The static function f723 sets `T` to `int`.
+ if (!tIsBool) {
+ x723 = f723 as dynamic;
+ l723 = f723 as dynamic;
+ x723 = confuse(f723);
+ l723 = confuse(f723);
+ }
+
+ Expect.isTrue(m723 is F723);
+ Expect.isTrue(m723 is Function Function(int x1, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m723) is F723);
+ // In checked mode, verifies the type.
+ x723 = m723;
+ l723 = m723;
+ x723 = confuse(m723);
+ l723 = confuse(m723);
+
+ }
+
+ void testF823() {
+ // Function Function([List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f823 is F823);
+ Expect.isTrue(confuse(f823) is F823);
+ // In checked mode, verifies the type.
+ Function Function([List<T> x1]) Function<B extends core.int>(int x) l823;
+ // The static function f823 sets `T` to `int`.
+ if (!tIsBool) {
+ x823 = f823 as dynamic;
+ l823 = f823 as dynamic;
+ x823 = confuse(f823);
+ l823 = confuse(f823);
+ }
+
+ Expect.isTrue(m823 is F823);
+ Expect.isTrue(m823 is Function Function([List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m823) is F823);
+ // In checked mode, verifies the type.
+ x823 = m823;
+ l823 = m823;
+ x823 = confuse(m823);
+ l823 = confuse(m823);
+ if (!tIsBool) {
+ Expect.isTrue(f823 is F823<int>);
+ Expect.isFalse(f823 is F823<bool>);
+ Expect.isTrue(confuse(f823) is F823<int>);
+ Expect.isFalse(confuse(f823) is F823<bool>);
+ Expect.equals(tIsDynamic, m823 is F823<bool>);
+ Expect.equals(tIsDynamic, confuse(m823) is F823<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x823 = (f823 as dynamic); });
+ Expect.throws(() { x823 = confuse(f823); });
+ Function Function([List<T> x1]) Function<B extends core.int>(int x) l823;
+ Expect.throws(() { l823 = (f823 as dynamic); });
+ Expect.throws(() { l823 = confuse(f823); });
+ }
+ Function Function([List<T> x1]) Function<B extends core.int>(int x) l823 = m823;
+ // In checked mode, verifies the type.
+ x823 = m823;
+ x823 = confuse(m823);
+ }
+ }
+
+ void testF923() {
+ // List<Function> Function(int x, [Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f923 is F923);
+ Expect.isTrue(confuse(f923) is F923);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [Function x1]) Function<B extends core.int>(int x) l923;
+ // The static function f923 sets `T` to `int`.
+ if (!tIsBool) {
+ x923 = f923 as dynamic;
+ l923 = f923 as dynamic;
+ x923 = confuse(f923);
+ l923 = confuse(f923);
+ }
+
+ Expect.isTrue(m923 is F923);
+ Expect.isTrue(m923 is List<Function> Function(int x, [Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m923) is F923);
+ // In checked mode, verifies the type.
+ x923 = m923;
+ l923 = m923;
+ x923 = confuse(m923);
+ l923 = confuse(m923);
+
+ }
+
+ void testF1023() {
+ // List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1023 is F1023);
+ Expect.isTrue(confuse(f1023) is F1023);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l1023;
+ // The static function f1023 sets `T` to `int`.
+ if (!tIsBool) {
+ x1023 = f1023 as dynamic;
+ l1023 = f1023 as dynamic;
+ x1023 = confuse(f1023);
+ l1023 = confuse(f1023);
+ }
+
+ Expect.isTrue(m1023 is F1023);
+ Expect.isTrue(m1023 is List<Function> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1023) is F1023);
+ // In checked mode, verifies the type.
+ x1023 = m1023;
+ l1023 = m1023;
+ x1023 = confuse(m1023);
+ l1023 = confuse(m1023);
+
+ }
+
+ void testF1123() {
+ // core.List<core.int> Function([Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1123 is F1123);
+ Expect.isTrue(confuse(f1123) is F1123);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x]) Function<B extends core.int>(int x) l1123;
+ // The static function f1123 sets `T` to `int`.
+ if (!tIsBool) {
+ x1123 = f1123 as dynamic;
+ l1123 = f1123 as dynamic;
+ x1123 = confuse(f1123);
+ l1123 = confuse(f1123);
+ }
+
+ Expect.isTrue(m1123 is F1123);
+ Expect.isTrue(m1123 is core.List<core.int> Function([Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1123) is F1123);
+ // In checked mode, verifies the type.
+ x1123 = m1123;
+ l1123 = m1123;
+ x1123 = confuse(m1123);
+ l1123 = confuse(m1123);
+
+ }
+
+ void testF1223() {
+ // core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1223 is F1223);
+ Expect.isTrue(confuse(f1223) is F1223);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>(int x) l1223;
+ // The static function f1223 sets `T` to `int`.
+ if (!tIsBool) {
+ x1223 = f1223 as dynamic;
+ l1223 = f1223 as dynamic;
+ x1223 = confuse(f1223);
+ l1223 = confuse(f1223);
+ }
+
+ Expect.isTrue(m1223 is F1223);
+ Expect.isTrue(m1223 is core.List<core.int> Function(core.List<core.int> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1223) is F1223);
+ // In checked mode, verifies the type.
+ x1223 = m1223;
+ l1223 = m1223;
+ x1223 = confuse(m1223);
+ l1223 = confuse(m1223);
+
+ }
+
+ void testF1323() {
+ // List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1323 is F1323);
+ Expect.isTrue(confuse(f1323) is F1323);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x) l1323;
+ // The static function f1323 sets `T` to `int`.
+ if (!tIsBool) {
+ x1323 = f1323 as dynamic;
+ l1323 = f1323 as dynamic;
+ x1323 = confuse(f1323);
+ l1323 = confuse(f1323);
+ }
+
+ Expect.isTrue(m1323 is F1323);
+ Expect.isTrue(m1323 is List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1323) is F1323);
+ // In checked mode, verifies the type.
+ x1323 = m1323;
+ l1323 = m1323;
+ x1323 = confuse(m1323);
+ l1323 = confuse(m1323);
+ if (!tIsBool) {
+ Expect.isTrue(f1323 is F1323<int>);
+ Expect.isFalse(f1323 is F1323<bool>);
+ Expect.isTrue(confuse(f1323) is F1323<int>);
+ Expect.isFalse(confuse(f1323) is F1323<bool>);
+ Expect.equals(tIsDynamic, m1323 is F1323<bool>);
+ Expect.equals(tIsDynamic, confuse(m1323) is F1323<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1323 = (f1323 as dynamic); });
+ Expect.throws(() { x1323 = confuse(f1323); });
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x) l1323;
+ Expect.throws(() { l1323 = (f1323 as dynamic); });
+ Expect.throws(() { l1323 = confuse(f1323); });
+ }
+ List<T> Function(int x2, [int x3]) Function<B extends core.int>(int x) l1323 = m1323;
+ // In checked mode, verifies the type.
+ x1323 = m1323;
+ x1323 = confuse(m1323);
+ }
+ }
+
+ void testF1423() {
+ // List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1423 is F1423);
+ Expect.isTrue(confuse(f1423) is F1423);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l1423;
+ // The static function f1423 sets `T` to `int`.
+ if (!tIsBool) {
+ x1423 = f1423 as dynamic;
+ l1423 = f1423 as dynamic;
+ x1423 = confuse(f1423);
+ l1423 = confuse(f1423);
+ }
+
+ Expect.isTrue(m1423 is F1423);
+ Expect.isTrue(m1423 is List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1423) is F1423);
+ // In checked mode, verifies the type.
+ x1423 = m1423;
+ l1423 = m1423;
+ x1423 = confuse(m1423);
+ l1423 = confuse(m1423);
+ if (!tIsBool) {
+ Expect.isTrue(f1423 is F1423<int>);
+ Expect.isFalse(f1423 is F1423<bool>);
+ Expect.isTrue(confuse(f1423) is F1423<int>);
+ Expect.isFalse(confuse(f1423) is F1423<bool>);
+ Expect.equals(tIsDynamic, m1423 is F1423<bool>);
+ Expect.equals(tIsDynamic, confuse(m1423) is F1423<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1423 = (f1423 as dynamic); });
+ Expect.throws(() { x1423 = confuse(f1423); });
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l1423;
+ Expect.throws(() { l1423 = (f1423 as dynamic); });
+ Expect.throws(() { l1423 = confuse(f1423); });
+ }
+ List<T> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l1423 = m1423;
+ // In checked mode, verifies the type.
+ x1423 = m1423;
+ x1423 = confuse(m1423);
+ }
+ }
+
+ void testF1523() {
+ // Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1523 is F1523);
+ Expect.isTrue(confuse(f1523) is F1523);
+ // In checked mode, verifies the type.
+ Function(int x) Function<B extends core.int>(int x) l1523;
+ // The static function f1523 sets `T` to `int`.
+ if (!tIsBool) {
+ x1523 = f1523 as dynamic;
+ l1523 = f1523 as dynamic;
+ x1523 = confuse(f1523);
+ l1523 = confuse(f1523);
+ }
+
+ Expect.isTrue(m1523 is F1523);
+ Expect.isTrue(m1523 is Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1523) is F1523);
+ // In checked mode, verifies the type.
+ x1523 = m1523;
+ l1523 = m1523;
+ x1523 = confuse(m1523);
+ l1523 = confuse(m1523);
+
+ }
+
+ void testF1623() {
+ // Function(int y, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1623 is F1623);
+ Expect.isTrue(confuse(f1623) is F1623);
+ // In checked mode, verifies the type.
+ Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l1623;
+ // The static function f1623 sets `T` to `int`.
+ if (!tIsBool) {
+ x1623 = f1623 as dynamic;
+ l1623 = f1623 as dynamic;
+ x1623 = confuse(f1623);
+ l1623 = confuse(f1623);
+ }
+
+ Expect.isTrue(m1623 is F1623);
+ Expect.isTrue(m1623 is Function(int y, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1623) is F1623);
+ // In checked mode, verifies the type.
+ x1623 = m1623;
+ l1623 = m1623;
+ x1623 = confuse(m1623);
+ l1623 = confuse(m1623);
+
+ }
+
+ void testF1723() {
+ // Function(int x2, [List<T> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1723 is F1723);
+ Expect.isTrue(confuse(f1723) is F1723);
+ // In checked mode, verifies the type.
+ Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1723;
+ // The static function f1723 sets `T` to `int`.
+ if (!tIsBool) {
+ x1723 = f1723 as dynamic;
+ l1723 = f1723 as dynamic;
+ x1723 = confuse(f1723);
+ l1723 = confuse(f1723);
+ }
+
+ Expect.isTrue(m1723 is F1723);
+ Expect.isTrue(m1723 is Function(int x2, [List<T> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1723) is F1723);
+ // In checked mode, verifies the type.
+ x1723 = m1723;
+ l1723 = m1723;
+ x1723 = confuse(m1723);
+ l1723 = confuse(m1723);
+ if (!tIsBool) {
+ Expect.isTrue(f1723 is F1723<int>);
+ Expect.isFalse(f1723 is F1723<bool>);
+ Expect.isTrue(confuse(f1723) is F1723<int>);
+ Expect.isFalse(confuse(f1723) is F1723<bool>);
+ Expect.equals(tIsDynamic, m1723 is F1723<bool>);
+ Expect.equals(tIsDynamic, confuse(m1723) is F1723<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1723 = (f1723 as dynamic); });
+ Expect.throws(() { x1723 = confuse(f1723); });
+ Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1723;
+ Expect.throws(() { l1723 = (f1723 as dynamic); });
+ Expect.throws(() { l1723 = confuse(f1723); });
+ }
+ Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1723 = m1723;
+ // In checked mode, verifies the type.
+ x1723 = m1723;
+ x1723 = confuse(m1723);
+ }
+ }
+
+ void testF1823() {
+ // List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1823 is F1823);
+ Expect.isTrue(confuse(f1823) is F1823);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1823;
+ // The static function f1823 sets `T` to `int`.
+ if (!tIsBool) {
+ x1823 = f1823 as dynamic;
+ l1823 = f1823 as dynamic;
+ x1823 = confuse(f1823);
+ l1823 = confuse(f1823);
+ }
+
+ Expect.isTrue(m1823 is F1823);
+ Expect.isTrue(m1823 is List<Function> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1823) is F1823);
+ // In checked mode, verifies the type.
+ x1823 = m1823;
+ l1823 = m1823;
+ x1823 = confuse(m1823);
+ l1823 = confuse(m1823);
+
+ }
+
+ void testF1923() {
+ // Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1923 is F1923);
+ Expect.isTrue(confuse(f1923) is F1923);
+ // In checked mode, verifies the type.
+ Function<A>(List<T> x) Function<B extends core.int>(int x) l1923;
+ // The static function f1923 sets `T` to `int`.
+ if (!tIsBool) {
+ x1923 = f1923 as dynamic;
+ l1923 = f1923 as dynamic;
+ x1923 = confuse(f1923);
+ l1923 = confuse(f1923);
+ }
+
+ Expect.isTrue(m1923 is F1923);
+ Expect.isTrue(m1923 is Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1923) is F1923);
+ // In checked mode, verifies the type.
+ x1923 = m1923;
+ l1923 = m1923;
+ x1923 = confuse(m1923);
+ l1923 = confuse(m1923);
+ if (!tIsBool) {
+ Expect.isTrue(f1923 is F1923<int>);
+ Expect.isFalse(f1923 is F1923<bool>);
+ Expect.isTrue(confuse(f1923) is F1923<int>);
+ Expect.isFalse(confuse(f1923) is F1923<bool>);
+ Expect.equals(tIsDynamic, m1923 is F1923<bool>);
+ Expect.equals(tIsDynamic, confuse(m1923) is F1923<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1923 = (f1923 as dynamic); });
+ Expect.throws(() { x1923 = confuse(f1923); });
+ Function<A>(List<T> x) Function<B extends core.int>(int x) l1923;
+ Expect.throws(() { l1923 = (f1923 as dynamic); });
+ Expect.throws(() { l1923 = confuse(f1923); });
+ }
+ Function<A>(List<T> x) Function<B extends core.int>(int x) l1923 = m1923;
+ // In checked mode, verifies the type.
+ x1923 = m1923;
+ x1923 = confuse(m1923);
+ }
+ }
+
+ void testF2023() {
+ // B Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2023 is F2023);
+ Expect.isTrue(confuse(f2023) is F2023);
+ // In checked mode, verifies the type.
+ B Function(core.List<core.int> x) Function<B extends core.int>(int x) l2023;
+ // The static function f2023 sets `T` to `int`.
+ if (!tIsBool) {
+ x2023 = f2023 as dynamic;
+ l2023 = f2023 as dynamic;
+ x2023 = confuse(f2023);
+ l2023 = confuse(f2023);
+ }
+
+ Expect.isTrue(m2023 is F2023);
+ Expect.isTrue(m2023 is B Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2023) is F2023);
+ // In checked mode, verifies the type.
+ x2023 = m2023;
+ l2023 = m2023;
+ x2023 = confuse(m2023);
+ l2023 = confuse(m2023);
+
+ }
+
+
+}
+
+class C24<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, [List<Function> x]) x24;
+ List<Function> Function([Function x]) x124;
+ List<T> Function(int x) x224;
+ Function(List<T> x) x324;
+ int Function(int x1, [int x2]) Function() x424;
+ int Function(int x0, {List<Function> x}) Function() x524;
+ Function Function(int x) Function() x624;
+ Function Function(int y, [List<Function> x]) Function() x724;
+ Function Function(int x1, [List<T> x2]) Function() x824;
+ List<Function> Function({Function x}) Function() x924;
+ List<Function> Function(List<T> x) Function() x1024;
+ core.List<core.int> Function(int x0, [Function x]) Function() x1124;
+ core.List<core.int> Function([core.List<core.int> x1]) Function() x1224;
+ List<T> Function(int x, [int x2]) Function() x1324;
+ List<T> Function(int y, {List<Function> x}) Function() x1424;
+ Function([int x]) Function() x1524;
+ Function(List<Function> x0) Function() x1624;
+ Function(int x, [List<T> x2]) Function() x1724;
+ List<Function> Function<A>(List<T> x) Function() x1824;
+ Function<A>() Function() x1924;
+ B Function(List<T> x) Function<B extends core.int>() x2024;
+
+
+ C24({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m24(int x0, [List<Function> x]) => null;
+ List<Function> m124([Function x]) => null;
+ List<T> m224(int x) => null;
+ m324(List<T> x) => null;
+ int Function(int x0, [int x1]) m424() => null;
+ int Function(int x0, {List<Function> x}) m524() => null;
+ Function Function(int x) m624() => null;
+ Function Function(int y, [List<Function> x]) m724() => null;
+ Function Function(int x0, [List<T> x1]) m824() => null;
+ List<Function> Function({Function x}) m924() => null;
+ List<Function> Function(List<T> x) m1024() => null;
+ core.List<core.int> Function(int x0, [Function x]) m1124() => null;
+ core.List<core.int> Function([core.List<core.int> x0]) m1224() => null;
+ List<T> Function(int x, [int x0]) m1324() => null;
+ List<T> Function(int y, {List<Function> x}) m1424() => null;
+ Function([int x]) m1524() => null;
+ Function(List<Function> x0) m1624() => null;
+ Function(int x, [List<T> x0]) m1724() => null;
+ List<Function> Function<A>(List<T> x) m1824() => null;
+ Function<A>() m1924() => null;
+ B Function(List<T> x) m2024<B extends core.int>() => null;
+
+
+ runTests() {
+ testF24();
+ testF124();
+ testF224();
+ testF324();
+ testF424();
+ testF524();
+ testF624();
+ testF724();
+ testF824();
+ testF924();
+ testF1024();
+ testF1124();
+ testF1224();
+ testF1324();
+ testF1424();
+ testF1524();
+ testF1624();
+ testF1724();
+ testF1824();
+ testF1924();
+ testF2024();
+ }
+
+ void testF24() {
+ // int Function(int x0, [List<Function> x])
+ Expect.isTrue(f24 is F24);
+ Expect.isTrue(confuse(f24) is F24);
+ // In checked mode, verifies the type.
+ int Function(int x0, [List<Function> x]) l24;
+ // The static function f24 sets `T` to `int`.
+ if (!tIsBool) {
+ x24 = f24 as dynamic;
+ l24 = f24 as dynamic;
+ x24 = confuse(f24);
+ l24 = confuse(f24);
+ }
+
+ Expect.isTrue(m24 is F24);
+ Expect.isTrue(m24 is int Function(int x0, [List<Function> x]));
+ Expect.isTrue(confuse(m24) is F24);
+ // In checked mode, verifies the type.
+ x24 = m24;
+ l24 = m24;
+ x24 = confuse(m24);
+ l24 = confuse(m24);
+
+ }
+
+ void testF124() {
+ // List<Function> Function([Function x])
+ Expect.isTrue(f124 is F124);
+ Expect.isTrue(confuse(f124) is F124);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x]) l124;
+ // The static function f124 sets `T` to `int`.
+ if (!tIsBool) {
+ x124 = f124 as dynamic;
+ l124 = f124 as dynamic;
+ x124 = confuse(f124);
+ l124 = confuse(f124);
+ }
+
+ Expect.isTrue(m124 is F124);
+ Expect.isTrue(m124 is List<Function> Function([Function x]));
+ Expect.isTrue(confuse(m124) is F124);
+ // In checked mode, verifies the type.
+ x124 = m124;
+ l124 = m124;
+ x124 = confuse(m124);
+ l124 = confuse(m124);
+
+ }
+
+ void testF224() {
+ // List<T> Function(int x)
+ Expect.isTrue(f224 is F224);
+ Expect.isTrue(confuse(f224) is F224);
+ // In checked mode, verifies the type.
+ List<T> Function(int x) l224;
+ // The static function f224 sets `T` to `int`.
+ if (!tIsBool) {
+ x224 = f224 as dynamic;
+ l224 = f224 as dynamic;
+ x224 = confuse(f224);
+ l224 = confuse(f224);
+ }
+
+ Expect.isTrue(m224 is F224);
+ Expect.isTrue(m224 is List<T> Function(int x));
+ Expect.isTrue(confuse(m224) is F224);
+ // In checked mode, verifies the type.
+ x224 = m224;
+ l224 = m224;
+ x224 = confuse(m224);
+ l224 = confuse(m224);
+ if (!tIsBool) {
+ Expect.isTrue(f224 is F224<int>);
+ Expect.isFalse(f224 is F224<bool>);
+ Expect.isTrue(confuse(f224) is F224<int>);
+ Expect.isFalse(confuse(f224) is F224<bool>);
+ Expect.equals(tIsDynamic, m224 is F224<bool>);
+ Expect.equals(tIsDynamic, confuse(m224) is F224<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x224 = (f224 as dynamic); });
+ Expect.throws(() { x224 = confuse(f224); });
+ List<T> Function(int x) l224;
+ Expect.throws(() { l224 = (f224 as dynamic); });
+ Expect.throws(() { l224 = confuse(f224); });
+ }
+ List<T> Function(int x) l224 = m224;
+ // In checked mode, verifies the type.
+ x224 = m224;
+ x224 = confuse(m224);
+ }
+ }
+
+ void testF324() {
+ // Function(List<T> x)
+ Expect.isTrue(f324 is F324);
+ Expect.isTrue(confuse(f324) is F324);
+ // In checked mode, verifies the type.
+ Function(List<T> x) l324;
+ // The static function f324 sets `T` to `int`.
+ if (!tIsBool) {
+ x324 = f324 as dynamic;
+ l324 = f324 as dynamic;
+ x324 = confuse(f324);
+ l324 = confuse(f324);
+ }
+
+ Expect.isTrue(m324 is F324);
+ Expect.isTrue(m324 is Function(List<T> x));
+ Expect.isTrue(confuse(m324) is F324);
+ // In checked mode, verifies the type.
+ x324 = m324;
+ l324 = m324;
+ x324 = confuse(m324);
+ l324 = confuse(m324);
+ if (!tIsBool) {
+ Expect.isTrue(f324 is F324<int>);
+ Expect.isFalse(f324 is F324<bool>);
+ Expect.isTrue(confuse(f324) is F324<int>);
+ Expect.isFalse(confuse(f324) is F324<bool>);
+ Expect.equals(tIsDynamic, m324 is F324<bool>);
+ Expect.equals(tIsDynamic, confuse(m324) is F324<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x324 = (f324 as dynamic); });
+ Expect.throws(() { x324 = confuse(f324); });
+ Function(List<T> x) l324;
+ Expect.throws(() { l324 = (f324 as dynamic); });
+ Expect.throws(() { l324 = confuse(f324); });
+ }
+ Function(List<T> x) l324 = m324;
+ // In checked mode, verifies the type.
+ x324 = m324;
+ x324 = confuse(m324);
+ }
+ }
+
+ void testF424() {
+ // int Function(int x1, [int x2]) Function()
+ Expect.isTrue(f424 is F424);
+ Expect.isTrue(confuse(f424) is F424);
+ // In checked mode, verifies the type.
+ int Function(int x1, [int x2]) Function() l424;
+ // The static function f424 sets `T` to `int`.
+ if (!tIsBool) {
+ x424 = f424 as dynamic;
+ l424 = f424 as dynamic;
+ x424 = confuse(f424);
+ l424 = confuse(f424);
+ }
+
+ Expect.isTrue(m424 is F424);
+ Expect.isTrue(m424 is int Function(int x1, [int x2]) Function());
+ Expect.isTrue(confuse(m424) is F424);
+ // In checked mode, verifies the type.
+ x424 = m424;
+ l424 = m424;
+ x424 = confuse(m424);
+ l424 = confuse(m424);
+
+ }
+
+ void testF524() {
+ // int Function(int x0, {List<Function> x}) Function()
+ Expect.isTrue(f524 is F524);
+ Expect.isTrue(confuse(f524) is F524);
+ // In checked mode, verifies the type.
+ int Function(int x0, {List<Function> x}) Function() l524;
+ // The static function f524 sets `T` to `int`.
+ if (!tIsBool) {
+ x524 = f524 as dynamic;
+ l524 = f524 as dynamic;
+ x524 = confuse(f524);
+ l524 = confuse(f524);
+ }
+
+ Expect.isTrue(m524 is F524);
+ Expect.isTrue(m524 is int Function(int x0, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m524) is F524);
+ // In checked mode, verifies the type.
+ x524 = m524;
+ l524 = m524;
+ x524 = confuse(m524);
+ l524 = confuse(m524);
+
+ }
+
+ void testF624() {
+ // Function Function(int x) Function()
+ Expect.isTrue(f624 is F624);
+ Expect.isTrue(confuse(f624) is F624);
+ // In checked mode, verifies the type.
+ Function Function(int x) Function() l624;
+ // The static function f624 sets `T` to `int`.
+ if (!tIsBool) {
+ x624 = f624 as dynamic;
+ l624 = f624 as dynamic;
+ x624 = confuse(f624);
+ l624 = confuse(f624);
+ }
+
+ Expect.isTrue(m624 is F624);
+ Expect.isTrue(m624 is Function Function(int x) Function());
+ Expect.isTrue(confuse(m624) is F624);
+ // In checked mode, verifies the type.
+ x624 = m624;
+ l624 = m624;
+ x624 = confuse(m624);
+ l624 = confuse(m624);
+
+ }
+
+ void testF724() {
+ // Function Function(int y, [List<Function> x]) Function()
+ Expect.isTrue(f724 is F724);
+ Expect.isTrue(confuse(f724) is F724);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<Function> x]) Function() l724;
+ // The static function f724 sets `T` to `int`.
+ if (!tIsBool) {
+ x724 = f724 as dynamic;
+ l724 = f724 as dynamic;
+ x724 = confuse(f724);
+ l724 = confuse(f724);
+ }
+
+ Expect.isTrue(m724 is F724);
+ Expect.isTrue(m724 is Function Function(int y, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m724) is F724);
+ // In checked mode, verifies the type.
+ x724 = m724;
+ l724 = m724;
+ x724 = confuse(m724);
+ l724 = confuse(m724);
+
+ }
+
+ void testF824() {
+ // Function Function(int x1, [List<T> x2]) Function()
+ Expect.isTrue(f824 is F824);
+ Expect.isTrue(confuse(f824) is F824);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<T> x2]) Function() l824;
+ // The static function f824 sets `T` to `int`.
+ if (!tIsBool) {
+ x824 = f824 as dynamic;
+ l824 = f824 as dynamic;
+ x824 = confuse(f824);
+ l824 = confuse(f824);
+ }
+
+ Expect.isTrue(m824 is F824);
+ Expect.isTrue(m824 is Function Function(int x1, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m824) is F824);
+ // In checked mode, verifies the type.
+ x824 = m824;
+ l824 = m824;
+ x824 = confuse(m824);
+ l824 = confuse(m824);
+ if (!tIsBool) {
+ Expect.isTrue(f824 is F824<int>);
+ Expect.isFalse(f824 is F824<bool>);
+ Expect.isTrue(confuse(f824) is F824<int>);
+ Expect.isFalse(confuse(f824) is F824<bool>);
+ Expect.equals(tIsDynamic, m824 is F824<bool>);
+ Expect.equals(tIsDynamic, confuse(m824) is F824<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x824 = (f824 as dynamic); });
+ Expect.throws(() { x824 = confuse(f824); });
+ Function Function(int x1, [List<T> x2]) Function() l824;
+ Expect.throws(() { l824 = (f824 as dynamic); });
+ Expect.throws(() { l824 = confuse(f824); });
+ }
+ Function Function(int x1, [List<T> x2]) Function() l824 = m824;
+ // In checked mode, verifies the type.
+ x824 = m824;
+ x824 = confuse(m824);
+ }
+ }
+
+ void testF924() {
+ // List<Function> Function({Function x}) Function()
+ Expect.isTrue(f924 is F924);
+ Expect.isTrue(confuse(f924) is F924);
+ // In checked mode, verifies the type.
+ List<Function> Function({Function x}) Function() l924;
+ // The static function f924 sets `T` to `int`.
+ if (!tIsBool) {
+ x924 = f924 as dynamic;
+ l924 = f924 as dynamic;
+ x924 = confuse(f924);
+ l924 = confuse(f924);
+ }
+
+ Expect.isTrue(m924 is F924);
+ Expect.isTrue(m924 is List<Function> Function({Function x}) Function());
+ Expect.isTrue(confuse(m924) is F924);
+ // In checked mode, verifies the type.
+ x924 = m924;
+ l924 = m924;
+ x924 = confuse(m924);
+ l924 = confuse(m924);
+
+ }
+
+ void testF1024() {
+ // List<Function> Function(List<T> x) Function()
+ Expect.isTrue(f1024 is F1024);
+ Expect.isTrue(confuse(f1024) is F1024);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x) Function() l1024;
+ // The static function f1024 sets `T` to `int`.
+ if (!tIsBool) {
+ x1024 = f1024 as dynamic;
+ l1024 = f1024 as dynamic;
+ x1024 = confuse(f1024);
+ l1024 = confuse(f1024);
+ }
+
+ Expect.isTrue(m1024 is F1024);
+ Expect.isTrue(m1024 is List<Function> Function(List<T> x) Function());
+ Expect.isTrue(confuse(m1024) is F1024);
+ // In checked mode, verifies the type.
+ x1024 = m1024;
+ l1024 = m1024;
+ x1024 = confuse(m1024);
+ l1024 = confuse(m1024);
+ if (!tIsBool) {
+ Expect.isTrue(f1024 is F1024<int>);
+ Expect.isFalse(f1024 is F1024<bool>);
+ Expect.isTrue(confuse(f1024) is F1024<int>);
+ Expect.isFalse(confuse(f1024) is F1024<bool>);
+ Expect.equals(tIsDynamic, m1024 is F1024<bool>);
+ Expect.equals(tIsDynamic, confuse(m1024) is F1024<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1024 = (f1024 as dynamic); });
+ Expect.throws(() { x1024 = confuse(f1024); });
+ List<Function> Function(List<T> x) Function() l1024;
+ Expect.throws(() { l1024 = (f1024 as dynamic); });
+ Expect.throws(() { l1024 = confuse(f1024); });
+ }
+ List<Function> Function(List<T> x) Function() l1024 = m1024;
+ // In checked mode, verifies the type.
+ x1024 = m1024;
+ x1024 = confuse(m1024);
+ }
+ }
+
+ void testF1124() {
+ // core.List<core.int> Function(int x0, [Function x]) Function()
+ Expect.isTrue(f1124 is F1124);
+ Expect.isTrue(confuse(f1124) is F1124);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [Function x]) Function() l1124;
+ // The static function f1124 sets `T` to `int`.
+ if (!tIsBool) {
+ x1124 = f1124 as dynamic;
+ l1124 = f1124 as dynamic;
+ x1124 = confuse(f1124);
+ l1124 = confuse(f1124);
+ }
+
+ Expect.isTrue(m1124 is F1124);
+ Expect.isTrue(m1124 is core.List<core.int> Function(int x0, [Function x]) Function());
+ Expect.isTrue(confuse(m1124) is F1124);
+ // In checked mode, verifies the type.
+ x1124 = m1124;
+ l1124 = m1124;
+ x1124 = confuse(m1124);
+ l1124 = confuse(m1124);
+
+ }
+
+ void testF1224() {
+ // core.List<core.int> Function([core.List<core.int> x1]) Function()
+ Expect.isTrue(f1224 is F1224);
+ Expect.isTrue(confuse(f1224) is F1224);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x1]) Function() l1224;
+ // The static function f1224 sets `T` to `int`.
+ if (!tIsBool) {
+ x1224 = f1224 as dynamic;
+ l1224 = f1224 as dynamic;
+ x1224 = confuse(f1224);
+ l1224 = confuse(f1224);
+ }
+
+ Expect.isTrue(m1224 is F1224);
+ Expect.isTrue(m1224 is core.List<core.int> Function([core.List<core.int> x1]) Function());
+ Expect.isTrue(confuse(m1224) is F1224);
+ // In checked mode, verifies the type.
+ x1224 = m1224;
+ l1224 = m1224;
+ x1224 = confuse(m1224);
+ l1224 = confuse(m1224);
+
+ }
+
+ void testF1324() {
+ // List<T> Function(int x, [int x2]) Function()
+ Expect.isTrue(f1324 is F1324);
+ Expect.isTrue(confuse(f1324) is F1324);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [int x2]) Function() l1324;
+ // The static function f1324 sets `T` to `int`.
+ if (!tIsBool) {
+ x1324 = f1324 as dynamic;
+ l1324 = f1324 as dynamic;
+ x1324 = confuse(f1324);
+ l1324 = confuse(f1324);
+ }
+
+ Expect.isTrue(m1324 is F1324);
+ Expect.isTrue(m1324 is List<T> Function(int x, [int x2]) Function());
+ Expect.isTrue(confuse(m1324) is F1324);
+ // In checked mode, verifies the type.
+ x1324 = m1324;
+ l1324 = m1324;
+ x1324 = confuse(m1324);
+ l1324 = confuse(m1324);
+ if (!tIsBool) {
+ Expect.isTrue(f1324 is F1324<int>);
+ Expect.isFalse(f1324 is F1324<bool>);
+ Expect.isTrue(confuse(f1324) is F1324<int>);
+ Expect.isFalse(confuse(f1324) is F1324<bool>);
+ Expect.equals(tIsDynamic, m1324 is F1324<bool>);
+ Expect.equals(tIsDynamic, confuse(m1324) is F1324<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1324 = (f1324 as dynamic); });
+ Expect.throws(() { x1324 = confuse(f1324); });
+ List<T> Function(int x, [int x2]) Function() l1324;
+ Expect.throws(() { l1324 = (f1324 as dynamic); });
+ Expect.throws(() { l1324 = confuse(f1324); });
+ }
+ List<T> Function(int x, [int x2]) Function() l1324 = m1324;
+ // In checked mode, verifies the type.
+ x1324 = m1324;
+ x1324 = confuse(m1324);
+ }
+ }
+
+ void testF1424() {
+ // List<T> Function(int y, {List<Function> x}) Function()
+ Expect.isTrue(f1424 is F1424);
+ Expect.isTrue(confuse(f1424) is F1424);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<Function> x}) Function() l1424;
+ // The static function f1424 sets `T` to `int`.
+ if (!tIsBool) {
+ x1424 = f1424 as dynamic;
+ l1424 = f1424 as dynamic;
+ x1424 = confuse(f1424);
+ l1424 = confuse(f1424);
+ }
+
+ Expect.isTrue(m1424 is F1424);
+ Expect.isTrue(m1424 is List<T> Function(int y, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m1424) is F1424);
+ // In checked mode, verifies the type.
+ x1424 = m1424;
+ l1424 = m1424;
+ x1424 = confuse(m1424);
+ l1424 = confuse(m1424);
+ if (!tIsBool) {
+ Expect.isTrue(f1424 is F1424<int>);
+ Expect.isFalse(f1424 is F1424<bool>);
+ Expect.isTrue(confuse(f1424) is F1424<int>);
+ Expect.isFalse(confuse(f1424) is F1424<bool>);
+ Expect.equals(tIsDynamic, m1424 is F1424<bool>);
+ Expect.equals(tIsDynamic, confuse(m1424) is F1424<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1424 = (f1424 as dynamic); });
+ Expect.throws(() { x1424 = confuse(f1424); });
+ List<T> Function(int y, {List<Function> x}) Function() l1424;
+ Expect.throws(() { l1424 = (f1424 as dynamic); });
+ Expect.throws(() { l1424 = confuse(f1424); });
+ }
+ List<T> Function(int y, {List<Function> x}) Function() l1424 = m1424;
+ // In checked mode, verifies the type.
+ x1424 = m1424;
+ x1424 = confuse(m1424);
+ }
+ }
+
+ void testF1524() {
+ // Function([int x]) Function()
+ Expect.isTrue(f1524 is F1524);
+ Expect.isTrue(confuse(f1524) is F1524);
+ // In checked mode, verifies the type.
+ Function([int x]) Function() l1524;
+ // The static function f1524 sets `T` to `int`.
+ if (!tIsBool) {
+ x1524 = f1524 as dynamic;
+ l1524 = f1524 as dynamic;
+ x1524 = confuse(f1524);
+ l1524 = confuse(f1524);
+ }
+
+ Expect.isTrue(m1524 is F1524);
+ Expect.isTrue(m1524 is Function([int x]) Function());
+ Expect.isTrue(confuse(m1524) is F1524);
+ // In checked mode, verifies the type.
+ x1524 = m1524;
+ l1524 = m1524;
+ x1524 = confuse(m1524);
+ l1524 = confuse(m1524);
+
+ }
+
+ void testF1624() {
+ // Function(List<Function> x0) Function()
+ Expect.isTrue(f1624 is F1624);
+ Expect.isTrue(confuse(f1624) is F1624);
+ // In checked mode, verifies the type.
+ Function(List<Function> x0) Function() l1624;
+ // The static function f1624 sets `T` to `int`.
+ if (!tIsBool) {
+ x1624 = f1624 as dynamic;
+ l1624 = f1624 as dynamic;
+ x1624 = confuse(f1624);
+ l1624 = confuse(f1624);
+ }
+
+ Expect.isTrue(m1624 is F1624);
+ Expect.isTrue(m1624 is Function(List<Function> x0) Function());
+ Expect.isTrue(confuse(m1624) is F1624);
+ // In checked mode, verifies the type.
+ x1624 = m1624;
+ l1624 = m1624;
+ x1624 = confuse(m1624);
+ l1624 = confuse(m1624);
+
+ }
+
+ void testF1724() {
+ // Function(int x, [List<T> x2]) Function()
+ Expect.isTrue(f1724 is F1724);
+ Expect.isTrue(confuse(f1724) is F1724);
+ // In checked mode, verifies the type.
+ Function(int x, [List<T> x2]) Function() l1724;
+ // The static function f1724 sets `T` to `int`.
+ if (!tIsBool) {
+ x1724 = f1724 as dynamic;
+ l1724 = f1724 as dynamic;
+ x1724 = confuse(f1724);
+ l1724 = confuse(f1724);
+ }
+
+ Expect.isTrue(m1724 is F1724);
+ Expect.isTrue(m1724 is Function(int x, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1724) is F1724);
+ // In checked mode, verifies the type.
+ x1724 = m1724;
+ l1724 = m1724;
+ x1724 = confuse(m1724);
+ l1724 = confuse(m1724);
+ if (!tIsBool) {
+ Expect.isTrue(f1724 is F1724<int>);
+ Expect.isFalse(f1724 is F1724<bool>);
+ Expect.isTrue(confuse(f1724) is F1724<int>);
+ Expect.isFalse(confuse(f1724) is F1724<bool>);
+ Expect.equals(tIsDynamic, m1724 is F1724<bool>);
+ Expect.equals(tIsDynamic, confuse(m1724) is F1724<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1724 = (f1724 as dynamic); });
+ Expect.throws(() { x1724 = confuse(f1724); });
+ Function(int x, [List<T> x2]) Function() l1724;
+ Expect.throws(() { l1724 = (f1724 as dynamic); });
+ Expect.throws(() { l1724 = confuse(f1724); });
+ }
+ Function(int x, [List<T> x2]) Function() l1724 = m1724;
+ // In checked mode, verifies the type.
+ x1724 = m1724;
+ x1724 = confuse(m1724);
+ }
+ }
+
+ void testF1824() {
+ // List<Function> Function<A>(List<T> x) Function()
+ Expect.isTrue(f1824 is F1824);
+ Expect.isTrue(confuse(f1824) is F1824);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<T> x) Function() l1824;
+ // The static function f1824 sets `T` to `int`.
+ if (!tIsBool) {
+ x1824 = f1824 as dynamic;
+ l1824 = f1824 as dynamic;
+ x1824 = confuse(f1824);
+ l1824 = confuse(f1824);
+ }
+
+ Expect.isTrue(m1824 is F1824);
+ Expect.isTrue(m1824 is List<Function> Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1824) is F1824);
+ // In checked mode, verifies the type.
+ x1824 = m1824;
+ l1824 = m1824;
+ x1824 = confuse(m1824);
+ l1824 = confuse(m1824);
+ if (!tIsBool) {
+ Expect.isTrue(f1824 is F1824<int>);
+ Expect.isFalse(f1824 is F1824<bool>);
+ Expect.isTrue(confuse(f1824) is F1824<int>);
+ Expect.isFalse(confuse(f1824) is F1824<bool>);
+ Expect.equals(tIsDynamic, m1824 is F1824<bool>);
+ Expect.equals(tIsDynamic, confuse(m1824) is F1824<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1824 = (f1824 as dynamic); });
+ Expect.throws(() { x1824 = confuse(f1824); });
+ List<Function> Function<A>(List<T> x) Function() l1824;
+ Expect.throws(() { l1824 = (f1824 as dynamic); });
+ Expect.throws(() { l1824 = confuse(f1824); });
+ }
+ List<Function> Function<A>(List<T> x) Function() l1824 = m1824;
+ // In checked mode, verifies the type.
+ x1824 = m1824;
+ x1824 = confuse(m1824);
+ }
+ }
+
+ void testF1924() {
+ // Function<A>() Function()
+ Expect.isTrue(f1924 is F1924);
+ Expect.isTrue(confuse(f1924) is F1924);
+ // In checked mode, verifies the type.
+ Function<A>() Function() l1924;
+ // The static function f1924 sets `T` to `int`.
+ if (!tIsBool) {
+ x1924 = f1924 as dynamic;
+ l1924 = f1924 as dynamic;
+ x1924 = confuse(f1924);
+ l1924 = confuse(f1924);
+ }
+
+ Expect.isTrue(m1924 is F1924);
+ Expect.isTrue(m1924 is Function<A>() Function());
+ Expect.isTrue(confuse(m1924) is F1924);
+ // In checked mode, verifies the type.
+ x1924 = m1924;
+ l1924 = m1924;
+ x1924 = confuse(m1924);
+ l1924 = confuse(m1924);
+
+ }
+
+ void testF2024() {
+ // B Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f2024 is F2024);
+ Expect.isTrue(confuse(f2024) is F2024);
+ // In checked mode, verifies the type.
+ B Function(List<T> x) Function<B extends core.int>() l2024;
+ // The static function f2024 sets `T` to `int`.
+ if (!tIsBool) {
+ x2024 = f2024 as dynamic;
+ l2024 = f2024 as dynamic;
+ x2024 = confuse(f2024);
+ l2024 = confuse(f2024);
+ }
+
+ Expect.isTrue(m2024 is F2024);
+ Expect.isTrue(m2024 is B Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m2024) is F2024);
+ // In checked mode, verifies the type.
+ x2024 = m2024;
+ l2024 = m2024;
+ x2024 = confuse(m2024);
+ l2024 = confuse(m2024);
+ if (!tIsBool) {
+ Expect.isTrue(f2024 is F2024<int>);
+ Expect.isFalse(f2024 is F2024<bool>);
+ Expect.isTrue(confuse(f2024) is F2024<int>);
+ Expect.isFalse(confuse(f2024) is F2024<bool>);
+ Expect.equals(tIsDynamic, m2024 is F2024<bool>);
+ Expect.equals(tIsDynamic, confuse(m2024) is F2024<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x2024 = (f2024 as dynamic); });
+ Expect.throws(() { x2024 = confuse(f2024); });
+ B Function(List<T> x) Function<B extends core.int>() l2024;
+ Expect.throws(() { l2024 = (f2024 as dynamic); });
+ Expect.throws(() { l2024 = confuse(f2024); });
+ }
+ B Function(List<T> x) Function<B extends core.int>() l2024 = m2024;
+ // In checked mode, verifies the type.
+ x2024 = m2024;
+ x2024 = confuse(m2024);
+ }
+ }
+
+
+}
+
+class C25<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, [List<Function> x]) x25;
+ List<Function> Function(int x0, [Function x]) x125;
+ List<T> Function([int x]) x225;
+ Function([List<T> x]) x325;
+ int Function(int x2, [int x3]) Function(int x) x425;
+ int Function(int x1, {List<Function> x}) Function(int x) x525;
+ Function Function(int x) Function(int x) x625;
+ Function Function(int y, [List<Function> x]) Function(int x) x725;
+ Function Function(int x2, [List<T> x3]) Function(int x) x825;
+ List<Function> Function({Function x}) Function(int x) x925;
+ List<Function> Function(List<T> x) Function(int x) x1025;
+ core.List<core.int> Function(int x1, [Function x]) Function(int x) x1125;
+ core.List<core.int> Function([core.List<core.int> x1]) Function(int x) x1225;
+ List<T> Function(int x, [int x1]) Function(int x) x1325;
+ List<T> Function(int y, {List<Function> x}) Function(int x) x1425;
+ Function([int x]) Function(int x) x1525;
+ Function(List<Function> x1) Function(int x) x1625;
+ Function(int x, [List<T> x1]) Function(int x) x1725;
+ List<Function> Function<A>(List<T> x) Function(int x) x1825;
+ Function<A>() Function(int x) x1925;
+ B Function(List<T> x) Function<B extends core.int>(int x) x2025;
+
+
+ C25({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m25(int y, [List<Function> x]) => null;
+ List<Function> m125(int x0, [Function x]) => null;
+ List<T> m225([int x]) => null;
+ m325([List<T> x]) => null;
+ int Function(int x0, [int x1]) m425(int x) => null;
+ int Function(int x0, {List<Function> x}) m525(int x) => null;
+ Function Function(int x) m625(int x) => null;
+ Function Function(int y, [List<Function> x]) m725(int x) => null;
+ Function Function(int x0, [List<T> x1]) m825(int x) => null;
+ List<Function> Function({Function x}) m925(int x) => null;
+ List<Function> Function(List<T> x) m1025(int x) => null;
+ core.List<core.int> Function(int x0, [Function x]) m1125(int x) => null;
+ core.List<core.int> Function([core.List<core.int> x0]) m1225(int x) => null;
+ List<T> Function(int x, [int x0]) m1325(int x) => null;
+ List<T> Function(int y, {List<Function> x}) m1425(int x) => null;
+ Function([int x]) m1525(int x) => null;
+ Function(List<Function> x0) m1625(int x) => null;
+ Function(int x, [List<T> x0]) m1725(int x) => null;
+ List<Function> Function<A>(List<T> x) m1825(int x) => null;
+ Function<A>() m1925(int x) => null;
+ B Function(List<T> x) m2025<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF25();
+ testF125();
+ testF225();
+ testF325();
+ testF425();
+ testF525();
+ testF625();
+ testF725();
+ testF825();
+ testF925();
+ testF1025();
+ testF1125();
+ testF1225();
+ testF1325();
+ testF1425();
+ testF1525();
+ testF1625();
+ testF1725();
+ testF1825();
+ testF1925();
+ testF2025();
+ }
+
+ void testF25() {
+ // int Function(int y, [List<Function> x])
+ Expect.isTrue(f25 is F25);
+ Expect.isTrue(confuse(f25) is F25);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<Function> x]) l25;
+ // The static function f25 sets `T` to `int`.
+ if (!tIsBool) {
+ x25 = f25 as dynamic;
+ l25 = f25 as dynamic;
+ x25 = confuse(f25);
+ l25 = confuse(f25);
+ }
+
+ Expect.isTrue(m25 is F25);
+ Expect.isTrue(m25 is int Function(int y, [List<Function> x]));
+ Expect.isTrue(confuse(m25) is F25);
+ // In checked mode, verifies the type.
+ x25 = m25;
+ l25 = m25;
+ x25 = confuse(m25);
+ l25 = confuse(m25);
+
+ }
+
+ void testF125() {
+ // List<Function> Function(int x0, [Function x])
+ Expect.isTrue(f125 is F125);
+ Expect.isTrue(confuse(f125) is F125);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [Function x]) l125;
+ // The static function f125 sets `T` to `int`.
+ if (!tIsBool) {
+ x125 = f125 as dynamic;
+ l125 = f125 as dynamic;
+ x125 = confuse(f125);
+ l125 = confuse(f125);
+ }
+
+ Expect.isTrue(m125 is F125);
+ Expect.isTrue(m125 is List<Function> Function(int x0, [Function x]));
+ Expect.isTrue(confuse(m125) is F125);
+ // In checked mode, verifies the type.
+ x125 = m125;
+ l125 = m125;
+ x125 = confuse(m125);
+ l125 = confuse(m125);
+
+ }
+
+ void testF225() {
+ // List<T> Function([int x])
+ Expect.isTrue(f225 is F225);
+ Expect.isTrue(confuse(f225) is F225);
+ // In checked mode, verifies the type.
+ List<T> Function([int x]) l225;
+ // The static function f225 sets `T` to `int`.
+ if (!tIsBool) {
+ x225 = f225 as dynamic;
+ l225 = f225 as dynamic;
+ x225 = confuse(f225);
+ l225 = confuse(f225);
+ }
+
+ Expect.isTrue(m225 is F225);
+ Expect.isTrue(m225 is List<T> Function([int x]));
+ Expect.isTrue(confuse(m225) is F225);
+ // In checked mode, verifies the type.
+ x225 = m225;
+ l225 = m225;
+ x225 = confuse(m225);
+ l225 = confuse(m225);
+ if (!tIsBool) {
+ Expect.isTrue(f225 is F225<int>);
+ Expect.isFalse(f225 is F225<bool>);
+ Expect.isTrue(confuse(f225) is F225<int>);
+ Expect.isFalse(confuse(f225) is F225<bool>);
+ Expect.equals(tIsDynamic, m225 is F225<bool>);
+ Expect.equals(tIsDynamic, confuse(m225) is F225<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x225 = (f225 as dynamic); });
+ Expect.throws(() { x225 = confuse(f225); });
+ List<T> Function([int x]) l225;
+ Expect.throws(() { l225 = (f225 as dynamic); });
+ Expect.throws(() { l225 = confuse(f225); });
+ }
+ List<T> Function([int x]) l225 = m225;
+ // In checked mode, verifies the type.
+ x225 = m225;
+ x225 = confuse(m225);
+ }
+ }
+
+ void testF325() {
+ // Function([List<T> x])
+ Expect.isTrue(f325 is F325);
+ Expect.isTrue(confuse(f325) is F325);
+ // In checked mode, verifies the type.
+ Function([List<T> x]) l325;
+ // The static function f325 sets `T` to `int`.
+ if (!tIsBool) {
+ x325 = f325 as dynamic;
+ l325 = f325 as dynamic;
+ x325 = confuse(f325);
+ l325 = confuse(f325);
+ }
+
+ Expect.isTrue(m325 is F325);
+ Expect.isTrue(m325 is Function([List<T> x]));
+ Expect.isTrue(confuse(m325) is F325);
+ // In checked mode, verifies the type.
+ x325 = m325;
+ l325 = m325;
+ x325 = confuse(m325);
+ l325 = confuse(m325);
+ if (!tIsBool) {
+ Expect.isTrue(f325 is F325<int>);
+ Expect.isFalse(f325 is F325<bool>);
+ Expect.isTrue(confuse(f325) is F325<int>);
+ Expect.isFalse(confuse(f325) is F325<bool>);
+ Expect.equals(tIsDynamic, m325 is F325<bool>);
+ Expect.equals(tIsDynamic, confuse(m325) is F325<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x325 = (f325 as dynamic); });
+ Expect.throws(() { x325 = confuse(f325); });
+ Function([List<T> x]) l325;
+ Expect.throws(() { l325 = (f325 as dynamic); });
+ Expect.throws(() { l325 = confuse(f325); });
+ }
+ Function([List<T> x]) l325 = m325;
+ // In checked mode, verifies the type.
+ x325 = m325;
+ x325 = confuse(m325);
+ }
+ }
+
+ void testF425() {
+ // int Function(int x2, [int x3]) Function(int x)
+ Expect.isTrue(f425 is F425);
+ Expect.isTrue(confuse(f425) is F425);
+ // In checked mode, verifies the type.
+ int Function(int x2, [int x3]) Function(int x) l425;
+ // The static function f425 sets `T` to `int`.
+ if (!tIsBool) {
+ x425 = f425 as dynamic;
+ l425 = f425 as dynamic;
+ x425 = confuse(f425);
+ l425 = confuse(f425);
+ }
+
+ Expect.isTrue(m425 is F425);
+ Expect.isTrue(m425 is int Function(int x2, [int x3]) Function(int x));
+ Expect.isTrue(confuse(m425) is F425);
+ // In checked mode, verifies the type.
+ x425 = m425;
+ l425 = m425;
+ x425 = confuse(m425);
+ l425 = confuse(m425);
+
+ }
+
+ void testF525() {
+ // int Function(int x1, {List<Function> x}) Function(int x)
+ Expect.isTrue(f525 is F525);
+ Expect.isTrue(confuse(f525) is F525);
+ // In checked mode, verifies the type.
+ int Function(int x1, {List<Function> x}) Function(int x) l525;
+ // The static function f525 sets `T` to `int`.
+ if (!tIsBool) {
+ x525 = f525 as dynamic;
+ l525 = f525 as dynamic;
+ x525 = confuse(f525);
+ l525 = confuse(f525);
+ }
+
+ Expect.isTrue(m525 is F525);
+ Expect.isTrue(m525 is int Function(int x1, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m525) is F525);
+ // In checked mode, verifies the type.
+ x525 = m525;
+ l525 = m525;
+ x525 = confuse(m525);
+ l525 = confuse(m525);
+
+ }
+
+ void testF625() {
+ // Function Function(int x) Function(int x)
+ Expect.isTrue(f625 is F625);
+ Expect.isTrue(confuse(f625) is F625);
+ // In checked mode, verifies the type.
+ Function Function(int x) Function(int x) l625;
+ // The static function f625 sets `T` to `int`.
+ if (!tIsBool) {
+ x625 = f625 as dynamic;
+ l625 = f625 as dynamic;
+ x625 = confuse(f625);
+ l625 = confuse(f625);
+ }
+
+ Expect.isTrue(m625 is F625);
+ Expect.isTrue(m625 is Function Function(int x) Function(int x));
+ Expect.isTrue(confuse(m625) is F625);
+ // In checked mode, verifies the type.
+ x625 = m625;
+ l625 = m625;
+ x625 = confuse(m625);
+ l625 = confuse(m625);
+
+ }
+
+ void testF725() {
+ // Function Function(int y, [List<Function> x]) Function(int x)
+ Expect.isTrue(f725 is F725);
+ Expect.isTrue(confuse(f725) is F725);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<Function> x]) Function(int x) l725;
+ // The static function f725 sets `T` to `int`.
+ if (!tIsBool) {
+ x725 = f725 as dynamic;
+ l725 = f725 as dynamic;
+ x725 = confuse(f725);
+ l725 = confuse(f725);
+ }
+
+ Expect.isTrue(m725 is F725);
+ Expect.isTrue(m725 is Function Function(int y, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m725) is F725);
+ // In checked mode, verifies the type.
+ x725 = m725;
+ l725 = m725;
+ x725 = confuse(m725);
+ l725 = confuse(m725);
+
+ }
+
+ void testF825() {
+ // Function Function(int x2, [List<T> x3]) Function(int x)
+ Expect.isTrue(f825 is F825);
+ Expect.isTrue(confuse(f825) is F825);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [List<T> x3]) Function(int x) l825;
+ // The static function f825 sets `T` to `int`.
+ if (!tIsBool) {
+ x825 = f825 as dynamic;
+ l825 = f825 as dynamic;
+ x825 = confuse(f825);
+ l825 = confuse(f825);
+ }
+
+ Expect.isTrue(m825 is F825);
+ Expect.isTrue(m825 is Function Function(int x2, [List<T> x3]) Function(int x));
+ Expect.isTrue(confuse(m825) is F825);
+ // In checked mode, verifies the type.
+ x825 = m825;
+ l825 = m825;
+ x825 = confuse(m825);
+ l825 = confuse(m825);
+ if (!tIsBool) {
+ Expect.isTrue(f825 is F825<int>);
+ Expect.isFalse(f825 is F825<bool>);
+ Expect.isTrue(confuse(f825) is F825<int>);
+ Expect.isFalse(confuse(f825) is F825<bool>);
+ Expect.equals(tIsDynamic, m825 is F825<bool>);
+ Expect.equals(tIsDynamic, confuse(m825) is F825<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x825 = (f825 as dynamic); });
+ Expect.throws(() { x825 = confuse(f825); });
+ Function Function(int x2, [List<T> x3]) Function(int x) l825;
+ Expect.throws(() { l825 = (f825 as dynamic); });
+ Expect.throws(() { l825 = confuse(f825); });
+ }
+ Function Function(int x2, [List<T> x3]) Function(int x) l825 = m825;
+ // In checked mode, verifies the type.
+ x825 = m825;
+ x825 = confuse(m825);
+ }
+ }
+
+ void testF925() {
+ // List<Function> Function({Function x}) Function(int x)
+ Expect.isTrue(f925 is F925);
+ Expect.isTrue(confuse(f925) is F925);
+ // In checked mode, verifies the type.
+ List<Function> Function({Function x}) Function(int x) l925;
+ // The static function f925 sets `T` to `int`.
+ if (!tIsBool) {
+ x925 = f925 as dynamic;
+ l925 = f925 as dynamic;
+ x925 = confuse(f925);
+ l925 = confuse(f925);
+ }
+
+ Expect.isTrue(m925 is F925);
+ Expect.isTrue(m925 is List<Function> Function({Function x}) Function(int x));
+ Expect.isTrue(confuse(m925) is F925);
+ // In checked mode, verifies the type.
+ x925 = m925;
+ l925 = m925;
+ x925 = confuse(m925);
+ l925 = confuse(m925);
+
+ }
+
+ void testF1025() {
+ // List<Function> Function(List<T> x) Function(int x)
+ Expect.isTrue(f1025 is F1025);
+ Expect.isTrue(confuse(f1025) is F1025);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x) Function(int x) l1025;
+ // The static function f1025 sets `T` to `int`.
+ if (!tIsBool) {
+ x1025 = f1025 as dynamic;
+ l1025 = f1025 as dynamic;
+ x1025 = confuse(f1025);
+ l1025 = confuse(f1025);
+ }
+
+ Expect.isTrue(m1025 is F1025);
+ Expect.isTrue(m1025 is List<Function> Function(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1025) is F1025);
+ // In checked mode, verifies the type.
+ x1025 = m1025;
+ l1025 = m1025;
+ x1025 = confuse(m1025);
+ l1025 = confuse(m1025);
+ if (!tIsBool) {
+ Expect.isTrue(f1025 is F1025<int>);
+ Expect.isFalse(f1025 is F1025<bool>);
+ Expect.isTrue(confuse(f1025) is F1025<int>);
+ Expect.isFalse(confuse(f1025) is F1025<bool>);
+ Expect.equals(tIsDynamic, m1025 is F1025<bool>);
+ Expect.equals(tIsDynamic, confuse(m1025) is F1025<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1025 = (f1025 as dynamic); });
+ Expect.throws(() { x1025 = confuse(f1025); });
+ List<Function> Function(List<T> x) Function(int x) l1025;
+ Expect.throws(() { l1025 = (f1025 as dynamic); });
+ Expect.throws(() { l1025 = confuse(f1025); });
+ }
+ List<Function> Function(List<T> x) Function(int x) l1025 = m1025;
+ // In checked mode, verifies the type.
+ x1025 = m1025;
+ x1025 = confuse(m1025);
+ }
+ }
+
+ void testF1125() {
+ // core.List<core.int> Function(int x1, [Function x]) Function(int x)
+ Expect.isTrue(f1125 is F1125);
+ Expect.isTrue(confuse(f1125) is F1125);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [Function x]) Function(int x) l1125;
+ // The static function f1125 sets `T` to `int`.
+ if (!tIsBool) {
+ x1125 = f1125 as dynamic;
+ l1125 = f1125 as dynamic;
+ x1125 = confuse(f1125);
+ l1125 = confuse(f1125);
+ }
+
+ Expect.isTrue(m1125 is F1125);
+ Expect.isTrue(m1125 is core.List<core.int> Function(int x1, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m1125) is F1125);
+ // In checked mode, verifies the type.
+ x1125 = m1125;
+ l1125 = m1125;
+ x1125 = confuse(m1125);
+ l1125 = confuse(m1125);
+
+ }
+
+ void testF1225() {
+ // core.List<core.int> Function([core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1225 is F1225);
+ Expect.isTrue(confuse(f1225) is F1225);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x1]) Function(int x) l1225;
+ // The static function f1225 sets `T` to `int`.
+ if (!tIsBool) {
+ x1225 = f1225 as dynamic;
+ l1225 = f1225 as dynamic;
+ x1225 = confuse(f1225);
+ l1225 = confuse(f1225);
+ }
+
+ Expect.isTrue(m1225 is F1225);
+ Expect.isTrue(m1225 is core.List<core.int> Function([core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1225) is F1225);
+ // In checked mode, verifies the type.
+ x1225 = m1225;
+ l1225 = m1225;
+ x1225 = confuse(m1225);
+ l1225 = confuse(m1225);
+
+ }
+
+ void testF1325() {
+ // List<T> Function(int x, [int x1]) Function(int x)
+ Expect.isTrue(f1325 is F1325);
+ Expect.isTrue(confuse(f1325) is F1325);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [int x1]) Function(int x) l1325;
+ // The static function f1325 sets `T` to `int`.
+ if (!tIsBool) {
+ x1325 = f1325 as dynamic;
+ l1325 = f1325 as dynamic;
+ x1325 = confuse(f1325);
+ l1325 = confuse(f1325);
+ }
+
+ Expect.isTrue(m1325 is F1325);
+ Expect.isTrue(m1325 is List<T> Function(int x, [int x1]) Function(int x));
+ Expect.isTrue(confuse(m1325) is F1325);
+ // In checked mode, verifies the type.
+ x1325 = m1325;
+ l1325 = m1325;
+ x1325 = confuse(m1325);
+ l1325 = confuse(m1325);
+ if (!tIsBool) {
+ Expect.isTrue(f1325 is F1325<int>);
+ Expect.isFalse(f1325 is F1325<bool>);
+ Expect.isTrue(confuse(f1325) is F1325<int>);
+ Expect.isFalse(confuse(f1325) is F1325<bool>);
+ Expect.equals(tIsDynamic, m1325 is F1325<bool>);
+ Expect.equals(tIsDynamic, confuse(m1325) is F1325<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1325 = (f1325 as dynamic); });
+ Expect.throws(() { x1325 = confuse(f1325); });
+ List<T> Function(int x, [int x1]) Function(int x) l1325;
+ Expect.throws(() { l1325 = (f1325 as dynamic); });
+ Expect.throws(() { l1325 = confuse(f1325); });
+ }
+ List<T> Function(int x, [int x1]) Function(int x) l1325 = m1325;
+ // In checked mode, verifies the type.
+ x1325 = m1325;
+ x1325 = confuse(m1325);
+ }
+ }
+
+ void testF1425() {
+ // List<T> Function(int y, {List<Function> x}) Function(int x)
+ Expect.isTrue(f1425 is F1425);
+ Expect.isTrue(confuse(f1425) is F1425);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<Function> x}) Function(int x) l1425;
+ // The static function f1425 sets `T` to `int`.
+ if (!tIsBool) {
+ x1425 = f1425 as dynamic;
+ l1425 = f1425 as dynamic;
+ x1425 = confuse(f1425);
+ l1425 = confuse(f1425);
+ }
+
+ Expect.isTrue(m1425 is F1425);
+ Expect.isTrue(m1425 is List<T> Function(int y, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1425) is F1425);
+ // In checked mode, verifies the type.
+ x1425 = m1425;
+ l1425 = m1425;
+ x1425 = confuse(m1425);
+ l1425 = confuse(m1425);
+ if (!tIsBool) {
+ Expect.isTrue(f1425 is F1425<int>);
+ Expect.isFalse(f1425 is F1425<bool>);
+ Expect.isTrue(confuse(f1425) is F1425<int>);
+ Expect.isFalse(confuse(f1425) is F1425<bool>);
+ Expect.equals(tIsDynamic, m1425 is F1425<bool>);
+ Expect.equals(tIsDynamic, confuse(m1425) is F1425<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1425 = (f1425 as dynamic); });
+ Expect.throws(() { x1425 = confuse(f1425); });
+ List<T> Function(int y, {List<Function> x}) Function(int x) l1425;
+ Expect.throws(() { l1425 = (f1425 as dynamic); });
+ Expect.throws(() { l1425 = confuse(f1425); });
+ }
+ List<T> Function(int y, {List<Function> x}) Function(int x) l1425 = m1425;
+ // In checked mode, verifies the type.
+ x1425 = m1425;
+ x1425 = confuse(m1425);
+ }
+ }
+
+ void testF1525() {
+ // Function([int x]) Function(int x)
+ Expect.isTrue(f1525 is F1525);
+ Expect.isTrue(confuse(f1525) is F1525);
+ // In checked mode, verifies the type.
+ Function([int x]) Function(int x) l1525;
+ // The static function f1525 sets `T` to `int`.
+ if (!tIsBool) {
+ x1525 = f1525 as dynamic;
+ l1525 = f1525 as dynamic;
+ x1525 = confuse(f1525);
+ l1525 = confuse(f1525);
+ }
+
+ Expect.isTrue(m1525 is F1525);
+ Expect.isTrue(m1525 is Function([int x]) Function(int x));
+ Expect.isTrue(confuse(m1525) is F1525);
+ // In checked mode, verifies the type.
+ x1525 = m1525;
+ l1525 = m1525;
+ x1525 = confuse(m1525);
+ l1525 = confuse(m1525);
+
+ }
+
+ void testF1625() {
+ // Function(List<Function> x1) Function(int x)
+ Expect.isTrue(f1625 is F1625);
+ Expect.isTrue(confuse(f1625) is F1625);
+ // In checked mode, verifies the type.
+ Function(List<Function> x1) Function(int x) l1625;
+ // The static function f1625 sets `T` to `int`.
+ if (!tIsBool) {
+ x1625 = f1625 as dynamic;
+ l1625 = f1625 as dynamic;
+ x1625 = confuse(f1625);
+ l1625 = confuse(f1625);
+ }
+
+ Expect.isTrue(m1625 is F1625);
+ Expect.isTrue(m1625 is Function(List<Function> x1) Function(int x));
+ Expect.isTrue(confuse(m1625) is F1625);
+ // In checked mode, verifies the type.
+ x1625 = m1625;
+ l1625 = m1625;
+ x1625 = confuse(m1625);
+ l1625 = confuse(m1625);
+
+ }
+
+ void testF1725() {
+ // Function(int x, [List<T> x1]) Function(int x)
+ Expect.isTrue(f1725 is F1725);
+ Expect.isTrue(confuse(f1725) is F1725);
+ // In checked mode, verifies the type.
+ Function(int x, [List<T> x1]) Function(int x) l1725;
+ // The static function f1725 sets `T` to `int`.
+ if (!tIsBool) {
+ x1725 = f1725 as dynamic;
+ l1725 = f1725 as dynamic;
+ x1725 = confuse(f1725);
+ l1725 = confuse(f1725);
+ }
+
+ Expect.isTrue(m1725 is F1725);
+ Expect.isTrue(m1725 is Function(int x, [List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1725) is F1725);
+ // In checked mode, verifies the type.
+ x1725 = m1725;
+ l1725 = m1725;
+ x1725 = confuse(m1725);
+ l1725 = confuse(m1725);
+ if (!tIsBool) {
+ Expect.isTrue(f1725 is F1725<int>);
+ Expect.isFalse(f1725 is F1725<bool>);
+ Expect.isTrue(confuse(f1725) is F1725<int>);
+ Expect.isFalse(confuse(f1725) is F1725<bool>);
+ Expect.equals(tIsDynamic, m1725 is F1725<bool>);
+ Expect.equals(tIsDynamic, confuse(m1725) is F1725<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1725 = (f1725 as dynamic); });
+ Expect.throws(() { x1725 = confuse(f1725); });
+ Function(int x, [List<T> x1]) Function(int x) l1725;
+ Expect.throws(() { l1725 = (f1725 as dynamic); });
+ Expect.throws(() { l1725 = confuse(f1725); });
+ }
+ Function(int x, [List<T> x1]) Function(int x) l1725 = m1725;
+ // In checked mode, verifies the type.
+ x1725 = m1725;
+ x1725 = confuse(m1725);
+ }
+ }
+
+ void testF1825() {
+ // List<Function> Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1825 is F1825);
+ Expect.isTrue(confuse(f1825) is F1825);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<T> x) Function(int x) l1825;
+ // The static function f1825 sets `T` to `int`.
+ if (!tIsBool) {
+ x1825 = f1825 as dynamic;
+ l1825 = f1825 as dynamic;
+ x1825 = confuse(f1825);
+ l1825 = confuse(f1825);
+ }
+
+ Expect.isTrue(m1825 is F1825);
+ Expect.isTrue(m1825 is List<Function> Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1825) is F1825);
+ // In checked mode, verifies the type.
+ x1825 = m1825;
+ l1825 = m1825;
+ x1825 = confuse(m1825);
+ l1825 = confuse(m1825);
+ if (!tIsBool) {
+ Expect.isTrue(f1825 is F1825<int>);
+ Expect.isFalse(f1825 is F1825<bool>);
+ Expect.isTrue(confuse(f1825) is F1825<int>);
+ Expect.isFalse(confuse(f1825) is F1825<bool>);
+ Expect.equals(tIsDynamic, m1825 is F1825<bool>);
+ Expect.equals(tIsDynamic, confuse(m1825) is F1825<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1825 = (f1825 as dynamic); });
+ Expect.throws(() { x1825 = confuse(f1825); });
+ List<Function> Function<A>(List<T> x) Function(int x) l1825;
+ Expect.throws(() { l1825 = (f1825 as dynamic); });
+ Expect.throws(() { l1825 = confuse(f1825); });
+ }
+ List<Function> Function<A>(List<T> x) Function(int x) l1825 = m1825;
+ // In checked mode, verifies the type.
+ x1825 = m1825;
+ x1825 = confuse(m1825);
+ }
+ }
+
+ void testF1925() {
+ // Function<A>() Function(int x)
+ Expect.isTrue(f1925 is F1925);
+ Expect.isTrue(confuse(f1925) is F1925);
+ // In checked mode, verifies the type.
+ Function<A>() Function(int x) l1925;
+ // The static function f1925 sets `T` to `int`.
+ if (!tIsBool) {
+ x1925 = f1925 as dynamic;
+ l1925 = f1925 as dynamic;
+ x1925 = confuse(f1925);
+ l1925 = confuse(f1925);
+ }
+
+ Expect.isTrue(m1925 is F1925);
+ Expect.isTrue(m1925 is Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1925) is F1925);
+ // In checked mode, verifies the type.
+ x1925 = m1925;
+ l1925 = m1925;
+ x1925 = confuse(m1925);
+ l1925 = confuse(m1925);
+
+ }
+
+ void testF2025() {
+ // B Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f2025 is F2025);
+ Expect.isTrue(confuse(f2025) is F2025);
+ // In checked mode, verifies the type.
+ B Function(List<T> x) Function<B extends core.int>(int x) l2025;
+ // The static function f2025 sets `T` to `int`.
+ if (!tIsBool) {
+ x2025 = f2025 as dynamic;
+ l2025 = f2025 as dynamic;
+ x2025 = confuse(f2025);
+ l2025 = confuse(f2025);
+ }
+
+ Expect.isTrue(m2025 is F2025);
+ Expect.isTrue(m2025 is B Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2025) is F2025);
+ // In checked mode, verifies the type.
+ x2025 = m2025;
+ l2025 = m2025;
+ x2025 = confuse(m2025);
+ l2025 = confuse(m2025);
+ if (!tIsBool) {
+ Expect.isTrue(f2025 is F2025<int>);
+ Expect.isFalse(f2025 is F2025<bool>);
+ Expect.isTrue(confuse(f2025) is F2025<int>);
+ Expect.isFalse(confuse(f2025) is F2025<bool>);
+ Expect.equals(tIsDynamic, m2025 is F2025<bool>);
+ Expect.equals(tIsDynamic, confuse(m2025) is F2025<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x2025 = (f2025 as dynamic); });
+ Expect.throws(() { x2025 = confuse(f2025); });
+ B Function(List<T> x) Function<B extends core.int>(int x) l2025;
+ Expect.throws(() { l2025 = (f2025 as dynamic); });
+ Expect.throws(() { l2025 = confuse(f2025); });
+ }
+ B Function(List<T> x) Function<B extends core.int>(int x) l2025 = m2025;
+ // In checked mode, verifies the type.
+ x2025 = m2025;
+ x2025 = confuse(m2025);
+ }
+ }
+
+
+}
+
+class C26<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(List<Function> x0) x26;
+ List<Function> Function(int y, [Function x]) x126;
+ List<T> Function(int x0, [int x]) x226;
+ Function(int x0, [List<T> x]) x326;
+ int Function(int x2, [int x3]) Function<B extends core.int>() x426;
+ int Function(int x1, {List<Function> x}) Function<B extends core.int>() x526;
+ Function Function(int x) Function<B extends core.int>() x626;
+ Function Function(int y, [List<Function> x]) Function<B extends core.int>() x726;
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>() x826;
+ List<Function> Function({Function x}) Function<B extends core.int>() x926;
+ List<Function> Function(List<T> x) Function<B extends core.int>() x1026;
+ core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>() x1126;
+ core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>() x1226;
+ List<T> Function(int x, [int x1]) Function<B extends core.int>() x1326;
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>() x1426;
+ Function([int x]) Function<B extends core.int>() x1526;
+ Function(List<Function> x1) Function<B extends core.int>() x1626;
+ Function(int x, [List<T> x1]) Function<B extends core.int>() x1726;
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>() x1826;
+ Function<A>() Function<B extends core.int>() x1926;
+ B Function() Function<B extends core.int>() x2026;
+
+
+ C26({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m26(List<Function> x0) => null;
+ List<Function> m126(int y, [Function x]) => null;
+ List<T> m226(int x0, [int x]) => null;
+ m326(int x0, [List<T> x]) => null;
+ int Function(int x0, [int x1]) m426<B extends core.int>() => null;
+ int Function(int x0, {List<Function> x}) m526<B extends core.int>() => null;
+ Function Function(int x) m626<B extends core.int>() => null;
+ Function Function(int y, [List<Function> x]) m726<B extends core.int>() => null;
+ Function Function(int x0, [List<T> x1]) m826<B extends core.int>() => null;
+ List<Function> Function({Function x}) m926<B extends core.int>() => null;
+ List<Function> Function(List<T> x) m1026<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [Function x]) m1126<B extends core.int>() => null;
+ core.List<core.int> Function([core.List<core.int> x0]) m1226<B extends core.int>() => null;
+ List<T> Function(int x, [int x0]) m1326<B extends core.int>() => null;
+ List<T> Function(int y, {List<Function> x}) m1426<B extends core.int>() => null;
+ Function([int x]) m1526<B extends core.int>() => null;
+ Function(List<Function> x0) m1626<B extends core.int>() => null;
+ Function(int x, [List<T> x0]) m1726<B extends core.int>() => null;
+ List<Function> Function<A>(List<T> x) m1826<B extends core.int>() => null;
+ Function<A>() m1926<B extends core.int>() => null;
+ B Function() m2026<B extends core.int>() => null;
+
+
+ runTests() {
+ testF26();
+ testF126();
+ testF226();
+ testF326();
+ testF426();
+ testF526();
+ testF626();
+ testF726();
+ testF826();
+ testF926();
+ testF1026();
+ testF1126();
+ testF1226();
+ testF1326();
+ testF1426();
+ testF1526();
+ testF1626();
+ testF1726();
+ testF1826();
+ testF1926();
+ testF2026();
+ }
+
+ void testF26() {
+ // int Function(List<Function> x0)
+ Expect.isTrue(f26 is F26);
+ Expect.isTrue(confuse(f26) is F26);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x0) l26;
+ // The static function f26 sets `T` to `int`.
+ if (!tIsBool) {
+ x26 = f26 as dynamic;
+ l26 = f26 as dynamic;
+ x26 = confuse(f26);
+ l26 = confuse(f26);
+ }
+
+ Expect.isTrue(m26 is F26);
+ Expect.isTrue(m26 is int Function(List<Function> x0));
+ Expect.isTrue(confuse(m26) is F26);
+ // In checked mode, verifies the type.
+ x26 = m26;
+ l26 = m26;
+ x26 = confuse(m26);
+ l26 = confuse(m26);
+
+ }
+
+ void testF126() {
+ // List<Function> Function(int y, [Function x])
+ Expect.isTrue(f126 is F126);
+ Expect.isTrue(confuse(f126) is F126);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [Function x]) l126;
+ // The static function f126 sets `T` to `int`.
+ if (!tIsBool) {
+ x126 = f126 as dynamic;
+ l126 = f126 as dynamic;
+ x126 = confuse(f126);
+ l126 = confuse(f126);
+ }
+
+ Expect.isTrue(m126 is F126);
+ Expect.isTrue(m126 is List<Function> Function(int y, [Function x]));
+ Expect.isTrue(confuse(m126) is F126);
+ // In checked mode, verifies the type.
+ x126 = m126;
+ l126 = m126;
+ x126 = confuse(m126);
+ l126 = confuse(m126);
+
+ }
+
+ void testF226() {
+ // List<T> Function(int x0, [int x])
+ Expect.isTrue(f226 is F226);
+ Expect.isTrue(confuse(f226) is F226);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [int x]) l226;
+ // The static function f226 sets `T` to `int`.
+ if (!tIsBool) {
+ x226 = f226 as dynamic;
+ l226 = f226 as dynamic;
+ x226 = confuse(f226);
+ l226 = confuse(f226);
+ }
+
+ Expect.isTrue(m226 is F226);
+ Expect.isTrue(m226 is List<T> Function(int x0, [int x]));
+ Expect.isTrue(confuse(m226) is F226);
+ // In checked mode, verifies the type.
+ x226 = m226;
+ l226 = m226;
+ x226 = confuse(m226);
+ l226 = confuse(m226);
+ if (!tIsBool) {
+ Expect.isTrue(f226 is F226<int>);
+ Expect.isFalse(f226 is F226<bool>);
+ Expect.isTrue(confuse(f226) is F226<int>);
+ Expect.isFalse(confuse(f226) is F226<bool>);
+ Expect.equals(tIsDynamic, m226 is F226<bool>);
+ Expect.equals(tIsDynamic, confuse(m226) is F226<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x226 = (f226 as dynamic); });
+ Expect.throws(() { x226 = confuse(f226); });
+ List<T> Function(int x0, [int x]) l226;
+ Expect.throws(() { l226 = (f226 as dynamic); });
+ Expect.throws(() { l226 = confuse(f226); });
+ }
+ List<T> Function(int x0, [int x]) l226 = m226;
+ // In checked mode, verifies the type.
+ x226 = m226;
+ x226 = confuse(m226);
+ }
+ }
+
+ void testF326() {
+ // Function(int x0, [List<T> x])
+ Expect.isTrue(f326 is F326);
+ Expect.isTrue(confuse(f326) is F326);
+ // In checked mode, verifies the type.
+ Function(int x0, [List<T> x]) l326;
+ // The static function f326 sets `T` to `int`.
+ if (!tIsBool) {
+ x326 = f326 as dynamic;
+ l326 = f326 as dynamic;
+ x326 = confuse(f326);
+ l326 = confuse(f326);
+ }
+
+ Expect.isTrue(m326 is F326);
+ Expect.isTrue(m326 is Function(int x0, [List<T> x]));
+ Expect.isTrue(confuse(m326) is F326);
+ // In checked mode, verifies the type.
+ x326 = m326;
+ l326 = m326;
+ x326 = confuse(m326);
+ l326 = confuse(m326);
+ if (!tIsBool) {
+ Expect.isTrue(f326 is F326<int>);
+ Expect.isFalse(f326 is F326<bool>);
+ Expect.isTrue(confuse(f326) is F326<int>);
+ Expect.isFalse(confuse(f326) is F326<bool>);
+ Expect.equals(tIsDynamic, m326 is F326<bool>);
+ Expect.equals(tIsDynamic, confuse(m326) is F326<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x326 = (f326 as dynamic); });
+ Expect.throws(() { x326 = confuse(f326); });
+ Function(int x0, [List<T> x]) l326;
+ Expect.throws(() { l326 = (f326 as dynamic); });
+ Expect.throws(() { l326 = confuse(f326); });
+ }
+ Function(int x0, [List<T> x]) l326 = m326;
+ // In checked mode, verifies the type.
+ x326 = m326;
+ x326 = confuse(m326);
+ }
+ }
+
+ void testF426() {
+ // int Function(int x2, [int x3]) Function<B extends core.int>()
+ Expect.isTrue(f426 is F426);
+ Expect.isTrue(confuse(f426) is F426);
+ // In checked mode, verifies the type.
+ int Function(int x2, [int x3]) Function<B extends core.int>() l426;
+ // The static function f426 sets `T` to `int`.
+ if (!tIsBool) {
+ x426 = f426 as dynamic;
+ l426 = f426 as dynamic;
+ x426 = confuse(f426);
+ l426 = confuse(f426);
+ }
+
+ Expect.isTrue(m426 is F426);
+ Expect.isTrue(m426 is int Function(int x2, [int x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m426) is F426);
+ // In checked mode, verifies the type.
+ x426 = m426;
+ l426 = m426;
+ x426 = confuse(m426);
+ l426 = confuse(m426);
+
+ }
+
+ void testF526() {
+ // int Function(int x1, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f526 is F526);
+ Expect.isTrue(confuse(f526) is F526);
+ // In checked mode, verifies the type.
+ int Function(int x1, {List<Function> x}) Function<B extends core.int>() l526;
+ // The static function f526 sets `T` to `int`.
+ if (!tIsBool) {
+ x526 = f526 as dynamic;
+ l526 = f526 as dynamic;
+ x526 = confuse(f526);
+ l526 = confuse(f526);
+ }
+
+ Expect.isTrue(m526 is F526);
+ Expect.isTrue(m526 is int Function(int x1, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m526) is F526);
+ // In checked mode, verifies the type.
+ x526 = m526;
+ l526 = m526;
+ x526 = confuse(m526);
+ l526 = confuse(m526);
+
+ }
+
+ void testF626() {
+ // Function Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f626 is F626);
+ Expect.isTrue(confuse(f626) is F626);
+ // In checked mode, verifies the type.
+ Function Function(int x) Function<B extends core.int>() l626;
+ // The static function f626 sets `T` to `int`.
+ if (!tIsBool) {
+ x626 = f626 as dynamic;
+ l626 = f626 as dynamic;
+ x626 = confuse(f626);
+ l626 = confuse(f626);
+ }
+
+ Expect.isTrue(m626 is F626);
+ Expect.isTrue(m626 is Function Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m626) is F626);
+ // In checked mode, verifies the type.
+ x626 = m626;
+ l626 = m626;
+ x626 = confuse(m626);
+ l626 = confuse(m626);
+
+ }
+
+ void testF726() {
+ // Function Function(int y, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f726 is F726);
+ Expect.isTrue(confuse(f726) is F726);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<Function> x]) Function<B extends core.int>() l726;
+ // The static function f726 sets `T` to `int`.
+ if (!tIsBool) {
+ x726 = f726 as dynamic;
+ l726 = f726 as dynamic;
+ x726 = confuse(f726);
+ l726 = confuse(f726);
+ }
+
+ Expect.isTrue(m726 is F726);
+ Expect.isTrue(m726 is Function Function(int y, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m726) is F726);
+ // In checked mode, verifies the type.
+ x726 = m726;
+ l726 = m726;
+ x726 = confuse(m726);
+ l726 = confuse(m726);
+
+ }
+
+ void testF826() {
+ // Function Function(int x2, [List<T> x3]) Function<B extends core.int>()
+ Expect.isTrue(f826 is F826);
+ Expect.isTrue(confuse(f826) is F826);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>() l826;
+ // The static function f826 sets `T` to `int`.
+ if (!tIsBool) {
+ x826 = f826 as dynamic;
+ l826 = f826 as dynamic;
+ x826 = confuse(f826);
+ l826 = confuse(f826);
+ }
+
+ Expect.isTrue(m826 is F826);
+ Expect.isTrue(m826 is Function Function(int x2, [List<T> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m826) is F826);
+ // In checked mode, verifies the type.
+ x826 = m826;
+ l826 = m826;
+ x826 = confuse(m826);
+ l826 = confuse(m826);
+ if (!tIsBool) {
+ Expect.isTrue(f826 is F826<int>);
+ Expect.isFalse(f826 is F826<bool>);
+ Expect.isTrue(confuse(f826) is F826<int>);
+ Expect.isFalse(confuse(f826) is F826<bool>);
+ Expect.equals(tIsDynamic, m826 is F826<bool>);
+ Expect.equals(tIsDynamic, confuse(m826) is F826<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x826 = (f826 as dynamic); });
+ Expect.throws(() { x826 = confuse(f826); });
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>() l826;
+ Expect.throws(() { l826 = (f826 as dynamic); });
+ Expect.throws(() { l826 = confuse(f826); });
+ }
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>() l826 = m826;
+ // In checked mode, verifies the type.
+ x826 = m826;
+ x826 = confuse(m826);
+ }
+ }
+
+ void testF926() {
+ // List<Function> Function({Function x}) Function<B extends core.int>()
+ Expect.isTrue(f926 is F926);
+ Expect.isTrue(confuse(f926) is F926);
+ // In checked mode, verifies the type.
+ List<Function> Function({Function x}) Function<B extends core.int>() l926;
+ // The static function f926 sets `T` to `int`.
+ if (!tIsBool) {
+ x926 = f926 as dynamic;
+ l926 = f926 as dynamic;
+ x926 = confuse(f926);
+ l926 = confuse(f926);
+ }
+
+ Expect.isTrue(m926 is F926);
+ Expect.isTrue(m926 is List<Function> Function({Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m926) is F926);
+ // In checked mode, verifies the type.
+ x926 = m926;
+ l926 = m926;
+ x926 = confuse(m926);
+ l926 = confuse(m926);
+
+ }
+
+ void testF1026() {
+ // List<Function> Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1026 is F1026);
+ Expect.isTrue(confuse(f1026) is F1026);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x) Function<B extends core.int>() l1026;
+ // The static function f1026 sets `T` to `int`.
+ if (!tIsBool) {
+ x1026 = f1026 as dynamic;
+ l1026 = f1026 as dynamic;
+ x1026 = confuse(f1026);
+ l1026 = confuse(f1026);
+ }
+
+ Expect.isTrue(m1026 is F1026);
+ Expect.isTrue(m1026 is List<Function> Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1026) is F1026);
+ // In checked mode, verifies the type.
+ x1026 = m1026;
+ l1026 = m1026;
+ x1026 = confuse(m1026);
+ l1026 = confuse(m1026);
+ if (!tIsBool) {
+ Expect.isTrue(f1026 is F1026<int>);
+ Expect.isFalse(f1026 is F1026<bool>);
+ Expect.isTrue(confuse(f1026) is F1026<int>);
+ Expect.isFalse(confuse(f1026) is F1026<bool>);
+ Expect.equals(tIsDynamic, m1026 is F1026<bool>);
+ Expect.equals(tIsDynamic, confuse(m1026) is F1026<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1026 = (f1026 as dynamic); });
+ Expect.throws(() { x1026 = confuse(f1026); });
+ List<Function> Function(List<T> x) Function<B extends core.int>() l1026;
+ Expect.throws(() { l1026 = (f1026 as dynamic); });
+ Expect.throws(() { l1026 = confuse(f1026); });
+ }
+ List<Function> Function(List<T> x) Function<B extends core.int>() l1026 = m1026;
+ // In checked mode, verifies the type.
+ x1026 = m1026;
+ x1026 = confuse(m1026);
+ }
+ }
+
+ void testF1126() {
+ // core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1126 is F1126);
+ Expect.isTrue(confuse(f1126) is F1126);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>() l1126;
+ // The static function f1126 sets `T` to `int`.
+ if (!tIsBool) {
+ x1126 = f1126 as dynamic;
+ l1126 = f1126 as dynamic;
+ x1126 = confuse(f1126);
+ l1126 = confuse(f1126);
+ }
+
+ Expect.isTrue(m1126 is F1126);
+ Expect.isTrue(m1126 is core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1126) is F1126);
+ // In checked mode, verifies the type.
+ x1126 = m1126;
+ l1126 = m1126;
+ x1126 = confuse(m1126);
+ l1126 = confuse(m1126);
+
+ }
+
+ void testF1226() {
+ // core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1226 is F1226);
+ Expect.isTrue(confuse(f1226) is F1226);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>() l1226;
+ // The static function f1226 sets `T` to `int`.
+ if (!tIsBool) {
+ x1226 = f1226 as dynamic;
+ l1226 = f1226 as dynamic;
+ x1226 = confuse(f1226);
+ l1226 = confuse(f1226);
+ }
+
+ Expect.isTrue(m1226 is F1226);
+ Expect.isTrue(m1226 is core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1226) is F1226);
+ // In checked mode, verifies the type.
+ x1226 = m1226;
+ l1226 = m1226;
+ x1226 = confuse(m1226);
+ l1226 = confuse(m1226);
+
+ }
+
+ void testF1326() {
+ // List<T> Function(int x, [int x1]) Function<B extends core.int>()
+ Expect.isTrue(f1326 is F1326);
+ Expect.isTrue(confuse(f1326) is F1326);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [int x1]) Function<B extends core.int>() l1326;
+ // The static function f1326 sets `T` to `int`.
+ if (!tIsBool) {
+ x1326 = f1326 as dynamic;
+ l1326 = f1326 as dynamic;
+ x1326 = confuse(f1326);
+ l1326 = confuse(f1326);
+ }
+
+ Expect.isTrue(m1326 is F1326);
+ Expect.isTrue(m1326 is List<T> Function(int x, [int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1326) is F1326);
+ // In checked mode, verifies the type.
+ x1326 = m1326;
+ l1326 = m1326;
+ x1326 = confuse(m1326);
+ l1326 = confuse(m1326);
+ if (!tIsBool) {
+ Expect.isTrue(f1326 is F1326<int>);
+ Expect.isFalse(f1326 is F1326<bool>);
+ Expect.isTrue(confuse(f1326) is F1326<int>);
+ Expect.isFalse(confuse(f1326) is F1326<bool>);
+ Expect.equals(tIsDynamic, m1326 is F1326<bool>);
+ Expect.equals(tIsDynamic, confuse(m1326) is F1326<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1326 = (f1326 as dynamic); });
+ Expect.throws(() { x1326 = confuse(f1326); });
+ List<T> Function(int x, [int x1]) Function<B extends core.int>() l1326;
+ Expect.throws(() { l1326 = (f1326 as dynamic); });
+ Expect.throws(() { l1326 = confuse(f1326); });
+ }
+ List<T> Function(int x, [int x1]) Function<B extends core.int>() l1326 = m1326;
+ // In checked mode, verifies the type.
+ x1326 = m1326;
+ x1326 = confuse(m1326);
+ }
+ }
+
+ void testF1426() {
+ // List<T> Function(int y, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1426 is F1426);
+ Expect.isTrue(confuse(f1426) is F1426);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>() l1426;
+ // The static function f1426 sets `T` to `int`.
+ if (!tIsBool) {
+ x1426 = f1426 as dynamic;
+ l1426 = f1426 as dynamic;
+ x1426 = confuse(f1426);
+ l1426 = confuse(f1426);
+ }
+
+ Expect.isTrue(m1426 is F1426);
+ Expect.isTrue(m1426 is List<T> Function(int y, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1426) is F1426);
+ // In checked mode, verifies the type.
+ x1426 = m1426;
+ l1426 = m1426;
+ x1426 = confuse(m1426);
+ l1426 = confuse(m1426);
+ if (!tIsBool) {
+ Expect.isTrue(f1426 is F1426<int>);
+ Expect.isFalse(f1426 is F1426<bool>);
+ Expect.isTrue(confuse(f1426) is F1426<int>);
+ Expect.isFalse(confuse(f1426) is F1426<bool>);
+ Expect.equals(tIsDynamic, m1426 is F1426<bool>);
+ Expect.equals(tIsDynamic, confuse(m1426) is F1426<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1426 = (f1426 as dynamic); });
+ Expect.throws(() { x1426 = confuse(f1426); });
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>() l1426;
+ Expect.throws(() { l1426 = (f1426 as dynamic); });
+ Expect.throws(() { l1426 = confuse(f1426); });
+ }
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>() l1426 = m1426;
+ // In checked mode, verifies the type.
+ x1426 = m1426;
+ x1426 = confuse(m1426);
+ }
+ }
+
+ void testF1526() {
+ // Function([int x]) Function<B extends core.int>()
+ Expect.isTrue(f1526 is F1526);
+ Expect.isTrue(confuse(f1526) is F1526);
+ // In checked mode, verifies the type.
+ Function([int x]) Function<B extends core.int>() l1526;
+ // The static function f1526 sets `T` to `int`.
+ if (!tIsBool) {
+ x1526 = f1526 as dynamic;
+ l1526 = f1526 as dynamic;
+ x1526 = confuse(f1526);
+ l1526 = confuse(f1526);
+ }
+
+ Expect.isTrue(m1526 is F1526);
+ Expect.isTrue(m1526 is Function([int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1526) is F1526);
+ // In checked mode, verifies the type.
+ x1526 = m1526;
+ l1526 = m1526;
+ x1526 = confuse(m1526);
+ l1526 = confuse(m1526);
+
+ }
+
+ void testF1626() {
+ // Function(List<Function> x1) Function<B extends core.int>()
+ Expect.isTrue(f1626 is F1626);
+ Expect.isTrue(confuse(f1626) is F1626);
+ // In checked mode, verifies the type.
+ Function(List<Function> x1) Function<B extends core.int>() l1626;
+ // The static function f1626 sets `T` to `int`.
+ if (!tIsBool) {
+ x1626 = f1626 as dynamic;
+ l1626 = f1626 as dynamic;
+ x1626 = confuse(f1626);
+ l1626 = confuse(f1626);
+ }
+
+ Expect.isTrue(m1626 is F1626);
+ Expect.isTrue(m1626 is Function(List<Function> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1626) is F1626);
+ // In checked mode, verifies the type.
+ x1626 = m1626;
+ l1626 = m1626;
+ x1626 = confuse(m1626);
+ l1626 = confuse(m1626);
+
+ }
+
+ void testF1726() {
+ // Function(int x, [List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1726 is F1726);
+ Expect.isTrue(confuse(f1726) is F1726);
+ // In checked mode, verifies the type.
+ Function(int x, [List<T> x1]) Function<B extends core.int>() l1726;
+ // The static function f1726 sets `T` to `int`.
+ if (!tIsBool) {
+ x1726 = f1726 as dynamic;
+ l1726 = f1726 as dynamic;
+ x1726 = confuse(f1726);
+ l1726 = confuse(f1726);
+ }
+
+ Expect.isTrue(m1726 is F1726);
+ Expect.isTrue(m1726 is Function(int x, [List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1726) is F1726);
+ // In checked mode, verifies the type.
+ x1726 = m1726;
+ l1726 = m1726;
+ x1726 = confuse(m1726);
+ l1726 = confuse(m1726);
+ if (!tIsBool) {
+ Expect.isTrue(f1726 is F1726<int>);
+ Expect.isFalse(f1726 is F1726<bool>);
+ Expect.isTrue(confuse(f1726) is F1726<int>);
+ Expect.isFalse(confuse(f1726) is F1726<bool>);
+ Expect.equals(tIsDynamic, m1726 is F1726<bool>);
+ Expect.equals(tIsDynamic, confuse(m1726) is F1726<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1726 = (f1726 as dynamic); });
+ Expect.throws(() { x1726 = confuse(f1726); });
+ Function(int x, [List<T> x1]) Function<B extends core.int>() l1726;
+ Expect.throws(() { l1726 = (f1726 as dynamic); });
+ Expect.throws(() { l1726 = confuse(f1726); });
+ }
+ Function(int x, [List<T> x1]) Function<B extends core.int>() l1726 = m1726;
+ // In checked mode, verifies the type.
+ x1726 = m1726;
+ x1726 = confuse(m1726);
+ }
+ }
+
+ void testF1826() {
+ // List<Function> Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1826 is F1826);
+ Expect.isTrue(confuse(f1826) is F1826);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>() l1826;
+ // The static function f1826 sets `T` to `int`.
+ if (!tIsBool) {
+ x1826 = f1826 as dynamic;
+ l1826 = f1826 as dynamic;
+ x1826 = confuse(f1826);
+ l1826 = confuse(f1826);
+ }
+
+ Expect.isTrue(m1826 is F1826);
+ Expect.isTrue(m1826 is List<Function> Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1826) is F1826);
+ // In checked mode, verifies the type.
+ x1826 = m1826;
+ l1826 = m1826;
+ x1826 = confuse(m1826);
+ l1826 = confuse(m1826);
+ if (!tIsBool) {
+ Expect.isTrue(f1826 is F1826<int>);
+ Expect.isFalse(f1826 is F1826<bool>);
+ Expect.isTrue(confuse(f1826) is F1826<int>);
+ Expect.isFalse(confuse(f1826) is F1826<bool>);
+ Expect.equals(tIsDynamic, m1826 is F1826<bool>);
+ Expect.equals(tIsDynamic, confuse(m1826) is F1826<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1826 = (f1826 as dynamic); });
+ Expect.throws(() { x1826 = confuse(f1826); });
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>() l1826;
+ Expect.throws(() { l1826 = (f1826 as dynamic); });
+ Expect.throws(() { l1826 = confuse(f1826); });
+ }
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>() l1826 = m1826;
+ // In checked mode, verifies the type.
+ x1826 = m1826;
+ x1826 = confuse(m1826);
+ }
+ }
+
+ void testF1926() {
+ // Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1926 is F1926);
+ Expect.isTrue(confuse(f1926) is F1926);
+ // In checked mode, verifies the type.
+ Function<A>() Function<B extends core.int>() l1926;
+ // The static function f1926 sets `T` to `int`.
+ if (!tIsBool) {
+ x1926 = f1926 as dynamic;
+ l1926 = f1926 as dynamic;
+ x1926 = confuse(f1926);
+ l1926 = confuse(f1926);
+ }
+
+ Expect.isTrue(m1926 is F1926);
+ Expect.isTrue(m1926 is Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1926) is F1926);
+ // In checked mode, verifies the type.
+ x1926 = m1926;
+ l1926 = m1926;
+ x1926 = confuse(m1926);
+ l1926 = confuse(m1926);
+
+ }
+
+ void testF2026() {
+ // B Function() Function<B extends core.int>()
+ Expect.isTrue(f2026 is F2026);
+ Expect.isTrue(confuse(f2026) is F2026);
+ // In checked mode, verifies the type.
+ B Function() Function<B extends core.int>() l2026;
+ // The static function f2026 sets `T` to `int`.
+ if (!tIsBool) {
+ x2026 = f2026 as dynamic;
+ l2026 = f2026 as dynamic;
+ x2026 = confuse(f2026);
+ l2026 = confuse(f2026);
+ }
+
+ Expect.isTrue(m2026 is F2026);
+ Expect.isTrue(m2026 is B Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m2026) is F2026);
+ // In checked mode, verifies the type.
+ x2026 = m2026;
+ l2026 = m2026;
+ x2026 = confuse(m2026);
+ l2026 = confuse(m2026);
+
+ }
+
+
+}
+
+class C27<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([List<Function> x1]) x27;
+ List<Function> Function(Function x0) x127;
+ List<T> Function(int y, [int x]) x227;
+ Function(int y, [List<T> x]) x327;
+ int Function(int x2, [int x3]) Function<B extends core.int>(int x) x427;
+ int Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) x527;
+ Function Function(int x) Function<B extends core.int>(int x) x627;
+ Function Function(int y, [List<Function> x]) Function<B extends core.int>(int x) x727;
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) x827;
+ List<Function> Function({Function x}) Function<B extends core.int>(int x) x927;
+ List<Function> Function(List<T> x) Function<B extends core.int>(int x) x1027;
+ core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>(int x) x1127;
+ core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) x1227;
+ List<T> Function(int x, [int x1]) Function<B extends core.int>(int x) x1327;
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) x1427;
+ Function([int x]) Function<B extends core.int>(int x) x1527;
+ Function(List<Function> x1) Function<B extends core.int>(int x) x1627;
+ Function(int x, [List<T> x1]) Function<B extends core.int>(int x) x1727;
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x) x1827;
+ Function<A>() Function<B extends core.int>(int x) x1927;
+ B Function() Function<B extends core.int>(int x) x2027;
+
+
+ C27({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m27([List<Function> x0]) => null;
+ List<Function> m127(Function x0) => null;
+ List<T> m227(int y, [int x]) => null;
+ m327(int y, [List<T> x]) => null;
+ int Function(int x0, [int x1]) m427<B extends core.int>(int x) => null;
+ int Function(int x0, {List<Function> x}) m527<B extends core.int>(int x) => null;
+ Function Function(int x) m627<B extends core.int>(int x) => null;
+ Function Function(int y, [List<Function> x]) m727<B extends core.int>(int x) => null;
+ Function Function(int x0, [List<T> x1]) m827<B extends core.int>(int x) => null;
+ List<Function> Function({Function x}) m927<B extends core.int>(int x) => null;
+ List<Function> Function(List<T> x) m1027<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [Function x]) m1127<B extends core.int>(int x) => null;
+ core.List<core.int> Function([core.List<core.int> x0]) m1227<B extends core.int>(int x) => null;
+ List<T> Function(int x, [int x0]) m1327<B extends core.int>(int x) => null;
+ List<T> Function(int y, {List<Function> x}) m1427<B extends core.int>(int x) => null;
+ Function([int x]) m1527<B extends core.int>(int x) => null;
+ Function(List<Function> x0) m1627<B extends core.int>(int x) => null;
+ Function(int x, [List<T> x0]) m1727<B extends core.int>(int x) => null;
+ List<Function> Function<A>(List<T> x) m1827<B extends core.int>(int x) => null;
+ Function<A>() m1927<B extends core.int>(int x) => null;
+ B Function() m2027<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF27();
+ testF127();
+ testF227();
+ testF327();
+ testF427();
+ testF527();
+ testF627();
+ testF727();
+ testF827();
+ testF927();
+ testF1027();
+ testF1127();
+ testF1227();
+ testF1327();
+ testF1427();
+ testF1527();
+ testF1627();
+ testF1727();
+ testF1827();
+ testF1927();
+ testF2027();
+ }
+
+ void testF27() {
+ // int Function([List<Function> x1])
+ Expect.isTrue(f27 is F27);
+ Expect.isTrue(confuse(f27) is F27);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x1]) l27;
+ // The static function f27 sets `T` to `int`.
+ if (!tIsBool) {
+ x27 = f27 as dynamic;
+ l27 = f27 as dynamic;
+ x27 = confuse(f27);
+ l27 = confuse(f27);
+ }
+
+ Expect.isTrue(m27 is F27);
+ Expect.isTrue(m27 is int Function([List<Function> x1]));
+ Expect.isTrue(confuse(m27) is F27);
+ // In checked mode, verifies the type.
+ x27 = m27;
+ l27 = m27;
+ x27 = confuse(m27);
+ l27 = confuse(m27);
+
+ }
+
+ void testF127() {
+ // List<Function> Function(Function x0)
+ Expect.isTrue(f127 is F127);
+ Expect.isTrue(confuse(f127) is F127);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x0) l127;
+ // The static function f127 sets `T` to `int`.
+ if (!tIsBool) {
+ x127 = f127 as dynamic;
+ l127 = f127 as dynamic;
+ x127 = confuse(f127);
+ l127 = confuse(f127);
+ }
+
+ Expect.isTrue(m127 is F127);
+ Expect.isTrue(m127 is List<Function> Function(Function x0));
+ Expect.isTrue(confuse(m127) is F127);
+ // In checked mode, verifies the type.
+ x127 = m127;
+ l127 = m127;
+ x127 = confuse(m127);
+ l127 = confuse(m127);
+
+ }
+
+ void testF227() {
+ // List<T> Function(int y, [int x])
+ Expect.isTrue(f227 is F227);
+ Expect.isTrue(confuse(f227) is F227);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [int x]) l227;
+ // The static function f227 sets `T` to `int`.
+ if (!tIsBool) {
+ x227 = f227 as dynamic;
+ l227 = f227 as dynamic;
+ x227 = confuse(f227);
+ l227 = confuse(f227);
+ }
+
+ Expect.isTrue(m227 is F227);
+ Expect.isTrue(m227 is List<T> Function(int y, [int x]));
+ Expect.isTrue(confuse(m227) is F227);
+ // In checked mode, verifies the type.
+ x227 = m227;
+ l227 = m227;
+ x227 = confuse(m227);
+ l227 = confuse(m227);
+ if (!tIsBool) {
+ Expect.isTrue(f227 is F227<int>);
+ Expect.isFalse(f227 is F227<bool>);
+ Expect.isTrue(confuse(f227) is F227<int>);
+ Expect.isFalse(confuse(f227) is F227<bool>);
+ Expect.equals(tIsDynamic, m227 is F227<bool>);
+ Expect.equals(tIsDynamic, confuse(m227) is F227<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x227 = (f227 as dynamic); });
+ Expect.throws(() { x227 = confuse(f227); });
+ List<T> Function(int y, [int x]) l227;
+ Expect.throws(() { l227 = (f227 as dynamic); });
+ Expect.throws(() { l227 = confuse(f227); });
+ }
+ List<T> Function(int y, [int x]) l227 = m227;
+ // In checked mode, verifies the type.
+ x227 = m227;
+ x227 = confuse(m227);
+ }
+ }
+
+ void testF327() {
+ // Function(int y, [List<T> x])
+ Expect.isTrue(f327 is F327);
+ Expect.isTrue(confuse(f327) is F327);
+ // In checked mode, verifies the type.
+ Function(int y, [List<T> x]) l327;
+ // The static function f327 sets `T` to `int`.
+ if (!tIsBool) {
+ x327 = f327 as dynamic;
+ l327 = f327 as dynamic;
+ x327 = confuse(f327);
+ l327 = confuse(f327);
+ }
+
+ Expect.isTrue(m327 is F327);
+ Expect.isTrue(m327 is Function(int y, [List<T> x]));
+ Expect.isTrue(confuse(m327) is F327);
+ // In checked mode, verifies the type.
+ x327 = m327;
+ l327 = m327;
+ x327 = confuse(m327);
+ l327 = confuse(m327);
+ if (!tIsBool) {
+ Expect.isTrue(f327 is F327<int>);
+ Expect.isFalse(f327 is F327<bool>);
+ Expect.isTrue(confuse(f327) is F327<int>);
+ Expect.isFalse(confuse(f327) is F327<bool>);
+ Expect.equals(tIsDynamic, m327 is F327<bool>);
+ Expect.equals(tIsDynamic, confuse(m327) is F327<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x327 = (f327 as dynamic); });
+ Expect.throws(() { x327 = confuse(f327); });
+ Function(int y, [List<T> x]) l327;
+ Expect.throws(() { l327 = (f327 as dynamic); });
+ Expect.throws(() { l327 = confuse(f327); });
+ }
+ Function(int y, [List<T> x]) l327 = m327;
+ // In checked mode, verifies the type.
+ x327 = m327;
+ x327 = confuse(m327);
+ }
+ }
+
+ void testF427() {
+ // int Function(int x2, [int x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f427 is F427);
+ Expect.isTrue(confuse(f427) is F427);
+ // In checked mode, verifies the type.
+ int Function(int x2, [int x3]) Function<B extends core.int>(int x) l427;
+ // The static function f427 sets `T` to `int`.
+ if (!tIsBool) {
+ x427 = f427 as dynamic;
+ l427 = f427 as dynamic;
+ x427 = confuse(f427);
+ l427 = confuse(f427);
+ }
+
+ Expect.isTrue(m427 is F427);
+ Expect.isTrue(m427 is int Function(int x2, [int x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m427) is F427);
+ // In checked mode, verifies the type.
+ x427 = m427;
+ l427 = m427;
+ x427 = confuse(m427);
+ l427 = confuse(m427);
+
+ }
+
+ void testF527() {
+ // int Function(int x1, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f527 is F527);
+ Expect.isTrue(confuse(f527) is F527);
+ // In checked mode, verifies the type.
+ int Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l527;
+ // The static function f527 sets `T` to `int`.
+ if (!tIsBool) {
+ x527 = f527 as dynamic;
+ l527 = f527 as dynamic;
+ x527 = confuse(f527);
+ l527 = confuse(f527);
+ }
+
+ Expect.isTrue(m527 is F527);
+ Expect.isTrue(m527 is int Function(int x1, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m527) is F527);
+ // In checked mode, verifies the type.
+ x527 = m527;
+ l527 = m527;
+ x527 = confuse(m527);
+ l527 = confuse(m527);
+
+ }
+
+ void testF627() {
+ // Function Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f627 is F627);
+ Expect.isTrue(confuse(f627) is F627);
+ // In checked mode, verifies the type.
+ Function Function(int x) Function<B extends core.int>(int x) l627;
+ // The static function f627 sets `T` to `int`.
+ if (!tIsBool) {
+ x627 = f627 as dynamic;
+ l627 = f627 as dynamic;
+ x627 = confuse(f627);
+ l627 = confuse(f627);
+ }
+
+ Expect.isTrue(m627 is F627);
+ Expect.isTrue(m627 is Function Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m627) is F627);
+ // In checked mode, verifies the type.
+ x627 = m627;
+ l627 = m627;
+ x627 = confuse(m627);
+ l627 = confuse(m627);
+
+ }
+
+ void testF727() {
+ // Function Function(int y, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f727 is F727);
+ Expect.isTrue(confuse(f727) is F727);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l727;
+ // The static function f727 sets `T` to `int`.
+ if (!tIsBool) {
+ x727 = f727 as dynamic;
+ l727 = f727 as dynamic;
+ x727 = confuse(f727);
+ l727 = confuse(f727);
+ }
+
+ Expect.isTrue(m727 is F727);
+ Expect.isTrue(m727 is Function Function(int y, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m727) is F727);
+ // In checked mode, verifies the type.
+ x727 = m727;
+ l727 = m727;
+ x727 = confuse(m727);
+ l727 = confuse(m727);
+
+ }
+
+ void testF827() {
+ // Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f827 is F827);
+ Expect.isTrue(confuse(f827) is F827);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l827;
+ // The static function f827 sets `T` to `int`.
+ if (!tIsBool) {
+ x827 = f827 as dynamic;
+ l827 = f827 as dynamic;
+ x827 = confuse(f827);
+ l827 = confuse(f827);
+ }
+
+ Expect.isTrue(m827 is F827);
+ Expect.isTrue(m827 is Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m827) is F827);
+ // In checked mode, verifies the type.
+ x827 = m827;
+ l827 = m827;
+ x827 = confuse(m827);
+ l827 = confuse(m827);
+ if (!tIsBool) {
+ Expect.isTrue(f827 is F827<int>);
+ Expect.isFalse(f827 is F827<bool>);
+ Expect.isTrue(confuse(f827) is F827<int>);
+ Expect.isFalse(confuse(f827) is F827<bool>);
+ Expect.equals(tIsDynamic, m827 is F827<bool>);
+ Expect.equals(tIsDynamic, confuse(m827) is F827<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x827 = (f827 as dynamic); });
+ Expect.throws(() { x827 = confuse(f827); });
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l827;
+ Expect.throws(() { l827 = (f827 as dynamic); });
+ Expect.throws(() { l827 = confuse(f827); });
+ }
+ Function Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l827 = m827;
+ // In checked mode, verifies the type.
+ x827 = m827;
+ x827 = confuse(m827);
+ }
+ }
+
+ void testF927() {
+ // List<Function> Function({Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f927 is F927);
+ Expect.isTrue(confuse(f927) is F927);
+ // In checked mode, verifies the type.
+ List<Function> Function({Function x}) Function<B extends core.int>(int x) l927;
+ // The static function f927 sets `T` to `int`.
+ if (!tIsBool) {
+ x927 = f927 as dynamic;
+ l927 = f927 as dynamic;
+ x927 = confuse(f927);
+ l927 = confuse(f927);
+ }
+
+ Expect.isTrue(m927 is F927);
+ Expect.isTrue(m927 is List<Function> Function({Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m927) is F927);
+ // In checked mode, verifies the type.
+ x927 = m927;
+ l927 = m927;
+ x927 = confuse(m927);
+ l927 = confuse(m927);
+
+ }
+
+ void testF1027() {
+ // List<Function> Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1027 is F1027);
+ Expect.isTrue(confuse(f1027) is F1027);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x) Function<B extends core.int>(int x) l1027;
+ // The static function f1027 sets `T` to `int`.
+ if (!tIsBool) {
+ x1027 = f1027 as dynamic;
+ l1027 = f1027 as dynamic;
+ x1027 = confuse(f1027);
+ l1027 = confuse(f1027);
+ }
+
+ Expect.isTrue(m1027 is F1027);
+ Expect.isTrue(m1027 is List<Function> Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1027) is F1027);
+ // In checked mode, verifies the type.
+ x1027 = m1027;
+ l1027 = m1027;
+ x1027 = confuse(m1027);
+ l1027 = confuse(m1027);
+ if (!tIsBool) {
+ Expect.isTrue(f1027 is F1027<int>);
+ Expect.isFalse(f1027 is F1027<bool>);
+ Expect.isTrue(confuse(f1027) is F1027<int>);
+ Expect.isFalse(confuse(f1027) is F1027<bool>);
+ Expect.equals(tIsDynamic, m1027 is F1027<bool>);
+ Expect.equals(tIsDynamic, confuse(m1027) is F1027<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1027 = (f1027 as dynamic); });
+ Expect.throws(() { x1027 = confuse(f1027); });
+ List<Function> Function(List<T> x) Function<B extends core.int>(int x) l1027;
+ Expect.throws(() { l1027 = (f1027 as dynamic); });
+ Expect.throws(() { l1027 = confuse(f1027); });
+ }
+ List<Function> Function(List<T> x) Function<B extends core.int>(int x) l1027 = m1027;
+ // In checked mode, verifies the type.
+ x1027 = m1027;
+ x1027 = confuse(m1027);
+ }
+ }
+
+ void testF1127() {
+ // core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1127 is F1127);
+ Expect.isTrue(confuse(f1127) is F1127);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>(int x) l1127;
+ // The static function f1127 sets `T` to `int`.
+ if (!tIsBool) {
+ x1127 = f1127 as dynamic;
+ l1127 = f1127 as dynamic;
+ x1127 = confuse(f1127);
+ l1127 = confuse(f1127);
+ }
+
+ Expect.isTrue(m1127 is F1127);
+ Expect.isTrue(m1127 is core.List<core.int> Function(int x1, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1127) is F1127);
+ // In checked mode, verifies the type.
+ x1127 = m1127;
+ l1127 = m1127;
+ x1127 = confuse(m1127);
+ l1127 = confuse(m1127);
+
+ }
+
+ void testF1227() {
+ // core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1227 is F1227);
+ Expect.isTrue(confuse(f1227) is F1227);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l1227;
+ // The static function f1227 sets `T` to `int`.
+ if (!tIsBool) {
+ x1227 = f1227 as dynamic;
+ l1227 = f1227 as dynamic;
+ x1227 = confuse(f1227);
+ l1227 = confuse(f1227);
+ }
+
+ Expect.isTrue(m1227 is F1227);
+ Expect.isTrue(m1227 is core.List<core.int> Function([core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1227) is F1227);
+ // In checked mode, verifies the type.
+ x1227 = m1227;
+ l1227 = m1227;
+ x1227 = confuse(m1227);
+ l1227 = confuse(m1227);
+
+ }
+
+ void testF1327() {
+ // List<T> Function(int x, [int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1327 is F1327);
+ Expect.isTrue(confuse(f1327) is F1327);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [int x1]) Function<B extends core.int>(int x) l1327;
+ // The static function f1327 sets `T` to `int`.
+ if (!tIsBool) {
+ x1327 = f1327 as dynamic;
+ l1327 = f1327 as dynamic;
+ x1327 = confuse(f1327);
+ l1327 = confuse(f1327);
+ }
+
+ Expect.isTrue(m1327 is F1327);
+ Expect.isTrue(m1327 is List<T> Function(int x, [int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1327) is F1327);
+ // In checked mode, verifies the type.
+ x1327 = m1327;
+ l1327 = m1327;
+ x1327 = confuse(m1327);
+ l1327 = confuse(m1327);
+ if (!tIsBool) {
+ Expect.isTrue(f1327 is F1327<int>);
+ Expect.isFalse(f1327 is F1327<bool>);
+ Expect.isTrue(confuse(f1327) is F1327<int>);
+ Expect.isFalse(confuse(f1327) is F1327<bool>);
+ Expect.equals(tIsDynamic, m1327 is F1327<bool>);
+ Expect.equals(tIsDynamic, confuse(m1327) is F1327<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1327 = (f1327 as dynamic); });
+ Expect.throws(() { x1327 = confuse(f1327); });
+ List<T> Function(int x, [int x1]) Function<B extends core.int>(int x) l1327;
+ Expect.throws(() { l1327 = (f1327 as dynamic); });
+ Expect.throws(() { l1327 = confuse(f1327); });
+ }
+ List<T> Function(int x, [int x1]) Function<B extends core.int>(int x) l1327 = m1327;
+ // In checked mode, verifies the type.
+ x1327 = m1327;
+ x1327 = confuse(m1327);
+ }
+ }
+
+ void testF1427() {
+ // List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1427 is F1427);
+ Expect.isTrue(confuse(f1427) is F1427);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l1427;
+ // The static function f1427 sets `T` to `int`.
+ if (!tIsBool) {
+ x1427 = f1427 as dynamic;
+ l1427 = f1427 as dynamic;
+ x1427 = confuse(f1427);
+ l1427 = confuse(f1427);
+ }
+
+ Expect.isTrue(m1427 is F1427);
+ Expect.isTrue(m1427 is List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1427) is F1427);
+ // In checked mode, verifies the type.
+ x1427 = m1427;
+ l1427 = m1427;
+ x1427 = confuse(m1427);
+ l1427 = confuse(m1427);
+ if (!tIsBool) {
+ Expect.isTrue(f1427 is F1427<int>);
+ Expect.isFalse(f1427 is F1427<bool>);
+ Expect.isTrue(confuse(f1427) is F1427<int>);
+ Expect.isFalse(confuse(f1427) is F1427<bool>);
+ Expect.equals(tIsDynamic, m1427 is F1427<bool>);
+ Expect.equals(tIsDynamic, confuse(m1427) is F1427<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1427 = (f1427 as dynamic); });
+ Expect.throws(() { x1427 = confuse(f1427); });
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l1427;
+ Expect.throws(() { l1427 = (f1427 as dynamic); });
+ Expect.throws(() { l1427 = confuse(f1427); });
+ }
+ List<T> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l1427 = m1427;
+ // In checked mode, verifies the type.
+ x1427 = m1427;
+ x1427 = confuse(m1427);
+ }
+ }
+
+ void testF1527() {
+ // Function([int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1527 is F1527);
+ Expect.isTrue(confuse(f1527) is F1527);
+ // In checked mode, verifies the type.
+ Function([int x]) Function<B extends core.int>(int x) l1527;
+ // The static function f1527 sets `T` to `int`.
+ if (!tIsBool) {
+ x1527 = f1527 as dynamic;
+ l1527 = f1527 as dynamic;
+ x1527 = confuse(f1527);
+ l1527 = confuse(f1527);
+ }
+
+ Expect.isTrue(m1527 is F1527);
+ Expect.isTrue(m1527 is Function([int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1527) is F1527);
+ // In checked mode, verifies the type.
+ x1527 = m1527;
+ l1527 = m1527;
+ x1527 = confuse(m1527);
+ l1527 = confuse(m1527);
+
+ }
+
+ void testF1627() {
+ // Function(List<Function> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1627 is F1627);
+ Expect.isTrue(confuse(f1627) is F1627);
+ // In checked mode, verifies the type.
+ Function(List<Function> x1) Function<B extends core.int>(int x) l1627;
+ // The static function f1627 sets `T` to `int`.
+ if (!tIsBool) {
+ x1627 = f1627 as dynamic;
+ l1627 = f1627 as dynamic;
+ x1627 = confuse(f1627);
+ l1627 = confuse(f1627);
+ }
+
+ Expect.isTrue(m1627 is F1627);
+ Expect.isTrue(m1627 is Function(List<Function> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1627) is F1627);
+ // In checked mode, verifies the type.
+ x1627 = m1627;
+ l1627 = m1627;
+ x1627 = confuse(m1627);
+ l1627 = confuse(m1627);
+
+ }
+
+ void testF1727() {
+ // Function(int x, [List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1727 is F1727);
+ Expect.isTrue(confuse(f1727) is F1727);
+ // In checked mode, verifies the type.
+ Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1727;
+ // The static function f1727 sets `T` to `int`.
+ if (!tIsBool) {
+ x1727 = f1727 as dynamic;
+ l1727 = f1727 as dynamic;
+ x1727 = confuse(f1727);
+ l1727 = confuse(f1727);
+ }
+
+ Expect.isTrue(m1727 is F1727);
+ Expect.isTrue(m1727 is Function(int x, [List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1727) is F1727);
+ // In checked mode, verifies the type.
+ x1727 = m1727;
+ l1727 = m1727;
+ x1727 = confuse(m1727);
+ l1727 = confuse(m1727);
+ if (!tIsBool) {
+ Expect.isTrue(f1727 is F1727<int>);
+ Expect.isFalse(f1727 is F1727<bool>);
+ Expect.isTrue(confuse(f1727) is F1727<int>);
+ Expect.isFalse(confuse(f1727) is F1727<bool>);
+ Expect.equals(tIsDynamic, m1727 is F1727<bool>);
+ Expect.equals(tIsDynamic, confuse(m1727) is F1727<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1727 = (f1727 as dynamic); });
+ Expect.throws(() { x1727 = confuse(f1727); });
+ Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1727;
+ Expect.throws(() { l1727 = (f1727 as dynamic); });
+ Expect.throws(() { l1727 = confuse(f1727); });
+ }
+ Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1727 = m1727;
+ // In checked mode, verifies the type.
+ x1727 = m1727;
+ x1727 = confuse(m1727);
+ }
+ }
+
+ void testF1827() {
+ // List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1827 is F1827);
+ Expect.isTrue(confuse(f1827) is F1827);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x) l1827;
+ // The static function f1827 sets `T` to `int`.
+ if (!tIsBool) {
+ x1827 = f1827 as dynamic;
+ l1827 = f1827 as dynamic;
+ x1827 = confuse(f1827);
+ l1827 = confuse(f1827);
+ }
+
+ Expect.isTrue(m1827 is F1827);
+ Expect.isTrue(m1827 is List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1827) is F1827);
+ // In checked mode, verifies the type.
+ x1827 = m1827;
+ l1827 = m1827;
+ x1827 = confuse(m1827);
+ l1827 = confuse(m1827);
+ if (!tIsBool) {
+ Expect.isTrue(f1827 is F1827<int>);
+ Expect.isFalse(f1827 is F1827<bool>);
+ Expect.isTrue(confuse(f1827) is F1827<int>);
+ Expect.isFalse(confuse(f1827) is F1827<bool>);
+ Expect.equals(tIsDynamic, m1827 is F1827<bool>);
+ Expect.equals(tIsDynamic, confuse(m1827) is F1827<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1827 = (f1827 as dynamic); });
+ Expect.throws(() { x1827 = confuse(f1827); });
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x) l1827;
+ Expect.throws(() { l1827 = (f1827 as dynamic); });
+ Expect.throws(() { l1827 = confuse(f1827); });
+ }
+ List<Function> Function<A>(List<T> x) Function<B extends core.int>(int x) l1827 = m1827;
+ // In checked mode, verifies the type.
+ x1827 = m1827;
+ x1827 = confuse(m1827);
+ }
+ }
+
+ void testF1927() {
+ // Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1927 is F1927);
+ Expect.isTrue(confuse(f1927) is F1927);
+ // In checked mode, verifies the type.
+ Function<A>() Function<B extends core.int>(int x) l1927;
+ // The static function f1927 sets `T` to `int`.
+ if (!tIsBool) {
+ x1927 = f1927 as dynamic;
+ l1927 = f1927 as dynamic;
+ x1927 = confuse(f1927);
+ l1927 = confuse(f1927);
+ }
+
+ Expect.isTrue(m1927 is F1927);
+ Expect.isTrue(m1927 is Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1927) is F1927);
+ // In checked mode, verifies the type.
+ x1927 = m1927;
+ l1927 = m1927;
+ x1927 = confuse(m1927);
+ l1927 = confuse(m1927);
+
+ }
+
+ void testF2027() {
+ // B Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f2027 is F2027);
+ Expect.isTrue(confuse(f2027) is F2027);
+ // In checked mode, verifies the type.
+ B Function() Function<B extends core.int>(int x) l2027;
+ // The static function f2027 sets `T` to `int`.
+ if (!tIsBool) {
+ x2027 = f2027 as dynamic;
+ l2027 = f2027 as dynamic;
+ x2027 = confuse(f2027);
+ l2027 = confuse(f2027);
+ }
+
+ Expect.isTrue(m2027 is F2027);
+ Expect.isTrue(m2027 is B Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m2027) is F2027);
+ // In checked mode, verifies the type.
+ x2027 = m2027;
+ l2027 = m2027;
+ x2027 = confuse(m2027);
+ l2027 = confuse(m2027);
+
+ }
+
+
+}
+
+class C28<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x1, [List<Function> x2]) x28;
+ List<Function> Function([Function x1]) x128;
+ List<T> Function(int x0) x228;
+ Function(List<T> x0) x328;
+ int Function(int x, [int x2]) Function() x428;
+ int Function(int y, {List<Function> x}) Function() x528;
+ Function Function([int x]) Function() x628;
+ Function Function(List<Function> x0) Function() x728;
+ Function Function(int x, [List<T> x2]) Function() x828;
+ List<Function> Function(int x0, {Function x}) Function() x928;
+ List<Function> Function([List<T> x]) Function() x1028;
+ core.List<core.int> Function(int y, [Function x]) Function() x1128;
+ core.List<core.int> Function(int x1, [core.List<core.int> x2]) Function() x1228;
+ List<T> Function({int x}) Function() x1328;
+ List<T> Function(core.List<core.int> x) Function() x1428;
+ Function(int x0, [int x]) Function() x1528;
+ Function([List<Function> x1]) Function() x1628;
+ Function({List<T> x}) Function() x1728;
+ List<Function> Function<A>() Function() x1828;
+ Function<A>(A x) Function() x1928;
+
+
+ C28({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m28(int x0, [List<Function> x1]) => null;
+ List<Function> m128([Function x0]) => null;
+ List<T> m228(int x0) => null;
+ m328(List<T> x0) => null;
+ int Function(int x, [int x0]) m428() => null;
+ int Function(int y, {List<Function> x}) m528() => null;
+ Function Function([int x]) m628() => null;
+ Function Function(List<Function> x0) m728() => null;
+ Function Function(int x, [List<T> x0]) m828() => null;
+ List<Function> Function(int x0, {Function x}) m928() => null;
+ List<Function> Function([List<T> x]) m1028() => null;
+ core.List<core.int> Function(int y, [Function x]) m1128() => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x1]) m1228() => null;
+ List<T> Function({int x}) m1328() => null;
+ List<T> Function(core.List<core.int> x) m1428() => null;
+ Function(int x0, [int x]) m1528() => null;
+ Function([List<Function> x0]) m1628() => null;
+ Function({List<T> x}) m1728() => null;
+ List<Function> Function<A>() m1828() => null;
+ Function<A>(A x) m1928() => null;
+
+
+ runTests() {
+ testF28();
+ testF128();
+ testF228();
+ testF328();
+ testF428();
+ testF528();
+ testF628();
+ testF728();
+ testF828();
+ testF928();
+ testF1028();
+ testF1128();
+ testF1228();
+ testF1328();
+ testF1428();
+ testF1528();
+ testF1628();
+ testF1728();
+ testF1828();
+ testF1928();
+ }
+
+ void testF28() {
+ // int Function(int x1, [List<Function> x2])
+ Expect.isTrue(f28 is F28);
+ Expect.isTrue(confuse(f28) is F28);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<Function> x2]) l28;
+ // The static function f28 sets `T` to `int`.
+ if (!tIsBool) {
+ x28 = f28 as dynamic;
+ l28 = f28 as dynamic;
+ x28 = confuse(f28);
+ l28 = confuse(f28);
+ }
+
+ Expect.isTrue(m28 is F28);
+ Expect.isTrue(m28 is int Function(int x1, [List<Function> x2]));
+ Expect.isTrue(confuse(m28) is F28);
+ // In checked mode, verifies the type.
+ x28 = m28;
+ l28 = m28;
+ x28 = confuse(m28);
+ l28 = confuse(m28);
+
+ }
+
+ void testF128() {
+ // List<Function> Function([Function x1])
+ Expect.isTrue(f128 is F128);
+ Expect.isTrue(confuse(f128) is F128);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x1]) l128;
+ // The static function f128 sets `T` to `int`.
+ if (!tIsBool) {
+ x128 = f128 as dynamic;
+ l128 = f128 as dynamic;
+ x128 = confuse(f128);
+ l128 = confuse(f128);
+ }
+
+ Expect.isTrue(m128 is F128);
+ Expect.isTrue(m128 is List<Function> Function([Function x1]));
+ Expect.isTrue(confuse(m128) is F128);
+ // In checked mode, verifies the type.
+ x128 = m128;
+ l128 = m128;
+ x128 = confuse(m128);
+ l128 = confuse(m128);
+
+ }
+
+ void testF228() {
+ // List<T> Function(int x0)
+ Expect.isTrue(f228 is F228);
+ Expect.isTrue(confuse(f228) is F228);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0) l228;
+ // The static function f228 sets `T` to `int`.
+ if (!tIsBool) {
+ x228 = f228 as dynamic;
+ l228 = f228 as dynamic;
+ x228 = confuse(f228);
+ l228 = confuse(f228);
+ }
+
+ Expect.isTrue(m228 is F228);
+ Expect.isTrue(m228 is List<T> Function(int x0));
+ Expect.isTrue(confuse(m228) is F228);
+ // In checked mode, verifies the type.
+ x228 = m228;
+ l228 = m228;
+ x228 = confuse(m228);
+ l228 = confuse(m228);
+ if (!tIsBool) {
+ Expect.isTrue(f228 is F228<int>);
+ Expect.isFalse(f228 is F228<bool>);
+ Expect.isTrue(confuse(f228) is F228<int>);
+ Expect.isFalse(confuse(f228) is F228<bool>);
+ Expect.equals(tIsDynamic, m228 is F228<bool>);
+ Expect.equals(tIsDynamic, confuse(m228) is F228<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x228 = (f228 as dynamic); });
+ Expect.throws(() { x228 = confuse(f228); });
+ List<T> Function(int x0) l228;
+ Expect.throws(() { l228 = (f228 as dynamic); });
+ Expect.throws(() { l228 = confuse(f228); });
+ }
+ List<T> Function(int x0) l228 = m228;
+ // In checked mode, verifies the type.
+ x228 = m228;
+ x228 = confuse(m228);
+ }
+ }
+
+ void testF328() {
+ // Function(List<T> x0)
+ Expect.isTrue(f328 is F328);
+ Expect.isTrue(confuse(f328) is F328);
+ // In checked mode, verifies the type.
+ Function(List<T> x0) l328;
+ // The static function f328 sets `T` to `int`.
+ if (!tIsBool) {
+ x328 = f328 as dynamic;
+ l328 = f328 as dynamic;
+ x328 = confuse(f328);
+ l328 = confuse(f328);
+ }
+
+ Expect.isTrue(m328 is F328);
+ Expect.isTrue(m328 is Function(List<T> x0));
+ Expect.isTrue(confuse(m328) is F328);
+ // In checked mode, verifies the type.
+ x328 = m328;
+ l328 = m328;
+ x328 = confuse(m328);
+ l328 = confuse(m328);
+ if (!tIsBool) {
+ Expect.isTrue(f328 is F328<int>);
+ Expect.isFalse(f328 is F328<bool>);
+ Expect.isTrue(confuse(f328) is F328<int>);
+ Expect.isFalse(confuse(f328) is F328<bool>);
+ Expect.equals(tIsDynamic, m328 is F328<bool>);
+ Expect.equals(tIsDynamic, confuse(m328) is F328<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x328 = (f328 as dynamic); });
+ Expect.throws(() { x328 = confuse(f328); });
+ Function(List<T> x0) l328;
+ Expect.throws(() { l328 = (f328 as dynamic); });
+ Expect.throws(() { l328 = confuse(f328); });
+ }
+ Function(List<T> x0) l328 = m328;
+ // In checked mode, verifies the type.
+ x328 = m328;
+ x328 = confuse(m328);
+ }
+ }
+
+ void testF428() {
+ // int Function(int x, [int x2]) Function()
+ Expect.isTrue(f428 is F428);
+ Expect.isTrue(confuse(f428) is F428);
+ // In checked mode, verifies the type.
+ int Function(int x, [int x2]) Function() l428;
+ // The static function f428 sets `T` to `int`.
+ if (!tIsBool) {
+ x428 = f428 as dynamic;
+ l428 = f428 as dynamic;
+ x428 = confuse(f428);
+ l428 = confuse(f428);
+ }
+
+ Expect.isTrue(m428 is F428);
+ Expect.isTrue(m428 is int Function(int x, [int x2]) Function());
+ Expect.isTrue(confuse(m428) is F428);
+ // In checked mode, verifies the type.
+ x428 = m428;
+ l428 = m428;
+ x428 = confuse(m428);
+ l428 = confuse(m428);
+
+ }
+
+ void testF528() {
+ // int Function(int y, {List<Function> x}) Function()
+ Expect.isTrue(f528 is F528);
+ Expect.isTrue(confuse(f528) is F528);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<Function> x}) Function() l528;
+ // The static function f528 sets `T` to `int`.
+ if (!tIsBool) {
+ x528 = f528 as dynamic;
+ l528 = f528 as dynamic;
+ x528 = confuse(f528);
+ l528 = confuse(f528);
+ }
+
+ Expect.isTrue(m528 is F528);
+ Expect.isTrue(m528 is int Function(int y, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m528) is F528);
+ // In checked mode, verifies the type.
+ x528 = m528;
+ l528 = m528;
+ x528 = confuse(m528);
+ l528 = confuse(m528);
+
+ }
+
+ void testF628() {
+ // Function Function([int x]) Function()
+ Expect.isTrue(f628 is F628);
+ Expect.isTrue(confuse(f628) is F628);
+ // In checked mode, verifies the type.
+ Function Function([int x]) Function() l628;
+ // The static function f628 sets `T` to `int`.
+ if (!tIsBool) {
+ x628 = f628 as dynamic;
+ l628 = f628 as dynamic;
+ x628 = confuse(f628);
+ l628 = confuse(f628);
+ }
+
+ Expect.isTrue(m628 is F628);
+ Expect.isTrue(m628 is Function Function([int x]) Function());
+ Expect.isTrue(confuse(m628) is F628);
+ // In checked mode, verifies the type.
+ x628 = m628;
+ l628 = m628;
+ x628 = confuse(m628);
+ l628 = confuse(m628);
+
+ }
+
+ void testF728() {
+ // Function Function(List<Function> x0) Function()
+ Expect.isTrue(f728 is F728);
+ Expect.isTrue(confuse(f728) is F728);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x0) Function() l728;
+ // The static function f728 sets `T` to `int`.
+ if (!tIsBool) {
+ x728 = f728 as dynamic;
+ l728 = f728 as dynamic;
+ x728 = confuse(f728);
+ l728 = confuse(f728);
+ }
+
+ Expect.isTrue(m728 is F728);
+ Expect.isTrue(m728 is Function Function(List<Function> x0) Function());
+ Expect.isTrue(confuse(m728) is F728);
+ // In checked mode, verifies the type.
+ x728 = m728;
+ l728 = m728;
+ x728 = confuse(m728);
+ l728 = confuse(m728);
+
+ }
+
+ void testF828() {
+ // Function Function(int x, [List<T> x2]) Function()
+ Expect.isTrue(f828 is F828);
+ Expect.isTrue(confuse(f828) is F828);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<T> x2]) Function() l828;
+ // The static function f828 sets `T` to `int`.
+ if (!tIsBool) {
+ x828 = f828 as dynamic;
+ l828 = f828 as dynamic;
+ x828 = confuse(f828);
+ l828 = confuse(f828);
+ }
+
+ Expect.isTrue(m828 is F828);
+ Expect.isTrue(m828 is Function Function(int x, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m828) is F828);
+ // In checked mode, verifies the type.
+ x828 = m828;
+ l828 = m828;
+ x828 = confuse(m828);
+ l828 = confuse(m828);
+ if (!tIsBool) {
+ Expect.isTrue(f828 is F828<int>);
+ Expect.isFalse(f828 is F828<bool>);
+ Expect.isTrue(confuse(f828) is F828<int>);
+ Expect.isFalse(confuse(f828) is F828<bool>);
+ Expect.equals(tIsDynamic, m828 is F828<bool>);
+ Expect.equals(tIsDynamic, confuse(m828) is F828<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x828 = (f828 as dynamic); });
+ Expect.throws(() { x828 = confuse(f828); });
+ Function Function(int x, [List<T> x2]) Function() l828;
+ Expect.throws(() { l828 = (f828 as dynamic); });
+ Expect.throws(() { l828 = confuse(f828); });
+ }
+ Function Function(int x, [List<T> x2]) Function() l828 = m828;
+ // In checked mode, verifies the type.
+ x828 = m828;
+ x828 = confuse(m828);
+ }
+ }
+
+ void testF928() {
+ // List<Function> Function(int x0, {Function x}) Function()
+ Expect.isTrue(f928 is F928);
+ Expect.isTrue(confuse(f928) is F928);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {Function x}) Function() l928;
+ // The static function f928 sets `T` to `int`.
+ if (!tIsBool) {
+ x928 = f928 as dynamic;
+ l928 = f928 as dynamic;
+ x928 = confuse(f928);
+ l928 = confuse(f928);
+ }
+
+ Expect.isTrue(m928 is F928);
+ Expect.isTrue(m928 is List<Function> Function(int x0, {Function x}) Function());
+ Expect.isTrue(confuse(m928) is F928);
+ // In checked mode, verifies the type.
+ x928 = m928;
+ l928 = m928;
+ x928 = confuse(m928);
+ l928 = confuse(m928);
+
+ }
+
+ void testF1028() {
+ // List<Function> Function([List<T> x]) Function()
+ Expect.isTrue(f1028 is F1028);
+ Expect.isTrue(confuse(f1028) is F1028);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x]) Function() l1028;
+ // The static function f1028 sets `T` to `int`.
+ if (!tIsBool) {
+ x1028 = f1028 as dynamic;
+ l1028 = f1028 as dynamic;
+ x1028 = confuse(f1028);
+ l1028 = confuse(f1028);
+ }
+
+ Expect.isTrue(m1028 is F1028);
+ Expect.isTrue(m1028 is List<Function> Function([List<T> x]) Function());
+ Expect.isTrue(confuse(m1028) is F1028);
+ // In checked mode, verifies the type.
+ x1028 = m1028;
+ l1028 = m1028;
+ x1028 = confuse(m1028);
+ l1028 = confuse(m1028);
+ if (!tIsBool) {
+ Expect.isTrue(f1028 is F1028<int>);
+ Expect.isFalse(f1028 is F1028<bool>);
+ Expect.isTrue(confuse(f1028) is F1028<int>);
+ Expect.isFalse(confuse(f1028) is F1028<bool>);
+ Expect.equals(tIsDynamic, m1028 is F1028<bool>);
+ Expect.equals(tIsDynamic, confuse(m1028) is F1028<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1028 = (f1028 as dynamic); });
+ Expect.throws(() { x1028 = confuse(f1028); });
+ List<Function> Function([List<T> x]) Function() l1028;
+ Expect.throws(() { l1028 = (f1028 as dynamic); });
+ Expect.throws(() { l1028 = confuse(f1028); });
+ }
+ List<Function> Function([List<T> x]) Function() l1028 = m1028;
+ // In checked mode, verifies the type.
+ x1028 = m1028;
+ x1028 = confuse(m1028);
+ }
+ }
+
+ void testF1128() {
+ // core.List<core.int> Function(int y, [Function x]) Function()
+ Expect.isTrue(f1128 is F1128);
+ Expect.isTrue(confuse(f1128) is F1128);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [Function x]) Function() l1128;
+ // The static function f1128 sets `T` to `int`.
+ if (!tIsBool) {
+ x1128 = f1128 as dynamic;
+ l1128 = f1128 as dynamic;
+ x1128 = confuse(f1128);
+ l1128 = confuse(f1128);
+ }
+
+ Expect.isTrue(m1128 is F1128);
+ Expect.isTrue(m1128 is core.List<core.int> Function(int y, [Function x]) Function());
+ Expect.isTrue(confuse(m1128) is F1128);
+ // In checked mode, verifies the type.
+ x1128 = m1128;
+ l1128 = m1128;
+ x1128 = confuse(m1128);
+ l1128 = confuse(m1128);
+
+ }
+
+ void testF1228() {
+ // core.List<core.int> Function(int x1, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1228 is F1228);
+ Expect.isTrue(confuse(f1228) is F1228);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [core.List<core.int> x2]) Function() l1228;
+ // The static function f1228 sets `T` to `int`.
+ if (!tIsBool) {
+ x1228 = f1228 as dynamic;
+ l1228 = f1228 as dynamic;
+ x1228 = confuse(f1228);
+ l1228 = confuse(f1228);
+ }
+
+ Expect.isTrue(m1228 is F1228);
+ Expect.isTrue(m1228 is core.List<core.int> Function(int x1, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1228) is F1228);
+ // In checked mode, verifies the type.
+ x1228 = m1228;
+ l1228 = m1228;
+ x1228 = confuse(m1228);
+ l1228 = confuse(m1228);
+
+ }
+
+ void testF1328() {
+ // List<T> Function({int x}) Function()
+ Expect.isTrue(f1328 is F1328);
+ Expect.isTrue(confuse(f1328) is F1328);
+ // In checked mode, verifies the type.
+ List<T> Function({int x}) Function() l1328;
+ // The static function f1328 sets `T` to `int`.
+ if (!tIsBool) {
+ x1328 = f1328 as dynamic;
+ l1328 = f1328 as dynamic;
+ x1328 = confuse(f1328);
+ l1328 = confuse(f1328);
+ }
+
+ Expect.isTrue(m1328 is F1328);
+ Expect.isTrue(m1328 is List<T> Function({int x}) Function());
+ Expect.isTrue(confuse(m1328) is F1328);
+ // In checked mode, verifies the type.
+ x1328 = m1328;
+ l1328 = m1328;
+ x1328 = confuse(m1328);
+ l1328 = confuse(m1328);
+ if (!tIsBool) {
+ Expect.isTrue(f1328 is F1328<int>);
+ Expect.isFalse(f1328 is F1328<bool>);
+ Expect.isTrue(confuse(f1328) is F1328<int>);
+ Expect.isFalse(confuse(f1328) is F1328<bool>);
+ Expect.equals(tIsDynamic, m1328 is F1328<bool>);
+ Expect.equals(tIsDynamic, confuse(m1328) is F1328<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1328 = (f1328 as dynamic); });
+ Expect.throws(() { x1328 = confuse(f1328); });
+ List<T> Function({int x}) Function() l1328;
+ Expect.throws(() { l1328 = (f1328 as dynamic); });
+ Expect.throws(() { l1328 = confuse(f1328); });
+ }
+ List<T> Function({int x}) Function() l1328 = m1328;
+ // In checked mode, verifies the type.
+ x1328 = m1328;
+ x1328 = confuse(m1328);
+ }
+ }
+
+ void testF1428() {
+ // List<T> Function(core.List<core.int> x) Function()
+ Expect.isTrue(f1428 is F1428);
+ Expect.isTrue(confuse(f1428) is F1428);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x) Function() l1428;
+ // The static function f1428 sets `T` to `int`.
+ if (!tIsBool) {
+ x1428 = f1428 as dynamic;
+ l1428 = f1428 as dynamic;
+ x1428 = confuse(f1428);
+ l1428 = confuse(f1428);
+ }
+
+ Expect.isTrue(m1428 is F1428);
+ Expect.isTrue(m1428 is List<T> Function(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1428) is F1428);
+ // In checked mode, verifies the type.
+ x1428 = m1428;
+ l1428 = m1428;
+ x1428 = confuse(m1428);
+ l1428 = confuse(m1428);
+ if (!tIsBool) {
+ Expect.isTrue(f1428 is F1428<int>);
+ Expect.isFalse(f1428 is F1428<bool>);
+ Expect.isTrue(confuse(f1428) is F1428<int>);
+ Expect.isFalse(confuse(f1428) is F1428<bool>);
+ Expect.equals(tIsDynamic, m1428 is F1428<bool>);
+ Expect.equals(tIsDynamic, confuse(m1428) is F1428<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1428 = (f1428 as dynamic); });
+ Expect.throws(() { x1428 = confuse(f1428); });
+ List<T> Function(core.List<core.int> x) Function() l1428;
+ Expect.throws(() { l1428 = (f1428 as dynamic); });
+ Expect.throws(() { l1428 = confuse(f1428); });
+ }
+ List<T> Function(core.List<core.int> x) Function() l1428 = m1428;
+ // In checked mode, verifies the type.
+ x1428 = m1428;
+ x1428 = confuse(m1428);
+ }
+ }
+
+ void testF1528() {
+ // Function(int x0, [int x]) Function()
+ Expect.isTrue(f1528 is F1528);
+ Expect.isTrue(confuse(f1528) is F1528);
+ // In checked mode, verifies the type.
+ Function(int x0, [int x]) Function() l1528;
+ // The static function f1528 sets `T` to `int`.
+ if (!tIsBool) {
+ x1528 = f1528 as dynamic;
+ l1528 = f1528 as dynamic;
+ x1528 = confuse(f1528);
+ l1528 = confuse(f1528);
+ }
+
+ Expect.isTrue(m1528 is F1528);
+ Expect.isTrue(m1528 is Function(int x0, [int x]) Function());
+ Expect.isTrue(confuse(m1528) is F1528);
+ // In checked mode, verifies the type.
+ x1528 = m1528;
+ l1528 = m1528;
+ x1528 = confuse(m1528);
+ l1528 = confuse(m1528);
+
+ }
+
+ void testF1628() {
+ // Function([List<Function> x1]) Function()
+ Expect.isTrue(f1628 is F1628);
+ Expect.isTrue(confuse(f1628) is F1628);
+ // In checked mode, verifies the type.
+ Function([List<Function> x1]) Function() l1628;
+ // The static function f1628 sets `T` to `int`.
+ if (!tIsBool) {
+ x1628 = f1628 as dynamic;
+ l1628 = f1628 as dynamic;
+ x1628 = confuse(f1628);
+ l1628 = confuse(f1628);
+ }
+
+ Expect.isTrue(m1628 is F1628);
+ Expect.isTrue(m1628 is Function([List<Function> x1]) Function());
+ Expect.isTrue(confuse(m1628) is F1628);
+ // In checked mode, verifies the type.
+ x1628 = m1628;
+ l1628 = m1628;
+ x1628 = confuse(m1628);
+ l1628 = confuse(m1628);
+
+ }
+
+ void testF1728() {
+ // Function({List<T> x}) Function()
+ Expect.isTrue(f1728 is F1728);
+ Expect.isTrue(confuse(f1728) is F1728);
+ // In checked mode, verifies the type.
+ Function({List<T> x}) Function() l1728;
+ // The static function f1728 sets `T` to `int`.
+ if (!tIsBool) {
+ x1728 = f1728 as dynamic;
+ l1728 = f1728 as dynamic;
+ x1728 = confuse(f1728);
+ l1728 = confuse(f1728);
+ }
+
+ Expect.isTrue(m1728 is F1728);
+ Expect.isTrue(m1728 is Function({List<T> x}) Function());
+ Expect.isTrue(confuse(m1728) is F1728);
+ // In checked mode, verifies the type.
+ x1728 = m1728;
+ l1728 = m1728;
+ x1728 = confuse(m1728);
+ l1728 = confuse(m1728);
+ if (!tIsBool) {
+ Expect.isTrue(f1728 is F1728<int>);
+ Expect.isFalse(f1728 is F1728<bool>);
+ Expect.isTrue(confuse(f1728) is F1728<int>);
+ Expect.isFalse(confuse(f1728) is F1728<bool>);
+ Expect.equals(tIsDynamic, m1728 is F1728<bool>);
+ Expect.equals(tIsDynamic, confuse(m1728) is F1728<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1728 = (f1728 as dynamic); });
+ Expect.throws(() { x1728 = confuse(f1728); });
+ Function({List<T> x}) Function() l1728;
+ Expect.throws(() { l1728 = (f1728 as dynamic); });
+ Expect.throws(() { l1728 = confuse(f1728); });
+ }
+ Function({List<T> x}) Function() l1728 = m1728;
+ // In checked mode, verifies the type.
+ x1728 = m1728;
+ x1728 = confuse(m1728);
+ }
+ }
+
+ void testF1828() {
+ // List<Function> Function<A>() Function()
+ Expect.isTrue(f1828 is F1828);
+ Expect.isTrue(confuse(f1828) is F1828);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>() Function() l1828;
+ // The static function f1828 sets `T` to `int`.
+ if (!tIsBool) {
+ x1828 = f1828 as dynamic;
+ l1828 = f1828 as dynamic;
+ x1828 = confuse(f1828);
+ l1828 = confuse(f1828);
+ }
+
+ Expect.isTrue(m1828 is F1828);
+ Expect.isTrue(m1828 is List<Function> Function<A>() Function());
+ Expect.isTrue(confuse(m1828) is F1828);
+ // In checked mode, verifies the type.
+ x1828 = m1828;
+ l1828 = m1828;
+ x1828 = confuse(m1828);
+ l1828 = confuse(m1828);
+
+ }
+
+ void testF1928() {
+ // Function<A>(A x) Function()
+ Expect.isTrue(f1928 is F1928);
+ Expect.isTrue(confuse(f1928) is F1928);
+ // In checked mode, verifies the type.
+ Function<A>(A x) Function() l1928;
+ // The static function f1928 sets `T` to `int`.
+ if (!tIsBool) {
+ x1928 = f1928 as dynamic;
+ l1928 = f1928 as dynamic;
+ x1928 = confuse(f1928);
+ l1928 = confuse(f1928);
+ }
+
+ Expect.isTrue(m1928 is F1928);
+ Expect.isTrue(m1928 is Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1928) is F1928);
+ // In checked mode, verifies the type.
+ x1928 = m1928;
+ l1928 = m1928;
+ x1928 = confuse(m1928);
+ l1928 = confuse(m1928);
+
+ }
+
+
+}
+
+class C29<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x, [List<Function> x2]) x29;
+ List<Function> Function(int x1, [Function x2]) x129;
+ List<T> Function([int x1]) x229;
+ Function([List<T> x1]) x329;
+ int Function(int x, [int x1]) Function(int x) x429;
+ int Function(int y, {List<Function> x}) Function(int x) x529;
+ Function Function([int x]) Function(int x) x629;
+ Function Function(List<Function> x1) Function(int x) x729;
+ Function Function(int x, [List<T> x1]) Function(int x) x829;
+ List<Function> Function(int x1, {Function x}) Function(int x) x929;
+ List<Function> Function([List<T> x]) Function(int x) x1029;
+ core.List<core.int> Function(int y, [Function x]) Function(int x) x1129;
+ core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function(int x) x1229;
+ List<T> Function({int x}) Function(int x) x1329;
+ List<T> Function(core.List<core.int> x) Function(int x) x1429;
+ Function(int x1, [int x]) Function(int x) x1529;
+ Function([List<Function> x1]) Function(int x) x1629;
+ Function({List<T> x}) Function(int x) x1729;
+ List<Function> Function<A>() Function(int x) x1829;
+ Function<A>(A x) Function(int x) x1929;
+
+
+ C29({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m29(int x, [List<Function> x0]) => null;
+ List<Function> m129(int x0, [Function x1]) => null;
+ List<T> m229([int x0]) => null;
+ m329([List<T> x0]) => null;
+ int Function(int x, [int x0]) m429(int x) => null;
+ int Function(int y, {List<Function> x}) m529(int x) => null;
+ Function Function([int x]) m629(int x) => null;
+ Function Function(List<Function> x0) m729(int x) => null;
+ Function Function(int x, [List<T> x0]) m829(int x) => null;
+ List<Function> Function(int x0, {Function x}) m929(int x) => null;
+ List<Function> Function([List<T> x]) m1029(int x) => null;
+ core.List<core.int> Function(int y, [Function x]) m1129(int x) => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x1]) m1229(int x) => null;
+ List<T> Function({int x}) m1329(int x) => null;
+ List<T> Function(core.List<core.int> x) m1429(int x) => null;
+ Function(int x0, [int x]) m1529(int x) => null;
+ Function([List<Function> x0]) m1629(int x) => null;
+ Function({List<T> x}) m1729(int x) => null;
+ List<Function> Function<A>() m1829(int x) => null;
+ Function<A>(A x) m1929(int x) => null;
+
+
+ runTests() {
+ testF29();
+ testF129();
+ testF229();
+ testF329();
+ testF429();
+ testF529();
+ testF629();
+ testF729();
+ testF829();
+ testF929();
+ testF1029();
+ testF1129();
+ testF1229();
+ testF1329();
+ testF1429();
+ testF1529();
+ testF1629();
+ testF1729();
+ testF1829();
+ testF1929();
+ }
+
+ void testF29() {
+ // int Function(int x, [List<Function> x2])
+ Expect.isTrue(f29 is F29);
+ Expect.isTrue(confuse(f29) is F29);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<Function> x2]) l29;
+ // The static function f29 sets `T` to `int`.
+ if (!tIsBool) {
+ x29 = f29 as dynamic;
+ l29 = f29 as dynamic;
+ x29 = confuse(f29);
+ l29 = confuse(f29);
+ }
+
+ Expect.isTrue(m29 is F29);
+ Expect.isTrue(m29 is int Function(int x, [List<Function> x2]));
+ Expect.isTrue(confuse(m29) is F29);
+ // In checked mode, verifies the type.
+ x29 = m29;
+ l29 = m29;
+ x29 = confuse(m29);
+ l29 = confuse(m29);
+
+ }
+
+ void testF129() {
+ // List<Function> Function(int x1, [Function x2])
+ Expect.isTrue(f129 is F129);
+ Expect.isTrue(confuse(f129) is F129);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [Function x2]) l129;
+ // The static function f129 sets `T` to `int`.
+ if (!tIsBool) {
+ x129 = f129 as dynamic;
+ l129 = f129 as dynamic;
+ x129 = confuse(f129);
+ l129 = confuse(f129);
+ }
+
+ Expect.isTrue(m129 is F129);
+ Expect.isTrue(m129 is List<Function> Function(int x1, [Function x2]));
+ Expect.isTrue(confuse(m129) is F129);
+ // In checked mode, verifies the type.
+ x129 = m129;
+ l129 = m129;
+ x129 = confuse(m129);
+ l129 = confuse(m129);
+
+ }
+
+ void testF229() {
+ // List<T> Function([int x1])
+ Expect.isTrue(f229 is F229);
+ Expect.isTrue(confuse(f229) is F229);
+ // In checked mode, verifies the type.
+ List<T> Function([int x1]) l229;
+ // The static function f229 sets `T` to `int`.
+ if (!tIsBool) {
+ x229 = f229 as dynamic;
+ l229 = f229 as dynamic;
+ x229 = confuse(f229);
+ l229 = confuse(f229);
+ }
+
+ Expect.isTrue(m229 is F229);
+ Expect.isTrue(m229 is List<T> Function([int x1]));
+ Expect.isTrue(confuse(m229) is F229);
+ // In checked mode, verifies the type.
+ x229 = m229;
+ l229 = m229;
+ x229 = confuse(m229);
+ l229 = confuse(m229);
+ if (!tIsBool) {
+ Expect.isTrue(f229 is F229<int>);
+ Expect.isFalse(f229 is F229<bool>);
+ Expect.isTrue(confuse(f229) is F229<int>);
+ Expect.isFalse(confuse(f229) is F229<bool>);
+ Expect.equals(tIsDynamic, m229 is F229<bool>);
+ Expect.equals(tIsDynamic, confuse(m229) is F229<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x229 = (f229 as dynamic); });
+ Expect.throws(() { x229 = confuse(f229); });
+ List<T> Function([int x1]) l229;
+ Expect.throws(() { l229 = (f229 as dynamic); });
+ Expect.throws(() { l229 = confuse(f229); });
+ }
+ List<T> Function([int x1]) l229 = m229;
+ // In checked mode, verifies the type.
+ x229 = m229;
+ x229 = confuse(m229);
+ }
+ }
+
+ void testF329() {
+ // Function([List<T> x1])
+ Expect.isTrue(f329 is F329);
+ Expect.isTrue(confuse(f329) is F329);
+ // In checked mode, verifies the type.
+ Function([List<T> x1]) l329;
+ // The static function f329 sets `T` to `int`.
+ if (!tIsBool) {
+ x329 = f329 as dynamic;
+ l329 = f329 as dynamic;
+ x329 = confuse(f329);
+ l329 = confuse(f329);
+ }
+
+ Expect.isTrue(m329 is F329);
+ Expect.isTrue(m329 is Function([List<T> x1]));
+ Expect.isTrue(confuse(m329) is F329);
+ // In checked mode, verifies the type.
+ x329 = m329;
+ l329 = m329;
+ x329 = confuse(m329);
+ l329 = confuse(m329);
+ if (!tIsBool) {
+ Expect.isTrue(f329 is F329<int>);
+ Expect.isFalse(f329 is F329<bool>);
+ Expect.isTrue(confuse(f329) is F329<int>);
+ Expect.isFalse(confuse(f329) is F329<bool>);
+ Expect.equals(tIsDynamic, m329 is F329<bool>);
+ Expect.equals(tIsDynamic, confuse(m329) is F329<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x329 = (f329 as dynamic); });
+ Expect.throws(() { x329 = confuse(f329); });
+ Function([List<T> x1]) l329;
+ Expect.throws(() { l329 = (f329 as dynamic); });
+ Expect.throws(() { l329 = confuse(f329); });
+ }
+ Function([List<T> x1]) l329 = m329;
+ // In checked mode, verifies the type.
+ x329 = m329;
+ x329 = confuse(m329);
+ }
+ }
+
+ void testF429() {
+ // int Function(int x, [int x1]) Function(int x)
+ Expect.isTrue(f429 is F429);
+ Expect.isTrue(confuse(f429) is F429);
+ // In checked mode, verifies the type.
+ int Function(int x, [int x1]) Function(int x) l429;
+ // The static function f429 sets `T` to `int`.
+ if (!tIsBool) {
+ x429 = f429 as dynamic;
+ l429 = f429 as dynamic;
+ x429 = confuse(f429);
+ l429 = confuse(f429);
+ }
+
+ Expect.isTrue(m429 is F429);
+ Expect.isTrue(m429 is int Function(int x, [int x1]) Function(int x));
+ Expect.isTrue(confuse(m429) is F429);
+ // In checked mode, verifies the type.
+ x429 = m429;
+ l429 = m429;
+ x429 = confuse(m429);
+ l429 = confuse(m429);
+
+ }
+
+ void testF529() {
+ // int Function(int y, {List<Function> x}) Function(int x)
+ Expect.isTrue(f529 is F529);
+ Expect.isTrue(confuse(f529) is F529);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<Function> x}) Function(int x) l529;
+ // The static function f529 sets `T` to `int`.
+ if (!tIsBool) {
+ x529 = f529 as dynamic;
+ l529 = f529 as dynamic;
+ x529 = confuse(f529);
+ l529 = confuse(f529);
+ }
+
+ Expect.isTrue(m529 is F529);
+ Expect.isTrue(m529 is int Function(int y, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m529) is F529);
+ // In checked mode, verifies the type.
+ x529 = m529;
+ l529 = m529;
+ x529 = confuse(m529);
+ l529 = confuse(m529);
+
+ }
+
+ void testF629() {
+ // Function Function([int x]) Function(int x)
+ Expect.isTrue(f629 is F629);
+ Expect.isTrue(confuse(f629) is F629);
+ // In checked mode, verifies the type.
+ Function Function([int x]) Function(int x) l629;
+ // The static function f629 sets `T` to `int`.
+ if (!tIsBool) {
+ x629 = f629 as dynamic;
+ l629 = f629 as dynamic;
+ x629 = confuse(f629);
+ l629 = confuse(f629);
+ }
+
+ Expect.isTrue(m629 is F629);
+ Expect.isTrue(m629 is Function Function([int x]) Function(int x));
+ Expect.isTrue(confuse(m629) is F629);
+ // In checked mode, verifies the type.
+ x629 = m629;
+ l629 = m629;
+ x629 = confuse(m629);
+ l629 = confuse(m629);
+
+ }
+
+ void testF729() {
+ // Function Function(List<Function> x1) Function(int x)
+ Expect.isTrue(f729 is F729);
+ Expect.isTrue(confuse(f729) is F729);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x1) Function(int x) l729;
+ // The static function f729 sets `T` to `int`.
+ if (!tIsBool) {
+ x729 = f729 as dynamic;
+ l729 = f729 as dynamic;
+ x729 = confuse(f729);
+ l729 = confuse(f729);
+ }
+
+ Expect.isTrue(m729 is F729);
+ Expect.isTrue(m729 is Function Function(List<Function> x1) Function(int x));
+ Expect.isTrue(confuse(m729) is F729);
+ // In checked mode, verifies the type.
+ x729 = m729;
+ l729 = m729;
+ x729 = confuse(m729);
+ l729 = confuse(m729);
+
+ }
+
+ void testF829() {
+ // Function Function(int x, [List<T> x1]) Function(int x)
+ Expect.isTrue(f829 is F829);
+ Expect.isTrue(confuse(f829) is F829);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<T> x1]) Function(int x) l829;
+ // The static function f829 sets `T` to `int`.
+ if (!tIsBool) {
+ x829 = f829 as dynamic;
+ l829 = f829 as dynamic;
+ x829 = confuse(f829);
+ l829 = confuse(f829);
+ }
+
+ Expect.isTrue(m829 is F829);
+ Expect.isTrue(m829 is Function Function(int x, [List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m829) is F829);
+ // In checked mode, verifies the type.
+ x829 = m829;
+ l829 = m829;
+ x829 = confuse(m829);
+ l829 = confuse(m829);
+ if (!tIsBool) {
+ Expect.isTrue(f829 is F829<int>);
+ Expect.isFalse(f829 is F829<bool>);
+ Expect.isTrue(confuse(f829) is F829<int>);
+ Expect.isFalse(confuse(f829) is F829<bool>);
+ Expect.equals(tIsDynamic, m829 is F829<bool>);
+ Expect.equals(tIsDynamic, confuse(m829) is F829<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x829 = (f829 as dynamic); });
+ Expect.throws(() { x829 = confuse(f829); });
+ Function Function(int x, [List<T> x1]) Function(int x) l829;
+ Expect.throws(() { l829 = (f829 as dynamic); });
+ Expect.throws(() { l829 = confuse(f829); });
+ }
+ Function Function(int x, [List<T> x1]) Function(int x) l829 = m829;
+ // In checked mode, verifies the type.
+ x829 = m829;
+ x829 = confuse(m829);
+ }
+ }
+
+ void testF929() {
+ // List<Function> Function(int x1, {Function x}) Function(int x)
+ Expect.isTrue(f929 is F929);
+ Expect.isTrue(confuse(f929) is F929);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {Function x}) Function(int x) l929;
+ // The static function f929 sets `T` to `int`.
+ if (!tIsBool) {
+ x929 = f929 as dynamic;
+ l929 = f929 as dynamic;
+ x929 = confuse(f929);
+ l929 = confuse(f929);
+ }
+
+ Expect.isTrue(m929 is F929);
+ Expect.isTrue(m929 is List<Function> Function(int x1, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m929) is F929);
+ // In checked mode, verifies the type.
+ x929 = m929;
+ l929 = m929;
+ x929 = confuse(m929);
+ l929 = confuse(m929);
+
+ }
+
+ void testF1029() {
+ // List<Function> Function([List<T> x]) Function(int x)
+ Expect.isTrue(f1029 is F1029);
+ Expect.isTrue(confuse(f1029) is F1029);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x]) Function(int x) l1029;
+ // The static function f1029 sets `T` to `int`.
+ if (!tIsBool) {
+ x1029 = f1029 as dynamic;
+ l1029 = f1029 as dynamic;
+ x1029 = confuse(f1029);
+ l1029 = confuse(f1029);
+ }
+
+ Expect.isTrue(m1029 is F1029);
+ Expect.isTrue(m1029 is List<Function> Function([List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1029) is F1029);
+ // In checked mode, verifies the type.
+ x1029 = m1029;
+ l1029 = m1029;
+ x1029 = confuse(m1029);
+ l1029 = confuse(m1029);
+ if (!tIsBool) {
+ Expect.isTrue(f1029 is F1029<int>);
+ Expect.isFalse(f1029 is F1029<bool>);
+ Expect.isTrue(confuse(f1029) is F1029<int>);
+ Expect.isFalse(confuse(f1029) is F1029<bool>);
+ Expect.equals(tIsDynamic, m1029 is F1029<bool>);
+ Expect.equals(tIsDynamic, confuse(m1029) is F1029<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1029 = (f1029 as dynamic); });
+ Expect.throws(() { x1029 = confuse(f1029); });
+ List<Function> Function([List<T> x]) Function(int x) l1029;
+ Expect.throws(() { l1029 = (f1029 as dynamic); });
+ Expect.throws(() { l1029 = confuse(f1029); });
+ }
+ List<Function> Function([List<T> x]) Function(int x) l1029 = m1029;
+ // In checked mode, verifies the type.
+ x1029 = m1029;
+ x1029 = confuse(m1029);
+ }
+ }
+
+ void testF1129() {
+ // core.List<core.int> Function(int y, [Function x]) Function(int x)
+ Expect.isTrue(f1129 is F1129);
+ Expect.isTrue(confuse(f1129) is F1129);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [Function x]) Function(int x) l1129;
+ // The static function f1129 sets `T` to `int`.
+ if (!tIsBool) {
+ x1129 = f1129 as dynamic;
+ l1129 = f1129 as dynamic;
+ x1129 = confuse(f1129);
+ l1129 = confuse(f1129);
+ }
+
+ Expect.isTrue(m1129 is F1129);
+ Expect.isTrue(m1129 is core.List<core.int> Function(int y, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m1129) is F1129);
+ // In checked mode, verifies the type.
+ x1129 = m1129;
+ l1129 = m1129;
+ x1129 = confuse(m1129);
+ l1129 = confuse(m1129);
+
+ }
+
+ void testF1229() {
+ // core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function(int x)
+ Expect.isTrue(f1229 is F1229);
+ Expect.isTrue(confuse(f1229) is F1229);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function(int x) l1229;
+ // The static function f1229 sets `T` to `int`.
+ if (!tIsBool) {
+ x1229 = f1229 as dynamic;
+ l1229 = f1229 as dynamic;
+ x1229 = confuse(f1229);
+ l1229 = confuse(f1229);
+ }
+
+ Expect.isTrue(m1229 is F1229);
+ Expect.isTrue(m1229 is core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function(int x));
+ Expect.isTrue(confuse(m1229) is F1229);
+ // In checked mode, verifies the type.
+ x1229 = m1229;
+ l1229 = m1229;
+ x1229 = confuse(m1229);
+ l1229 = confuse(m1229);
+
+ }
+
+ void testF1329() {
+ // List<T> Function({int x}) Function(int x)
+ Expect.isTrue(f1329 is F1329);
+ Expect.isTrue(confuse(f1329) is F1329);
+ // In checked mode, verifies the type.
+ List<T> Function({int x}) Function(int x) l1329;
+ // The static function f1329 sets `T` to `int`.
+ if (!tIsBool) {
+ x1329 = f1329 as dynamic;
+ l1329 = f1329 as dynamic;
+ x1329 = confuse(f1329);
+ l1329 = confuse(f1329);
+ }
+
+ Expect.isTrue(m1329 is F1329);
+ Expect.isTrue(m1329 is List<T> Function({int x}) Function(int x));
+ Expect.isTrue(confuse(m1329) is F1329);
+ // In checked mode, verifies the type.
+ x1329 = m1329;
+ l1329 = m1329;
+ x1329 = confuse(m1329);
+ l1329 = confuse(m1329);
+ if (!tIsBool) {
+ Expect.isTrue(f1329 is F1329<int>);
+ Expect.isFalse(f1329 is F1329<bool>);
+ Expect.isTrue(confuse(f1329) is F1329<int>);
+ Expect.isFalse(confuse(f1329) is F1329<bool>);
+ Expect.equals(tIsDynamic, m1329 is F1329<bool>);
+ Expect.equals(tIsDynamic, confuse(m1329) is F1329<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1329 = (f1329 as dynamic); });
+ Expect.throws(() { x1329 = confuse(f1329); });
+ List<T> Function({int x}) Function(int x) l1329;
+ Expect.throws(() { l1329 = (f1329 as dynamic); });
+ Expect.throws(() { l1329 = confuse(f1329); });
+ }
+ List<T> Function({int x}) Function(int x) l1329 = m1329;
+ // In checked mode, verifies the type.
+ x1329 = m1329;
+ x1329 = confuse(m1329);
+ }
+ }
+
+ void testF1429() {
+ // List<T> Function(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1429 is F1429);
+ Expect.isTrue(confuse(f1429) is F1429);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x) Function(int x) l1429;
+ // The static function f1429 sets `T` to `int`.
+ if (!tIsBool) {
+ x1429 = f1429 as dynamic;
+ l1429 = f1429 as dynamic;
+ x1429 = confuse(f1429);
+ l1429 = confuse(f1429);
+ }
+
+ Expect.isTrue(m1429 is F1429);
+ Expect.isTrue(m1429 is List<T> Function(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1429) is F1429);
+ // In checked mode, verifies the type.
+ x1429 = m1429;
+ l1429 = m1429;
+ x1429 = confuse(m1429);
+ l1429 = confuse(m1429);
+ if (!tIsBool) {
+ Expect.isTrue(f1429 is F1429<int>);
+ Expect.isFalse(f1429 is F1429<bool>);
+ Expect.isTrue(confuse(f1429) is F1429<int>);
+ Expect.isFalse(confuse(f1429) is F1429<bool>);
+ Expect.equals(tIsDynamic, m1429 is F1429<bool>);
+ Expect.equals(tIsDynamic, confuse(m1429) is F1429<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1429 = (f1429 as dynamic); });
+ Expect.throws(() { x1429 = confuse(f1429); });
+ List<T> Function(core.List<core.int> x) Function(int x) l1429;
+ Expect.throws(() { l1429 = (f1429 as dynamic); });
+ Expect.throws(() { l1429 = confuse(f1429); });
+ }
+ List<T> Function(core.List<core.int> x) Function(int x) l1429 = m1429;
+ // In checked mode, verifies the type.
+ x1429 = m1429;
+ x1429 = confuse(m1429);
+ }
+ }
+
+ void testF1529() {
+ // Function(int x1, [int x]) Function(int x)
+ Expect.isTrue(f1529 is F1529);
+ Expect.isTrue(confuse(f1529) is F1529);
+ // In checked mode, verifies the type.
+ Function(int x1, [int x]) Function(int x) l1529;
+ // The static function f1529 sets `T` to `int`.
+ if (!tIsBool) {
+ x1529 = f1529 as dynamic;
+ l1529 = f1529 as dynamic;
+ x1529 = confuse(f1529);
+ l1529 = confuse(f1529);
+ }
+
+ Expect.isTrue(m1529 is F1529);
+ Expect.isTrue(m1529 is Function(int x1, [int x]) Function(int x));
+ Expect.isTrue(confuse(m1529) is F1529);
+ // In checked mode, verifies the type.
+ x1529 = m1529;
+ l1529 = m1529;
+ x1529 = confuse(m1529);
+ l1529 = confuse(m1529);
+
+ }
+
+ void testF1629() {
+ // Function([List<Function> x1]) Function(int x)
+ Expect.isTrue(f1629 is F1629);
+ Expect.isTrue(confuse(f1629) is F1629);
+ // In checked mode, verifies the type.
+ Function([List<Function> x1]) Function(int x) l1629;
+ // The static function f1629 sets `T` to `int`.
+ if (!tIsBool) {
+ x1629 = f1629 as dynamic;
+ l1629 = f1629 as dynamic;
+ x1629 = confuse(f1629);
+ l1629 = confuse(f1629);
+ }
+
+ Expect.isTrue(m1629 is F1629);
+ Expect.isTrue(m1629 is Function([List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m1629) is F1629);
+ // In checked mode, verifies the type.
+ x1629 = m1629;
+ l1629 = m1629;
+ x1629 = confuse(m1629);
+ l1629 = confuse(m1629);
+
+ }
+
+ void testF1729() {
+ // Function({List<T> x}) Function(int x)
+ Expect.isTrue(f1729 is F1729);
+ Expect.isTrue(confuse(f1729) is F1729);
+ // In checked mode, verifies the type.
+ Function({List<T> x}) Function(int x) l1729;
+ // The static function f1729 sets `T` to `int`.
+ if (!tIsBool) {
+ x1729 = f1729 as dynamic;
+ l1729 = f1729 as dynamic;
+ x1729 = confuse(f1729);
+ l1729 = confuse(f1729);
+ }
+
+ Expect.isTrue(m1729 is F1729);
+ Expect.isTrue(m1729 is Function({List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1729) is F1729);
+ // In checked mode, verifies the type.
+ x1729 = m1729;
+ l1729 = m1729;
+ x1729 = confuse(m1729);
+ l1729 = confuse(m1729);
+ if (!tIsBool) {
+ Expect.isTrue(f1729 is F1729<int>);
+ Expect.isFalse(f1729 is F1729<bool>);
+ Expect.isTrue(confuse(f1729) is F1729<int>);
+ Expect.isFalse(confuse(f1729) is F1729<bool>);
+ Expect.equals(tIsDynamic, m1729 is F1729<bool>);
+ Expect.equals(tIsDynamic, confuse(m1729) is F1729<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1729 = (f1729 as dynamic); });
+ Expect.throws(() { x1729 = confuse(f1729); });
+ Function({List<T> x}) Function(int x) l1729;
+ Expect.throws(() { l1729 = (f1729 as dynamic); });
+ Expect.throws(() { l1729 = confuse(f1729); });
+ }
+ Function({List<T> x}) Function(int x) l1729 = m1729;
+ // In checked mode, verifies the type.
+ x1729 = m1729;
+ x1729 = confuse(m1729);
+ }
+ }
+
+ void testF1829() {
+ // List<Function> Function<A>() Function(int x)
+ Expect.isTrue(f1829 is F1829);
+ Expect.isTrue(confuse(f1829) is F1829);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>() Function(int x) l1829;
+ // The static function f1829 sets `T` to `int`.
+ if (!tIsBool) {
+ x1829 = f1829 as dynamic;
+ l1829 = f1829 as dynamic;
+ x1829 = confuse(f1829);
+ l1829 = confuse(f1829);
+ }
+
+ Expect.isTrue(m1829 is F1829);
+ Expect.isTrue(m1829 is List<Function> Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1829) is F1829);
+ // In checked mode, verifies the type.
+ x1829 = m1829;
+ l1829 = m1829;
+ x1829 = confuse(m1829);
+ l1829 = confuse(m1829);
+
+ }
+
+ void testF1929() {
+ // Function<A>(A x) Function(int x)
+ Expect.isTrue(f1929 is F1929);
+ Expect.isTrue(confuse(f1929) is F1929);
+ // In checked mode, verifies the type.
+ Function<A>(A x) Function(int x) l1929;
+ // The static function f1929 sets `T` to `int`.
+ if (!tIsBool) {
+ x1929 = f1929 as dynamic;
+ l1929 = f1929 as dynamic;
+ x1929 = confuse(f1929);
+ l1929 = confuse(f1929);
+ }
+
+ Expect.isTrue(m1929 is F1929);
+ Expect.isTrue(m1929 is Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1929) is F1929);
+ // In checked mode, verifies the type.
+ x1929 = m1929;
+ l1929 = m1929;
+ x1929 = confuse(m1929);
+ l1929 = confuse(m1929);
+
+ }
+
+
+}
+
+class C30<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function({List<Function> x}) x30;
+ List<Function> Function(int x, [Function x2]) x130;
+ List<T> Function(int x1, [int x2]) x230;
+ Function(int x1, [List<T> x2]) x330;
+ int Function(int x, [int x1]) Function<B extends core.int>() x430;
+ int Function(int y, {List<Function> x}) Function<B extends core.int>() x530;
+ Function Function([int x]) Function<B extends core.int>() x630;
+ Function Function(List<Function> x1) Function<B extends core.int>() x730;
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>() x830;
+ List<Function> Function(int x1, {Function x}) Function<B extends core.int>() x930;
+ List<Function> Function([List<T> x]) Function<B extends core.int>() x1030;
+ core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>() x1130;
+ core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() x1230;
+ List<T> Function({int x}) Function<B extends core.int>() x1330;
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>() x1430;
+ Function(int x1, [int x]) Function<B extends core.int>() x1530;
+ Function([List<Function> x1]) Function<B extends core.int>() x1630;
+ Function({List<T> x}) Function<B extends core.int>() x1730;
+ List<Function> Function<A>() Function<B extends core.int>() x1830;
+ Function<A>(A x) Function<B extends core.int>() x1930;
+
+
+ C30({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m30({List<Function> x}) => null;
+ List<Function> m130(int x, [Function x0]) => null;
+ List<T> m230(int x0, [int x1]) => null;
+ m330(int x0, [List<T> x1]) => null;
+ int Function(int x, [int x0]) m430<B extends core.int>() => null;
+ int Function(int y, {List<Function> x}) m530<B extends core.int>() => null;
+ Function Function([int x]) m630<B extends core.int>() => null;
+ Function Function(List<Function> x0) m730<B extends core.int>() => null;
+ Function Function(int x, [List<T> x0]) m830<B extends core.int>() => null;
+ List<Function> Function(int x0, {Function x}) m930<B extends core.int>() => null;
+ List<Function> Function([List<T> x]) m1030<B extends core.int>() => null;
+ core.List<core.int> Function(int y, [Function x]) m1130<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x1]) m1230<B extends core.int>() => null;
+ List<T> Function({int x}) m1330<B extends core.int>() => null;
+ List<T> Function(core.List<core.int> x) m1430<B extends core.int>() => null;
+ Function(int x0, [int x]) m1530<B extends core.int>() => null;
+ Function([List<Function> x0]) m1630<B extends core.int>() => null;
+ Function({List<T> x}) m1730<B extends core.int>() => null;
+ List<Function> Function<A>() m1830<B extends core.int>() => null;
+ Function<A>(A x) m1930<B extends core.int>() => null;
+
+
+ runTests() {
+ testF30();
+ testF130();
+ testF230();
+ testF330();
+ testF430();
+ testF530();
+ testF630();
+ testF730();
+ testF830();
+ testF930();
+ testF1030();
+ testF1130();
+ testF1230();
+ testF1330();
+ testF1430();
+ testF1530();
+ testF1630();
+ testF1730();
+ testF1830();
+ testF1930();
+ }
+
+ void testF30() {
+ // int Function({List<Function> x})
+ Expect.isTrue(f30 is F30);
+ Expect.isTrue(confuse(f30) is F30);
+ // In checked mode, verifies the type.
+ int Function({List<Function> x}) l30;
+ // The static function f30 sets `T` to `int`.
+ if (!tIsBool) {
+ x30 = f30 as dynamic;
+ l30 = f30 as dynamic;
+ x30 = confuse(f30);
+ l30 = confuse(f30);
+ }
+
+ Expect.isTrue(m30 is F30);
+ Expect.isTrue(m30 is int Function({List<Function> x}));
+ Expect.isTrue(confuse(m30) is F30);
+ // In checked mode, verifies the type.
+ x30 = m30;
+ l30 = m30;
+ x30 = confuse(m30);
+ l30 = confuse(m30);
+
+ }
+
+ void testF130() {
+ // List<Function> Function(int x, [Function x2])
+ Expect.isTrue(f130 is F130);
+ Expect.isTrue(confuse(f130) is F130);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [Function x2]) l130;
+ // The static function f130 sets `T` to `int`.
+ if (!tIsBool) {
+ x130 = f130 as dynamic;
+ l130 = f130 as dynamic;
+ x130 = confuse(f130);
+ l130 = confuse(f130);
+ }
+
+ Expect.isTrue(m130 is F130);
+ Expect.isTrue(m130 is List<Function> Function(int x, [Function x2]));
+ Expect.isTrue(confuse(m130) is F130);
+ // In checked mode, verifies the type.
+ x130 = m130;
+ l130 = m130;
+ x130 = confuse(m130);
+ l130 = confuse(m130);
+
+ }
+
+ void testF230() {
+ // List<T> Function(int x1, [int x2])
+ Expect.isTrue(f230 is F230);
+ Expect.isTrue(confuse(f230) is F230);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [int x2]) l230;
+ // The static function f230 sets `T` to `int`.
+ if (!tIsBool) {
+ x230 = f230 as dynamic;
+ l230 = f230 as dynamic;
+ x230 = confuse(f230);
+ l230 = confuse(f230);
+ }
+
+ Expect.isTrue(m230 is F230);
+ Expect.isTrue(m230 is List<T> Function(int x1, [int x2]));
+ Expect.isTrue(confuse(m230) is F230);
+ // In checked mode, verifies the type.
+ x230 = m230;
+ l230 = m230;
+ x230 = confuse(m230);
+ l230 = confuse(m230);
+ if (!tIsBool) {
+ Expect.isTrue(f230 is F230<int>);
+ Expect.isFalse(f230 is F230<bool>);
+ Expect.isTrue(confuse(f230) is F230<int>);
+ Expect.isFalse(confuse(f230) is F230<bool>);
+ Expect.equals(tIsDynamic, m230 is F230<bool>);
+ Expect.equals(tIsDynamic, confuse(m230) is F230<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x230 = (f230 as dynamic); });
+ Expect.throws(() { x230 = confuse(f230); });
+ List<T> Function(int x1, [int x2]) l230;
+ Expect.throws(() { l230 = (f230 as dynamic); });
+ Expect.throws(() { l230 = confuse(f230); });
+ }
+ List<T> Function(int x1, [int x2]) l230 = m230;
+ // In checked mode, verifies the type.
+ x230 = m230;
+ x230 = confuse(m230);
+ }
+ }
+
+ void testF330() {
+ // Function(int x1, [List<T> x2])
+ Expect.isTrue(f330 is F330);
+ Expect.isTrue(confuse(f330) is F330);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<T> x2]) l330;
+ // The static function f330 sets `T` to `int`.
+ if (!tIsBool) {
+ x330 = f330 as dynamic;
+ l330 = f330 as dynamic;
+ x330 = confuse(f330);
+ l330 = confuse(f330);
+ }
+
+ Expect.isTrue(m330 is F330);
+ Expect.isTrue(m330 is Function(int x1, [List<T> x2]));
+ Expect.isTrue(confuse(m330) is F330);
+ // In checked mode, verifies the type.
+ x330 = m330;
+ l330 = m330;
+ x330 = confuse(m330);
+ l330 = confuse(m330);
+ if (!tIsBool) {
+ Expect.isTrue(f330 is F330<int>);
+ Expect.isFalse(f330 is F330<bool>);
+ Expect.isTrue(confuse(f330) is F330<int>);
+ Expect.isFalse(confuse(f330) is F330<bool>);
+ Expect.equals(tIsDynamic, m330 is F330<bool>);
+ Expect.equals(tIsDynamic, confuse(m330) is F330<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x330 = (f330 as dynamic); });
+ Expect.throws(() { x330 = confuse(f330); });
+ Function(int x1, [List<T> x2]) l330;
+ Expect.throws(() { l330 = (f330 as dynamic); });
+ Expect.throws(() { l330 = confuse(f330); });
+ }
+ Function(int x1, [List<T> x2]) l330 = m330;
+ // In checked mode, verifies the type.
+ x330 = m330;
+ x330 = confuse(m330);
+ }
+ }
+
+ void testF430() {
+ // int Function(int x, [int x1]) Function<B extends core.int>()
+ Expect.isTrue(f430 is F430);
+ Expect.isTrue(confuse(f430) is F430);
+ // In checked mode, verifies the type.
+ int Function(int x, [int x1]) Function<B extends core.int>() l430;
+ // The static function f430 sets `T` to `int`.
+ if (!tIsBool) {
+ x430 = f430 as dynamic;
+ l430 = f430 as dynamic;
+ x430 = confuse(f430);
+ l430 = confuse(f430);
+ }
+
+ Expect.isTrue(m430 is F430);
+ Expect.isTrue(m430 is int Function(int x, [int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m430) is F430);
+ // In checked mode, verifies the type.
+ x430 = m430;
+ l430 = m430;
+ x430 = confuse(m430);
+ l430 = confuse(m430);
+
+ }
+
+ void testF530() {
+ // int Function(int y, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f530 is F530);
+ Expect.isTrue(confuse(f530) is F530);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<Function> x}) Function<B extends core.int>() l530;
+ // The static function f530 sets `T` to `int`.
+ if (!tIsBool) {
+ x530 = f530 as dynamic;
+ l530 = f530 as dynamic;
+ x530 = confuse(f530);
+ l530 = confuse(f530);
+ }
+
+ Expect.isTrue(m530 is F530);
+ Expect.isTrue(m530 is int Function(int y, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m530) is F530);
+ // In checked mode, verifies the type.
+ x530 = m530;
+ l530 = m530;
+ x530 = confuse(m530);
+ l530 = confuse(m530);
+
+ }
+
+ void testF630() {
+ // Function Function([int x]) Function<B extends core.int>()
+ Expect.isTrue(f630 is F630);
+ Expect.isTrue(confuse(f630) is F630);
+ // In checked mode, verifies the type.
+ Function Function([int x]) Function<B extends core.int>() l630;
+ // The static function f630 sets `T` to `int`.
+ if (!tIsBool) {
+ x630 = f630 as dynamic;
+ l630 = f630 as dynamic;
+ x630 = confuse(f630);
+ l630 = confuse(f630);
+ }
+
+ Expect.isTrue(m630 is F630);
+ Expect.isTrue(m630 is Function Function([int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m630) is F630);
+ // In checked mode, verifies the type.
+ x630 = m630;
+ l630 = m630;
+ x630 = confuse(m630);
+ l630 = confuse(m630);
+
+ }
+
+ void testF730() {
+ // Function Function(List<Function> x1) Function<B extends core.int>()
+ Expect.isTrue(f730 is F730);
+ Expect.isTrue(confuse(f730) is F730);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x1) Function<B extends core.int>() l730;
+ // The static function f730 sets `T` to `int`.
+ if (!tIsBool) {
+ x730 = f730 as dynamic;
+ l730 = f730 as dynamic;
+ x730 = confuse(f730);
+ l730 = confuse(f730);
+ }
+
+ Expect.isTrue(m730 is F730);
+ Expect.isTrue(m730 is Function Function(List<Function> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m730) is F730);
+ // In checked mode, verifies the type.
+ x730 = m730;
+ l730 = m730;
+ x730 = confuse(m730);
+ l730 = confuse(m730);
+
+ }
+
+ void testF830() {
+ // Function Function(int x, [List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f830 is F830);
+ Expect.isTrue(confuse(f830) is F830);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>() l830;
+ // The static function f830 sets `T` to `int`.
+ if (!tIsBool) {
+ x830 = f830 as dynamic;
+ l830 = f830 as dynamic;
+ x830 = confuse(f830);
+ l830 = confuse(f830);
+ }
+
+ Expect.isTrue(m830 is F830);
+ Expect.isTrue(m830 is Function Function(int x, [List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m830) is F830);
+ // In checked mode, verifies the type.
+ x830 = m830;
+ l830 = m830;
+ x830 = confuse(m830);
+ l830 = confuse(m830);
+ if (!tIsBool) {
+ Expect.isTrue(f830 is F830<int>);
+ Expect.isFalse(f830 is F830<bool>);
+ Expect.isTrue(confuse(f830) is F830<int>);
+ Expect.isFalse(confuse(f830) is F830<bool>);
+ Expect.equals(tIsDynamic, m830 is F830<bool>);
+ Expect.equals(tIsDynamic, confuse(m830) is F830<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x830 = (f830 as dynamic); });
+ Expect.throws(() { x830 = confuse(f830); });
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>() l830;
+ Expect.throws(() { l830 = (f830 as dynamic); });
+ Expect.throws(() { l830 = confuse(f830); });
+ }
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>() l830 = m830;
+ // In checked mode, verifies the type.
+ x830 = m830;
+ x830 = confuse(m830);
+ }
+ }
+
+ void testF930() {
+ // List<Function> Function(int x1, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f930 is F930);
+ Expect.isTrue(confuse(f930) is F930);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {Function x}) Function<B extends core.int>() l930;
+ // The static function f930 sets `T` to `int`.
+ if (!tIsBool) {
+ x930 = f930 as dynamic;
+ l930 = f930 as dynamic;
+ x930 = confuse(f930);
+ l930 = confuse(f930);
+ }
+
+ Expect.isTrue(m930 is F930);
+ Expect.isTrue(m930 is List<Function> Function(int x1, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m930) is F930);
+ // In checked mode, verifies the type.
+ x930 = m930;
+ l930 = m930;
+ x930 = confuse(m930);
+ l930 = confuse(m930);
+
+ }
+
+ void testF1030() {
+ // List<Function> Function([List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1030 is F1030);
+ Expect.isTrue(confuse(f1030) is F1030);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x]) Function<B extends core.int>() l1030;
+ // The static function f1030 sets `T` to `int`.
+ if (!tIsBool) {
+ x1030 = f1030 as dynamic;
+ l1030 = f1030 as dynamic;
+ x1030 = confuse(f1030);
+ l1030 = confuse(f1030);
+ }
+
+ Expect.isTrue(m1030 is F1030);
+ Expect.isTrue(m1030 is List<Function> Function([List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1030) is F1030);
+ // In checked mode, verifies the type.
+ x1030 = m1030;
+ l1030 = m1030;
+ x1030 = confuse(m1030);
+ l1030 = confuse(m1030);
+ if (!tIsBool) {
+ Expect.isTrue(f1030 is F1030<int>);
+ Expect.isFalse(f1030 is F1030<bool>);
+ Expect.isTrue(confuse(f1030) is F1030<int>);
+ Expect.isFalse(confuse(f1030) is F1030<bool>);
+ Expect.equals(tIsDynamic, m1030 is F1030<bool>);
+ Expect.equals(tIsDynamic, confuse(m1030) is F1030<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1030 = (f1030 as dynamic); });
+ Expect.throws(() { x1030 = confuse(f1030); });
+ List<Function> Function([List<T> x]) Function<B extends core.int>() l1030;
+ Expect.throws(() { l1030 = (f1030 as dynamic); });
+ Expect.throws(() { l1030 = confuse(f1030); });
+ }
+ List<Function> Function([List<T> x]) Function<B extends core.int>() l1030 = m1030;
+ // In checked mode, verifies the type.
+ x1030 = m1030;
+ x1030 = confuse(m1030);
+ }
+ }
+
+ void testF1130() {
+ // core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1130 is F1130);
+ Expect.isTrue(confuse(f1130) is F1130);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>() l1130;
+ // The static function f1130 sets `T` to `int`.
+ if (!tIsBool) {
+ x1130 = f1130 as dynamic;
+ l1130 = f1130 as dynamic;
+ x1130 = confuse(f1130);
+ l1130 = confuse(f1130);
+ }
+
+ Expect.isTrue(m1130 is F1130);
+ Expect.isTrue(m1130 is core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1130) is F1130);
+ // In checked mode, verifies the type.
+ x1130 = m1130;
+ l1130 = m1130;
+ x1130 = confuse(m1130);
+ l1130 = confuse(m1130);
+
+ }
+
+ void testF1230() {
+ // core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1230 is F1230);
+ Expect.isTrue(confuse(f1230) is F1230);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l1230;
+ // The static function f1230 sets `T` to `int`.
+ if (!tIsBool) {
+ x1230 = f1230 as dynamic;
+ l1230 = f1230 as dynamic;
+ x1230 = confuse(f1230);
+ l1230 = confuse(f1230);
+ }
+
+ Expect.isTrue(m1230 is F1230);
+ Expect.isTrue(m1230 is core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1230) is F1230);
+ // In checked mode, verifies the type.
+ x1230 = m1230;
+ l1230 = m1230;
+ x1230 = confuse(m1230);
+ l1230 = confuse(m1230);
+
+ }
+
+ void testF1330() {
+ // List<T> Function({int x}) Function<B extends core.int>()
+ Expect.isTrue(f1330 is F1330);
+ Expect.isTrue(confuse(f1330) is F1330);
+ // In checked mode, verifies the type.
+ List<T> Function({int x}) Function<B extends core.int>() l1330;
+ // The static function f1330 sets `T` to `int`.
+ if (!tIsBool) {
+ x1330 = f1330 as dynamic;
+ l1330 = f1330 as dynamic;
+ x1330 = confuse(f1330);
+ l1330 = confuse(f1330);
+ }
+
+ Expect.isTrue(m1330 is F1330);
+ Expect.isTrue(m1330 is List<T> Function({int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1330) is F1330);
+ // In checked mode, verifies the type.
+ x1330 = m1330;
+ l1330 = m1330;
+ x1330 = confuse(m1330);
+ l1330 = confuse(m1330);
+ if (!tIsBool) {
+ Expect.isTrue(f1330 is F1330<int>);
+ Expect.isFalse(f1330 is F1330<bool>);
+ Expect.isTrue(confuse(f1330) is F1330<int>);
+ Expect.isFalse(confuse(f1330) is F1330<bool>);
+ Expect.equals(tIsDynamic, m1330 is F1330<bool>);
+ Expect.equals(tIsDynamic, confuse(m1330) is F1330<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1330 = (f1330 as dynamic); });
+ Expect.throws(() { x1330 = confuse(f1330); });
+ List<T> Function({int x}) Function<B extends core.int>() l1330;
+ Expect.throws(() { l1330 = (f1330 as dynamic); });
+ Expect.throws(() { l1330 = confuse(f1330); });
+ }
+ List<T> Function({int x}) Function<B extends core.int>() l1330 = m1330;
+ // In checked mode, verifies the type.
+ x1330 = m1330;
+ x1330 = confuse(m1330);
+ }
+ }
+
+ void testF1430() {
+ // List<T> Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1430 is F1430);
+ Expect.isTrue(confuse(f1430) is F1430);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>() l1430;
+ // The static function f1430 sets `T` to `int`.
+ if (!tIsBool) {
+ x1430 = f1430 as dynamic;
+ l1430 = f1430 as dynamic;
+ x1430 = confuse(f1430);
+ l1430 = confuse(f1430);
+ }
+
+ Expect.isTrue(m1430 is F1430);
+ Expect.isTrue(m1430 is List<T> Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1430) is F1430);
+ // In checked mode, verifies the type.
+ x1430 = m1430;
+ l1430 = m1430;
+ x1430 = confuse(m1430);
+ l1430 = confuse(m1430);
+ if (!tIsBool) {
+ Expect.isTrue(f1430 is F1430<int>);
+ Expect.isFalse(f1430 is F1430<bool>);
+ Expect.isTrue(confuse(f1430) is F1430<int>);
+ Expect.isFalse(confuse(f1430) is F1430<bool>);
+ Expect.equals(tIsDynamic, m1430 is F1430<bool>);
+ Expect.equals(tIsDynamic, confuse(m1430) is F1430<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1430 = (f1430 as dynamic); });
+ Expect.throws(() { x1430 = confuse(f1430); });
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>() l1430;
+ Expect.throws(() { l1430 = (f1430 as dynamic); });
+ Expect.throws(() { l1430 = confuse(f1430); });
+ }
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>() l1430 = m1430;
+ // In checked mode, verifies the type.
+ x1430 = m1430;
+ x1430 = confuse(m1430);
+ }
+ }
+
+ void testF1530() {
+ // Function(int x1, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f1530 is F1530);
+ Expect.isTrue(confuse(f1530) is F1530);
+ // In checked mode, verifies the type.
+ Function(int x1, [int x]) Function<B extends core.int>() l1530;
+ // The static function f1530 sets `T` to `int`.
+ if (!tIsBool) {
+ x1530 = f1530 as dynamic;
+ l1530 = f1530 as dynamic;
+ x1530 = confuse(f1530);
+ l1530 = confuse(f1530);
+ }
+
+ Expect.isTrue(m1530 is F1530);
+ Expect.isTrue(m1530 is Function(int x1, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1530) is F1530);
+ // In checked mode, verifies the type.
+ x1530 = m1530;
+ l1530 = m1530;
+ x1530 = confuse(m1530);
+ l1530 = confuse(m1530);
+
+ }
+
+ void testF1630() {
+ // Function([List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1630 is F1630);
+ Expect.isTrue(confuse(f1630) is F1630);
+ // In checked mode, verifies the type.
+ Function([List<Function> x1]) Function<B extends core.int>() l1630;
+ // The static function f1630 sets `T` to `int`.
+ if (!tIsBool) {
+ x1630 = f1630 as dynamic;
+ l1630 = f1630 as dynamic;
+ x1630 = confuse(f1630);
+ l1630 = confuse(f1630);
+ }
+
+ Expect.isTrue(m1630 is F1630);
+ Expect.isTrue(m1630 is Function([List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1630) is F1630);
+ // In checked mode, verifies the type.
+ x1630 = m1630;
+ l1630 = m1630;
+ x1630 = confuse(m1630);
+ l1630 = confuse(m1630);
+
+ }
+
+ void testF1730() {
+ // Function({List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1730 is F1730);
+ Expect.isTrue(confuse(f1730) is F1730);
+ // In checked mode, verifies the type.
+ Function({List<T> x}) Function<B extends core.int>() l1730;
+ // The static function f1730 sets `T` to `int`.
+ if (!tIsBool) {
+ x1730 = f1730 as dynamic;
+ l1730 = f1730 as dynamic;
+ x1730 = confuse(f1730);
+ l1730 = confuse(f1730);
+ }
+
+ Expect.isTrue(m1730 is F1730);
+ Expect.isTrue(m1730 is Function({List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1730) is F1730);
+ // In checked mode, verifies the type.
+ x1730 = m1730;
+ l1730 = m1730;
+ x1730 = confuse(m1730);
+ l1730 = confuse(m1730);
+ if (!tIsBool) {
+ Expect.isTrue(f1730 is F1730<int>);
+ Expect.isFalse(f1730 is F1730<bool>);
+ Expect.isTrue(confuse(f1730) is F1730<int>);
+ Expect.isFalse(confuse(f1730) is F1730<bool>);
+ Expect.equals(tIsDynamic, m1730 is F1730<bool>);
+ Expect.equals(tIsDynamic, confuse(m1730) is F1730<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1730 = (f1730 as dynamic); });
+ Expect.throws(() { x1730 = confuse(f1730); });
+ Function({List<T> x}) Function<B extends core.int>() l1730;
+ Expect.throws(() { l1730 = (f1730 as dynamic); });
+ Expect.throws(() { l1730 = confuse(f1730); });
+ }
+ Function({List<T> x}) Function<B extends core.int>() l1730 = m1730;
+ // In checked mode, verifies the type.
+ x1730 = m1730;
+ x1730 = confuse(m1730);
+ }
+ }
+
+ void testF1830() {
+ // List<Function> Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1830 is F1830);
+ Expect.isTrue(confuse(f1830) is F1830);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>() Function<B extends core.int>() l1830;
+ // The static function f1830 sets `T` to `int`.
+ if (!tIsBool) {
+ x1830 = f1830 as dynamic;
+ l1830 = f1830 as dynamic;
+ x1830 = confuse(f1830);
+ l1830 = confuse(f1830);
+ }
+
+ Expect.isTrue(m1830 is F1830);
+ Expect.isTrue(m1830 is List<Function> Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1830) is F1830);
+ // In checked mode, verifies the type.
+ x1830 = m1830;
+ l1830 = m1830;
+ x1830 = confuse(m1830);
+ l1830 = confuse(m1830);
+
+ }
+
+ void testF1930() {
+ // Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1930 is F1930);
+ Expect.isTrue(confuse(f1930) is F1930);
+ // In checked mode, verifies the type.
+ Function<A>(A x) Function<B extends core.int>() l1930;
+ // The static function f1930 sets `T` to `int`.
+ if (!tIsBool) {
+ x1930 = f1930 as dynamic;
+ l1930 = f1930 as dynamic;
+ x1930 = confuse(f1930);
+ l1930 = confuse(f1930);
+ }
+
+ Expect.isTrue(m1930 is F1930);
+ Expect.isTrue(m1930 is Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1930) is F1930);
+ // In checked mode, verifies the type.
+ x1930 = m1930;
+ l1930 = m1930;
+ x1930 = confuse(m1930);
+ l1930 = confuse(m1930);
+
+ }
+
+
+}
+
+class C31<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, {List<Function> x}) x31;
+ List<Function> Function({Function x}) x131;
+ List<T> Function(int x, [int x2]) x231;
+ Function(int x, [List<T> x2]) x331;
+ int Function(int x, [int x1]) Function<B extends core.int>(int x) x431;
+ int Function(int y, {List<Function> x}) Function<B extends core.int>(int x) x531;
+ Function Function([int x]) Function<B extends core.int>(int x) x631;
+ Function Function(List<Function> x1) Function<B extends core.int>(int x) x731;
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x) x831;
+ List<Function> Function(int x1, {Function x}) Function<B extends core.int>(int x) x931;
+ List<Function> Function([List<T> x]) Function<B extends core.int>(int x) x1031;
+ core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>(int x) x1131;
+ core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) x1231;
+ List<T> Function({int x}) Function<B extends core.int>(int x) x1331;
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x) x1431;
+ Function(int x1, [int x]) Function<B extends core.int>(int x) x1531;
+ Function([List<Function> x1]) Function<B extends core.int>(int x) x1631;
+ Function({List<T> x}) Function<B extends core.int>(int x) x1731;
+ List<Function> Function<A>() Function<B extends core.int>(int x) x1831;
+ Function<A>(A x) Function<B extends core.int>(int x) x1931;
+
+
+ C31({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m31(int x0, {List<Function> x}) => null;
+ List<Function> m131({Function x}) => null;
+ List<T> m231(int x, [int x0]) => null;
+ m331(int x, [List<T> x0]) => null;
+ int Function(int x, [int x0]) m431<B extends core.int>(int x) => null;
+ int Function(int y, {List<Function> x}) m531<B extends core.int>(int x) => null;
+ Function Function([int x]) m631<B extends core.int>(int x) => null;
+ Function Function(List<Function> x0) m731<B extends core.int>(int x) => null;
+ Function Function(int x, [List<T> x0]) m831<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, {Function x}) m931<B extends core.int>(int x) => null;
+ List<Function> Function([List<T> x]) m1031<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, [Function x]) m1131<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [core.List<core.int> x1]) m1231<B extends core.int>(int x) => null;
+ List<T> Function({int x}) m1331<B extends core.int>(int x) => null;
+ List<T> Function(core.List<core.int> x) m1431<B extends core.int>(int x) => null;
+ Function(int x0, [int x]) m1531<B extends core.int>(int x) => null;
+ Function([List<Function> x0]) m1631<B extends core.int>(int x) => null;
+ Function({List<T> x}) m1731<B extends core.int>(int x) => null;
+ List<Function> Function<A>() m1831<B extends core.int>(int x) => null;
+ Function<A>(A x) m1931<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF31();
+ testF131();
+ testF231();
+ testF331();
+ testF431();
+ testF531();
+ testF631();
+ testF731();
+ testF831();
+ testF931();
+ testF1031();
+ testF1131();
+ testF1231();
+ testF1331();
+ testF1431();
+ testF1531();
+ testF1631();
+ testF1731();
+ testF1831();
+ testF1931();
+ }
+
+ void testF31() {
+ // int Function(int x0, {List<Function> x})
+ Expect.isTrue(f31 is F31);
+ Expect.isTrue(confuse(f31) is F31);
+ // In checked mode, verifies the type.
+ int Function(int x0, {List<Function> x}) l31;
+ // The static function f31 sets `T` to `int`.
+ if (!tIsBool) {
+ x31 = f31 as dynamic;
+ l31 = f31 as dynamic;
+ x31 = confuse(f31);
+ l31 = confuse(f31);
+ }
+
+ Expect.isTrue(m31 is F31);
+ Expect.isTrue(m31 is int Function(int x0, {List<Function> x}));
+ Expect.isTrue(confuse(m31) is F31);
+ // In checked mode, verifies the type.
+ x31 = m31;
+ l31 = m31;
+ x31 = confuse(m31);
+ l31 = confuse(m31);
+
+ }
+
+ void testF131() {
+ // List<Function> Function({Function x})
+ Expect.isTrue(f131 is F131);
+ Expect.isTrue(confuse(f131) is F131);
+ // In checked mode, verifies the type.
+ List<Function> Function({Function x}) l131;
+ // The static function f131 sets `T` to `int`.
+ if (!tIsBool) {
+ x131 = f131 as dynamic;
+ l131 = f131 as dynamic;
+ x131 = confuse(f131);
+ l131 = confuse(f131);
+ }
+
+ Expect.isTrue(m131 is F131);
+ Expect.isTrue(m131 is List<Function> Function({Function x}));
+ Expect.isTrue(confuse(m131) is F131);
+ // In checked mode, verifies the type.
+ x131 = m131;
+ l131 = m131;
+ x131 = confuse(m131);
+ l131 = confuse(m131);
+
+ }
+
+ void testF231() {
+ // List<T> Function(int x, [int x2])
+ Expect.isTrue(f231 is F231);
+ Expect.isTrue(confuse(f231) is F231);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [int x2]) l231;
+ // The static function f231 sets `T` to `int`.
+ if (!tIsBool) {
+ x231 = f231 as dynamic;
+ l231 = f231 as dynamic;
+ x231 = confuse(f231);
+ l231 = confuse(f231);
+ }
+
+ Expect.isTrue(m231 is F231);
+ Expect.isTrue(m231 is List<T> Function(int x, [int x2]));
+ Expect.isTrue(confuse(m231) is F231);
+ // In checked mode, verifies the type.
+ x231 = m231;
+ l231 = m231;
+ x231 = confuse(m231);
+ l231 = confuse(m231);
+ if (!tIsBool) {
+ Expect.isTrue(f231 is F231<int>);
+ Expect.isFalse(f231 is F231<bool>);
+ Expect.isTrue(confuse(f231) is F231<int>);
+ Expect.isFalse(confuse(f231) is F231<bool>);
+ Expect.equals(tIsDynamic, m231 is F231<bool>);
+ Expect.equals(tIsDynamic, confuse(m231) is F231<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x231 = (f231 as dynamic); });
+ Expect.throws(() { x231 = confuse(f231); });
+ List<T> Function(int x, [int x2]) l231;
+ Expect.throws(() { l231 = (f231 as dynamic); });
+ Expect.throws(() { l231 = confuse(f231); });
+ }
+ List<T> Function(int x, [int x2]) l231 = m231;
+ // In checked mode, verifies the type.
+ x231 = m231;
+ x231 = confuse(m231);
+ }
+ }
+
+ void testF331() {
+ // Function(int x, [List<T> x2])
+ Expect.isTrue(f331 is F331);
+ Expect.isTrue(confuse(f331) is F331);
+ // In checked mode, verifies the type.
+ Function(int x, [List<T> x2]) l331;
+ // The static function f331 sets `T` to `int`.
+ if (!tIsBool) {
+ x331 = f331 as dynamic;
+ l331 = f331 as dynamic;
+ x331 = confuse(f331);
+ l331 = confuse(f331);
+ }
+
+ Expect.isTrue(m331 is F331);
+ Expect.isTrue(m331 is Function(int x, [List<T> x2]));
+ Expect.isTrue(confuse(m331) is F331);
+ // In checked mode, verifies the type.
+ x331 = m331;
+ l331 = m331;
+ x331 = confuse(m331);
+ l331 = confuse(m331);
+ if (!tIsBool) {
+ Expect.isTrue(f331 is F331<int>);
+ Expect.isFalse(f331 is F331<bool>);
+ Expect.isTrue(confuse(f331) is F331<int>);
+ Expect.isFalse(confuse(f331) is F331<bool>);
+ Expect.equals(tIsDynamic, m331 is F331<bool>);
+ Expect.equals(tIsDynamic, confuse(m331) is F331<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x331 = (f331 as dynamic); });
+ Expect.throws(() { x331 = confuse(f331); });
+ Function(int x, [List<T> x2]) l331;
+ Expect.throws(() { l331 = (f331 as dynamic); });
+ Expect.throws(() { l331 = confuse(f331); });
+ }
+ Function(int x, [List<T> x2]) l331 = m331;
+ // In checked mode, verifies the type.
+ x331 = m331;
+ x331 = confuse(m331);
+ }
+ }
+
+ void testF431() {
+ // int Function(int x, [int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f431 is F431);
+ Expect.isTrue(confuse(f431) is F431);
+ // In checked mode, verifies the type.
+ int Function(int x, [int x1]) Function<B extends core.int>(int x) l431;
+ // The static function f431 sets `T` to `int`.
+ if (!tIsBool) {
+ x431 = f431 as dynamic;
+ l431 = f431 as dynamic;
+ x431 = confuse(f431);
+ l431 = confuse(f431);
+ }
+
+ Expect.isTrue(m431 is F431);
+ Expect.isTrue(m431 is int Function(int x, [int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m431) is F431);
+ // In checked mode, verifies the type.
+ x431 = m431;
+ l431 = m431;
+ x431 = confuse(m431);
+ l431 = confuse(m431);
+
+ }
+
+ void testF531() {
+ // int Function(int y, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f531 is F531);
+ Expect.isTrue(confuse(f531) is F531);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l531;
+ // The static function f531 sets `T` to `int`.
+ if (!tIsBool) {
+ x531 = f531 as dynamic;
+ l531 = f531 as dynamic;
+ x531 = confuse(f531);
+ l531 = confuse(f531);
+ }
+
+ Expect.isTrue(m531 is F531);
+ Expect.isTrue(m531 is int Function(int y, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m531) is F531);
+ // In checked mode, verifies the type.
+ x531 = m531;
+ l531 = m531;
+ x531 = confuse(m531);
+ l531 = confuse(m531);
+
+ }
+
+ void testF631() {
+ // Function Function([int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f631 is F631);
+ Expect.isTrue(confuse(f631) is F631);
+ // In checked mode, verifies the type.
+ Function Function([int x]) Function<B extends core.int>(int x) l631;
+ // The static function f631 sets `T` to `int`.
+ if (!tIsBool) {
+ x631 = f631 as dynamic;
+ l631 = f631 as dynamic;
+ x631 = confuse(f631);
+ l631 = confuse(f631);
+ }
+
+ Expect.isTrue(m631 is F631);
+ Expect.isTrue(m631 is Function Function([int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m631) is F631);
+ // In checked mode, verifies the type.
+ x631 = m631;
+ l631 = m631;
+ x631 = confuse(m631);
+ l631 = confuse(m631);
+
+ }
+
+ void testF731() {
+ // Function Function(List<Function> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f731 is F731);
+ Expect.isTrue(confuse(f731) is F731);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x1) Function<B extends core.int>(int x) l731;
+ // The static function f731 sets `T` to `int`.
+ if (!tIsBool) {
+ x731 = f731 as dynamic;
+ l731 = f731 as dynamic;
+ x731 = confuse(f731);
+ l731 = confuse(f731);
+ }
+
+ Expect.isTrue(m731 is F731);
+ Expect.isTrue(m731 is Function Function(List<Function> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m731) is F731);
+ // In checked mode, verifies the type.
+ x731 = m731;
+ l731 = m731;
+ x731 = confuse(m731);
+ l731 = confuse(m731);
+
+ }
+
+ void testF831() {
+ // Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f831 is F831);
+ Expect.isTrue(confuse(f831) is F831);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l831;
+ // The static function f831 sets `T` to `int`.
+ if (!tIsBool) {
+ x831 = f831 as dynamic;
+ l831 = f831 as dynamic;
+ x831 = confuse(f831);
+ l831 = confuse(f831);
+ }
+
+ Expect.isTrue(m831 is F831);
+ Expect.isTrue(m831 is Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m831) is F831);
+ // In checked mode, verifies the type.
+ x831 = m831;
+ l831 = m831;
+ x831 = confuse(m831);
+ l831 = confuse(m831);
+ if (!tIsBool) {
+ Expect.isTrue(f831 is F831<int>);
+ Expect.isFalse(f831 is F831<bool>);
+ Expect.isTrue(confuse(f831) is F831<int>);
+ Expect.isFalse(confuse(f831) is F831<bool>);
+ Expect.equals(tIsDynamic, m831 is F831<bool>);
+ Expect.equals(tIsDynamic, confuse(m831) is F831<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x831 = (f831 as dynamic); });
+ Expect.throws(() { x831 = confuse(f831); });
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l831;
+ Expect.throws(() { l831 = (f831 as dynamic); });
+ Expect.throws(() { l831 = confuse(f831); });
+ }
+ Function Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l831 = m831;
+ // In checked mode, verifies the type.
+ x831 = m831;
+ x831 = confuse(m831);
+ }
+ }
+
+ void testF931() {
+ // List<Function> Function(int x1, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f931 is F931);
+ Expect.isTrue(confuse(f931) is F931);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {Function x}) Function<B extends core.int>(int x) l931;
+ // The static function f931 sets `T` to `int`.
+ if (!tIsBool) {
+ x931 = f931 as dynamic;
+ l931 = f931 as dynamic;
+ x931 = confuse(f931);
+ l931 = confuse(f931);
+ }
+
+ Expect.isTrue(m931 is F931);
+ Expect.isTrue(m931 is List<Function> Function(int x1, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m931) is F931);
+ // In checked mode, verifies the type.
+ x931 = m931;
+ l931 = m931;
+ x931 = confuse(m931);
+ l931 = confuse(m931);
+
+ }
+
+ void testF1031() {
+ // List<Function> Function([List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1031 is F1031);
+ Expect.isTrue(confuse(f1031) is F1031);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x]) Function<B extends core.int>(int x) l1031;
+ // The static function f1031 sets `T` to `int`.
+ if (!tIsBool) {
+ x1031 = f1031 as dynamic;
+ l1031 = f1031 as dynamic;
+ x1031 = confuse(f1031);
+ l1031 = confuse(f1031);
+ }
+
+ Expect.isTrue(m1031 is F1031);
+ Expect.isTrue(m1031 is List<Function> Function([List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1031) is F1031);
+ // In checked mode, verifies the type.
+ x1031 = m1031;
+ l1031 = m1031;
+ x1031 = confuse(m1031);
+ l1031 = confuse(m1031);
+ if (!tIsBool) {
+ Expect.isTrue(f1031 is F1031<int>);
+ Expect.isFalse(f1031 is F1031<bool>);
+ Expect.isTrue(confuse(f1031) is F1031<int>);
+ Expect.isFalse(confuse(f1031) is F1031<bool>);
+ Expect.equals(tIsDynamic, m1031 is F1031<bool>);
+ Expect.equals(tIsDynamic, confuse(m1031) is F1031<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1031 = (f1031 as dynamic); });
+ Expect.throws(() { x1031 = confuse(f1031); });
+ List<Function> Function([List<T> x]) Function<B extends core.int>(int x) l1031;
+ Expect.throws(() { l1031 = (f1031 as dynamic); });
+ Expect.throws(() { l1031 = confuse(f1031); });
+ }
+ List<Function> Function([List<T> x]) Function<B extends core.int>(int x) l1031 = m1031;
+ // In checked mode, verifies the type.
+ x1031 = m1031;
+ x1031 = confuse(m1031);
+ }
+ }
+
+ void testF1131() {
+ // core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1131 is F1131);
+ Expect.isTrue(confuse(f1131) is F1131);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>(int x) l1131;
+ // The static function f1131 sets `T` to `int`.
+ if (!tIsBool) {
+ x1131 = f1131 as dynamic;
+ l1131 = f1131 as dynamic;
+ x1131 = confuse(f1131);
+ l1131 = confuse(f1131);
+ }
+
+ Expect.isTrue(m1131 is F1131);
+ Expect.isTrue(m1131 is core.List<core.int> Function(int y, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1131) is F1131);
+ // In checked mode, verifies the type.
+ x1131 = m1131;
+ l1131 = m1131;
+ x1131 = confuse(m1131);
+ l1131 = confuse(m1131);
+
+ }
+
+ void testF1231() {
+ // core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1231 is F1231);
+ Expect.isTrue(confuse(f1231) is F1231);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l1231;
+ // The static function f1231 sets `T` to `int`.
+ if (!tIsBool) {
+ x1231 = f1231 as dynamic;
+ l1231 = f1231 as dynamic;
+ x1231 = confuse(f1231);
+ l1231 = confuse(f1231);
+ }
+
+ Expect.isTrue(m1231 is F1231);
+ Expect.isTrue(m1231 is core.List<core.int> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1231) is F1231);
+ // In checked mode, verifies the type.
+ x1231 = m1231;
+ l1231 = m1231;
+ x1231 = confuse(m1231);
+ l1231 = confuse(m1231);
+
+ }
+
+ void testF1331() {
+ // List<T> Function({int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1331 is F1331);
+ Expect.isTrue(confuse(f1331) is F1331);
+ // In checked mode, verifies the type.
+ List<T> Function({int x}) Function<B extends core.int>(int x) l1331;
+ // The static function f1331 sets `T` to `int`.
+ if (!tIsBool) {
+ x1331 = f1331 as dynamic;
+ l1331 = f1331 as dynamic;
+ x1331 = confuse(f1331);
+ l1331 = confuse(f1331);
+ }
+
+ Expect.isTrue(m1331 is F1331);
+ Expect.isTrue(m1331 is List<T> Function({int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1331) is F1331);
+ // In checked mode, verifies the type.
+ x1331 = m1331;
+ l1331 = m1331;
+ x1331 = confuse(m1331);
+ l1331 = confuse(m1331);
+ if (!tIsBool) {
+ Expect.isTrue(f1331 is F1331<int>);
+ Expect.isFalse(f1331 is F1331<bool>);
+ Expect.isTrue(confuse(f1331) is F1331<int>);
+ Expect.isFalse(confuse(f1331) is F1331<bool>);
+ Expect.equals(tIsDynamic, m1331 is F1331<bool>);
+ Expect.equals(tIsDynamic, confuse(m1331) is F1331<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1331 = (f1331 as dynamic); });
+ Expect.throws(() { x1331 = confuse(f1331); });
+ List<T> Function({int x}) Function<B extends core.int>(int x) l1331;
+ Expect.throws(() { l1331 = (f1331 as dynamic); });
+ Expect.throws(() { l1331 = confuse(f1331); });
+ }
+ List<T> Function({int x}) Function<B extends core.int>(int x) l1331 = m1331;
+ // In checked mode, verifies the type.
+ x1331 = m1331;
+ x1331 = confuse(m1331);
+ }
+ }
+
+ void testF1431() {
+ // List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1431 is F1431);
+ Expect.isTrue(confuse(f1431) is F1431);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x) l1431;
+ // The static function f1431 sets `T` to `int`.
+ if (!tIsBool) {
+ x1431 = f1431 as dynamic;
+ l1431 = f1431 as dynamic;
+ x1431 = confuse(f1431);
+ l1431 = confuse(f1431);
+ }
+
+ Expect.isTrue(m1431 is F1431);
+ Expect.isTrue(m1431 is List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1431) is F1431);
+ // In checked mode, verifies the type.
+ x1431 = m1431;
+ l1431 = m1431;
+ x1431 = confuse(m1431);
+ l1431 = confuse(m1431);
+ if (!tIsBool) {
+ Expect.isTrue(f1431 is F1431<int>);
+ Expect.isFalse(f1431 is F1431<bool>);
+ Expect.isTrue(confuse(f1431) is F1431<int>);
+ Expect.isFalse(confuse(f1431) is F1431<bool>);
+ Expect.equals(tIsDynamic, m1431 is F1431<bool>);
+ Expect.equals(tIsDynamic, confuse(m1431) is F1431<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1431 = (f1431 as dynamic); });
+ Expect.throws(() { x1431 = confuse(f1431); });
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x) l1431;
+ Expect.throws(() { l1431 = (f1431 as dynamic); });
+ Expect.throws(() { l1431 = confuse(f1431); });
+ }
+ List<T> Function(core.List<core.int> x) Function<B extends core.int>(int x) l1431 = m1431;
+ // In checked mode, verifies the type.
+ x1431 = m1431;
+ x1431 = confuse(m1431);
+ }
+ }
+
+ void testF1531() {
+ // Function(int x1, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1531 is F1531);
+ Expect.isTrue(confuse(f1531) is F1531);
+ // In checked mode, verifies the type.
+ Function(int x1, [int x]) Function<B extends core.int>(int x) l1531;
+ // The static function f1531 sets `T` to `int`.
+ if (!tIsBool) {
+ x1531 = f1531 as dynamic;
+ l1531 = f1531 as dynamic;
+ x1531 = confuse(f1531);
+ l1531 = confuse(f1531);
+ }
+
+ Expect.isTrue(m1531 is F1531);
+ Expect.isTrue(m1531 is Function(int x1, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1531) is F1531);
+ // In checked mode, verifies the type.
+ x1531 = m1531;
+ l1531 = m1531;
+ x1531 = confuse(m1531);
+ l1531 = confuse(m1531);
+
+ }
+
+ void testF1631() {
+ // Function([List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1631 is F1631);
+ Expect.isTrue(confuse(f1631) is F1631);
+ // In checked mode, verifies the type.
+ Function([List<Function> x1]) Function<B extends core.int>(int x) l1631;
+ // The static function f1631 sets `T` to `int`.
+ if (!tIsBool) {
+ x1631 = f1631 as dynamic;
+ l1631 = f1631 as dynamic;
+ x1631 = confuse(f1631);
+ l1631 = confuse(f1631);
+ }
+
+ Expect.isTrue(m1631 is F1631);
+ Expect.isTrue(m1631 is Function([List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1631) is F1631);
+ // In checked mode, verifies the type.
+ x1631 = m1631;
+ l1631 = m1631;
+ x1631 = confuse(m1631);
+ l1631 = confuse(m1631);
+
+ }
+
+ void testF1731() {
+ // Function({List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1731 is F1731);
+ Expect.isTrue(confuse(f1731) is F1731);
+ // In checked mode, verifies the type.
+ Function({List<T> x}) Function<B extends core.int>(int x) l1731;
+ // The static function f1731 sets `T` to `int`.
+ if (!tIsBool) {
+ x1731 = f1731 as dynamic;
+ l1731 = f1731 as dynamic;
+ x1731 = confuse(f1731);
+ l1731 = confuse(f1731);
+ }
+
+ Expect.isTrue(m1731 is F1731);
+ Expect.isTrue(m1731 is Function({List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1731) is F1731);
+ // In checked mode, verifies the type.
+ x1731 = m1731;
+ l1731 = m1731;
+ x1731 = confuse(m1731);
+ l1731 = confuse(m1731);
+ if (!tIsBool) {
+ Expect.isTrue(f1731 is F1731<int>);
+ Expect.isFalse(f1731 is F1731<bool>);
+ Expect.isTrue(confuse(f1731) is F1731<int>);
+ Expect.isFalse(confuse(f1731) is F1731<bool>);
+ Expect.equals(tIsDynamic, m1731 is F1731<bool>);
+ Expect.equals(tIsDynamic, confuse(m1731) is F1731<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1731 = (f1731 as dynamic); });
+ Expect.throws(() { x1731 = confuse(f1731); });
+ Function({List<T> x}) Function<B extends core.int>(int x) l1731;
+ Expect.throws(() { l1731 = (f1731 as dynamic); });
+ Expect.throws(() { l1731 = confuse(f1731); });
+ }
+ Function({List<T> x}) Function<B extends core.int>(int x) l1731 = m1731;
+ // In checked mode, verifies the type.
+ x1731 = m1731;
+ x1731 = confuse(m1731);
+ }
+ }
+
+ void testF1831() {
+ // List<Function> Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1831 is F1831);
+ Expect.isTrue(confuse(f1831) is F1831);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>() Function<B extends core.int>(int x) l1831;
+ // The static function f1831 sets `T` to `int`.
+ if (!tIsBool) {
+ x1831 = f1831 as dynamic;
+ l1831 = f1831 as dynamic;
+ x1831 = confuse(f1831);
+ l1831 = confuse(f1831);
+ }
+
+ Expect.isTrue(m1831 is F1831);
+ Expect.isTrue(m1831 is List<Function> Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1831) is F1831);
+ // In checked mode, verifies the type.
+ x1831 = m1831;
+ l1831 = m1831;
+ x1831 = confuse(m1831);
+ l1831 = confuse(m1831);
+
+ }
+
+ void testF1931() {
+ // Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1931 is F1931);
+ Expect.isTrue(confuse(f1931) is F1931);
+ // In checked mode, verifies the type.
+ Function<A>(A x) Function<B extends core.int>(int x) l1931;
+ // The static function f1931 sets `T` to `int`.
+ if (!tIsBool) {
+ x1931 = f1931 as dynamic;
+ l1931 = f1931 as dynamic;
+ x1931 = confuse(f1931);
+ l1931 = confuse(f1931);
+ }
+
+ Expect.isTrue(m1931 is F1931);
+ Expect.isTrue(m1931 is Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1931) is F1931);
+ // In checked mode, verifies the type.
+ x1931 = m1931;
+ l1931 = m1931;
+ x1931 = confuse(m1931);
+ l1931 = confuse(m1931);
+
+ }
+
+
+}
+
+class C32<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, {List<Function> x}) x32;
+ List<Function> Function(int x0, {Function x}) x132;
+ List<T> Function({int x}) x232;
+ Function({List<T> x}) x332;
+ int Function({int x}) Function() x432;
+ int Function(core.List<core.int> x) Function() x532;
+ Function Function(int x0, [int x]) Function() x632;
+ Function Function([List<Function> x1]) Function() x732;
+ Function Function({List<T> x}) Function() x832;
+ List<Function> Function(int y, {Function x}) Function() x932;
+ List<Function> Function(int x0, [List<T> x]) Function() x1032;
+ core.List<core.int> Function(Function x0) Function() x1132;
+ core.List<core.int> Function(int x, [core.List<core.int> x2]) Function() x1232;
+ List<T> Function(int x0, {int x}) Function() x1332;
+ List<T> Function([core.List<core.int> x]) Function() x1432;
+ Function(int y, [int x]) Function() x1532;
+ Function(int x1, [List<Function> x2]) Function() x1632;
+ Function(int x0, {List<T> x}) Function() x1732;
+ List<Function> Function<A>(A x) Function() x1832;
+ Function<A>(List<A> x) Function() x1932;
+
+
+ C32({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m32(int y, {List<Function> x}) => null;
+ List<Function> m132(int x0, {Function x}) => null;
+ List<T> m232({int x}) => null;
+ m332({List<T> x}) => null;
+ int Function({int x}) m432() => null;
+ int Function(core.List<core.int> x) m532() => null;
+ Function Function(int x0, [int x]) m632() => null;
+ Function Function([List<Function> x0]) m732() => null;
+ Function Function({List<T> x}) m832() => null;
+ List<Function> Function(int y, {Function x}) m932() => null;
+ List<Function> Function(int x0, [List<T> x]) m1032() => null;
+ core.List<core.int> Function(Function x0) m1132() => null;
+ core.List<core.int> Function(int x, [core.List<core.int> x0]) m1232() => null;
+ List<T> Function(int x0, {int x}) m1332() => null;
+ List<T> Function([core.List<core.int> x]) m1432() => null;
+ Function(int y, [int x]) m1532() => null;
+ Function(int x0, [List<Function> x1]) m1632() => null;
+ Function(int x0, {List<T> x}) m1732() => null;
+ List<Function> Function<A>(A x) m1832() => null;
+ Function<A>(List<A> x) m1932() => null;
+
+
+ runTests() {
+ testF32();
+ testF132();
+ testF232();
+ testF332();
+ testF432();
+ testF532();
+ testF632();
+ testF732();
+ testF832();
+ testF932();
+ testF1032();
+ testF1132();
+ testF1232();
+ testF1332();
+ testF1432();
+ testF1532();
+ testF1632();
+ testF1732();
+ testF1832();
+ testF1932();
+ }
+
+ void testF32() {
+ // int Function(int y, {List<Function> x})
+ Expect.isTrue(f32 is F32);
+ Expect.isTrue(confuse(f32) is F32);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<Function> x}) l32;
+ // The static function f32 sets `T` to `int`.
+ if (!tIsBool) {
+ x32 = f32 as dynamic;
+ l32 = f32 as dynamic;
+ x32 = confuse(f32);
+ l32 = confuse(f32);
+ }
+
+ Expect.isTrue(m32 is F32);
+ Expect.isTrue(m32 is int Function(int y, {List<Function> x}));
+ Expect.isTrue(confuse(m32) is F32);
+ // In checked mode, verifies the type.
+ x32 = m32;
+ l32 = m32;
+ x32 = confuse(m32);
+ l32 = confuse(m32);
+
+ }
+
+ void testF132() {
+ // List<Function> Function(int x0, {Function x})
+ Expect.isTrue(f132 is F132);
+ Expect.isTrue(confuse(f132) is F132);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {Function x}) l132;
+ // The static function f132 sets `T` to `int`.
+ if (!tIsBool) {
+ x132 = f132 as dynamic;
+ l132 = f132 as dynamic;
+ x132 = confuse(f132);
+ l132 = confuse(f132);
+ }
+
+ Expect.isTrue(m132 is F132);
+ Expect.isTrue(m132 is List<Function> Function(int x0, {Function x}));
+ Expect.isTrue(confuse(m132) is F132);
+ // In checked mode, verifies the type.
+ x132 = m132;
+ l132 = m132;
+ x132 = confuse(m132);
+ l132 = confuse(m132);
+
+ }
+
+ void testF232() {
+ // List<T> Function({int x})
+ Expect.isTrue(f232 is F232);
+ Expect.isTrue(confuse(f232) is F232);
+ // In checked mode, verifies the type.
+ List<T> Function({int x}) l232;
+ // The static function f232 sets `T` to `int`.
+ if (!tIsBool) {
+ x232 = f232 as dynamic;
+ l232 = f232 as dynamic;
+ x232 = confuse(f232);
+ l232 = confuse(f232);
+ }
+
+ Expect.isTrue(m232 is F232);
+ Expect.isTrue(m232 is List<T> Function({int x}));
+ Expect.isTrue(confuse(m232) is F232);
+ // In checked mode, verifies the type.
+ x232 = m232;
+ l232 = m232;
+ x232 = confuse(m232);
+ l232 = confuse(m232);
+ if (!tIsBool) {
+ Expect.isTrue(f232 is F232<int>);
+ Expect.isFalse(f232 is F232<bool>);
+ Expect.isTrue(confuse(f232) is F232<int>);
+ Expect.isFalse(confuse(f232) is F232<bool>);
+ Expect.equals(tIsDynamic, m232 is F232<bool>);
+ Expect.equals(tIsDynamic, confuse(m232) is F232<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x232 = (f232 as dynamic); });
+ Expect.throws(() { x232 = confuse(f232); });
+ List<T> Function({int x}) l232;
+ Expect.throws(() { l232 = (f232 as dynamic); });
+ Expect.throws(() { l232 = confuse(f232); });
+ }
+ List<T> Function({int x}) l232 = m232;
+ // In checked mode, verifies the type.
+ x232 = m232;
+ x232 = confuse(m232);
+ }
+ }
+
+ void testF332() {
+ // Function({List<T> x})
+ Expect.isTrue(f332 is F332);
+ Expect.isTrue(confuse(f332) is F332);
+ // In checked mode, verifies the type.
+ Function({List<T> x}) l332;
+ // The static function f332 sets `T` to `int`.
+ if (!tIsBool) {
+ x332 = f332 as dynamic;
+ l332 = f332 as dynamic;
+ x332 = confuse(f332);
+ l332 = confuse(f332);
+ }
+
+ Expect.isTrue(m332 is F332);
+ Expect.isTrue(m332 is Function({List<T> x}));
+ Expect.isTrue(confuse(m332) is F332);
+ // In checked mode, verifies the type.
+ x332 = m332;
+ l332 = m332;
+ x332 = confuse(m332);
+ l332 = confuse(m332);
+ if (!tIsBool) {
+ Expect.isTrue(f332 is F332<int>);
+ Expect.isFalse(f332 is F332<bool>);
+ Expect.isTrue(confuse(f332) is F332<int>);
+ Expect.isFalse(confuse(f332) is F332<bool>);
+ Expect.equals(tIsDynamic, m332 is F332<bool>);
+ Expect.equals(tIsDynamic, confuse(m332) is F332<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x332 = (f332 as dynamic); });
+ Expect.throws(() { x332 = confuse(f332); });
+ Function({List<T> x}) l332;
+ Expect.throws(() { l332 = (f332 as dynamic); });
+ Expect.throws(() { l332 = confuse(f332); });
+ }
+ Function({List<T> x}) l332 = m332;
+ // In checked mode, verifies the type.
+ x332 = m332;
+ x332 = confuse(m332);
+ }
+ }
+
+ void testF432() {
+ // int Function({int x}) Function()
+ Expect.isTrue(f432 is F432);
+ Expect.isTrue(confuse(f432) is F432);
+ // In checked mode, verifies the type.
+ int Function({int x}) Function() l432;
+ // The static function f432 sets `T` to `int`.
+ if (!tIsBool) {
+ x432 = f432 as dynamic;
+ l432 = f432 as dynamic;
+ x432 = confuse(f432);
+ l432 = confuse(f432);
+ }
+
+ Expect.isTrue(m432 is F432);
+ Expect.isTrue(m432 is int Function({int x}) Function());
+ Expect.isTrue(confuse(m432) is F432);
+ // In checked mode, verifies the type.
+ x432 = m432;
+ l432 = m432;
+ x432 = confuse(m432);
+ l432 = confuse(m432);
+
+ }
+
+ void testF532() {
+ // int Function(core.List<core.int> x) Function()
+ Expect.isTrue(f532 is F532);
+ Expect.isTrue(confuse(f532) is F532);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x) Function() l532;
+ // The static function f532 sets `T` to `int`.
+ if (!tIsBool) {
+ x532 = f532 as dynamic;
+ l532 = f532 as dynamic;
+ x532 = confuse(f532);
+ l532 = confuse(f532);
+ }
+
+ Expect.isTrue(m532 is F532);
+ Expect.isTrue(m532 is int Function(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m532) is F532);
+ // In checked mode, verifies the type.
+ x532 = m532;
+ l532 = m532;
+ x532 = confuse(m532);
+ l532 = confuse(m532);
+
+ }
+
+ void testF632() {
+ // Function Function(int x0, [int x]) Function()
+ Expect.isTrue(f632 is F632);
+ Expect.isTrue(confuse(f632) is F632);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [int x]) Function() l632;
+ // The static function f632 sets `T` to `int`.
+ if (!tIsBool) {
+ x632 = f632 as dynamic;
+ l632 = f632 as dynamic;
+ x632 = confuse(f632);
+ l632 = confuse(f632);
+ }
+
+ Expect.isTrue(m632 is F632);
+ Expect.isTrue(m632 is Function Function(int x0, [int x]) Function());
+ Expect.isTrue(confuse(m632) is F632);
+ // In checked mode, verifies the type.
+ x632 = m632;
+ l632 = m632;
+ x632 = confuse(m632);
+ l632 = confuse(m632);
+
+ }
+
+ void testF732() {
+ // Function Function([List<Function> x1]) Function()
+ Expect.isTrue(f732 is F732);
+ Expect.isTrue(confuse(f732) is F732);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x1]) Function() l732;
+ // The static function f732 sets `T` to `int`.
+ if (!tIsBool) {
+ x732 = f732 as dynamic;
+ l732 = f732 as dynamic;
+ x732 = confuse(f732);
+ l732 = confuse(f732);
+ }
+
+ Expect.isTrue(m732 is F732);
+ Expect.isTrue(m732 is Function Function([List<Function> x1]) Function());
+ Expect.isTrue(confuse(m732) is F732);
+ // In checked mode, verifies the type.
+ x732 = m732;
+ l732 = m732;
+ x732 = confuse(m732);
+ l732 = confuse(m732);
+
+ }
+
+ void testF832() {
+ // Function Function({List<T> x}) Function()
+ Expect.isTrue(f832 is F832);
+ Expect.isTrue(confuse(f832) is F832);
+ // In checked mode, verifies the type.
+ Function Function({List<T> x}) Function() l832;
+ // The static function f832 sets `T` to `int`.
+ if (!tIsBool) {
+ x832 = f832 as dynamic;
+ l832 = f832 as dynamic;
+ x832 = confuse(f832);
+ l832 = confuse(f832);
+ }
+
+ Expect.isTrue(m832 is F832);
+ Expect.isTrue(m832 is Function Function({List<T> x}) Function());
+ Expect.isTrue(confuse(m832) is F832);
+ // In checked mode, verifies the type.
+ x832 = m832;
+ l832 = m832;
+ x832 = confuse(m832);
+ l832 = confuse(m832);
+ if (!tIsBool) {
+ Expect.isTrue(f832 is F832<int>);
+ Expect.isFalse(f832 is F832<bool>);
+ Expect.isTrue(confuse(f832) is F832<int>);
+ Expect.isFalse(confuse(f832) is F832<bool>);
+ Expect.equals(tIsDynamic, m832 is F832<bool>);
+ Expect.equals(tIsDynamic, confuse(m832) is F832<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x832 = (f832 as dynamic); });
+ Expect.throws(() { x832 = confuse(f832); });
+ Function Function({List<T> x}) Function() l832;
+ Expect.throws(() { l832 = (f832 as dynamic); });
+ Expect.throws(() { l832 = confuse(f832); });
+ }
+ Function Function({List<T> x}) Function() l832 = m832;
+ // In checked mode, verifies the type.
+ x832 = m832;
+ x832 = confuse(m832);
+ }
+ }
+
+ void testF932() {
+ // List<Function> Function(int y, {Function x}) Function()
+ Expect.isTrue(f932 is F932);
+ Expect.isTrue(confuse(f932) is F932);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {Function x}) Function() l932;
+ // The static function f932 sets `T` to `int`.
+ if (!tIsBool) {
+ x932 = f932 as dynamic;
+ l932 = f932 as dynamic;
+ x932 = confuse(f932);
+ l932 = confuse(f932);
+ }
+
+ Expect.isTrue(m932 is F932);
+ Expect.isTrue(m932 is List<Function> Function(int y, {Function x}) Function());
+ Expect.isTrue(confuse(m932) is F932);
+ // In checked mode, verifies the type.
+ x932 = m932;
+ l932 = m932;
+ x932 = confuse(m932);
+ l932 = confuse(m932);
+
+ }
+
+ void testF1032() {
+ // List<Function> Function(int x0, [List<T> x]) Function()
+ Expect.isTrue(f1032 is F1032);
+ Expect.isTrue(confuse(f1032) is F1032);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [List<T> x]) Function() l1032;
+ // The static function f1032 sets `T` to `int`.
+ if (!tIsBool) {
+ x1032 = f1032 as dynamic;
+ l1032 = f1032 as dynamic;
+ x1032 = confuse(f1032);
+ l1032 = confuse(f1032);
+ }
+
+ Expect.isTrue(m1032 is F1032);
+ Expect.isTrue(m1032 is List<Function> Function(int x0, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1032) is F1032);
+ // In checked mode, verifies the type.
+ x1032 = m1032;
+ l1032 = m1032;
+ x1032 = confuse(m1032);
+ l1032 = confuse(m1032);
+ if (!tIsBool) {
+ Expect.isTrue(f1032 is F1032<int>);
+ Expect.isFalse(f1032 is F1032<bool>);
+ Expect.isTrue(confuse(f1032) is F1032<int>);
+ Expect.isFalse(confuse(f1032) is F1032<bool>);
+ Expect.equals(tIsDynamic, m1032 is F1032<bool>);
+ Expect.equals(tIsDynamic, confuse(m1032) is F1032<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1032 = (f1032 as dynamic); });
+ Expect.throws(() { x1032 = confuse(f1032); });
+ List<Function> Function(int x0, [List<T> x]) Function() l1032;
+ Expect.throws(() { l1032 = (f1032 as dynamic); });
+ Expect.throws(() { l1032 = confuse(f1032); });
+ }
+ List<Function> Function(int x0, [List<T> x]) Function() l1032 = m1032;
+ // In checked mode, verifies the type.
+ x1032 = m1032;
+ x1032 = confuse(m1032);
+ }
+ }
+
+ void testF1132() {
+ // core.List<core.int> Function(Function x0) Function()
+ Expect.isTrue(f1132 is F1132);
+ Expect.isTrue(confuse(f1132) is F1132);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x0) Function() l1132;
+ // The static function f1132 sets `T` to `int`.
+ if (!tIsBool) {
+ x1132 = f1132 as dynamic;
+ l1132 = f1132 as dynamic;
+ x1132 = confuse(f1132);
+ l1132 = confuse(f1132);
+ }
+
+ Expect.isTrue(m1132 is F1132);
+ Expect.isTrue(m1132 is core.List<core.int> Function(Function x0) Function());
+ Expect.isTrue(confuse(m1132) is F1132);
+ // In checked mode, verifies the type.
+ x1132 = m1132;
+ l1132 = m1132;
+ x1132 = confuse(m1132);
+ l1132 = confuse(m1132);
+
+ }
+
+ void testF1232() {
+ // core.List<core.int> Function(int x, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1232 is F1232);
+ Expect.isTrue(confuse(f1232) is F1232);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [core.List<core.int> x2]) Function() l1232;
+ // The static function f1232 sets `T` to `int`.
+ if (!tIsBool) {
+ x1232 = f1232 as dynamic;
+ l1232 = f1232 as dynamic;
+ x1232 = confuse(f1232);
+ l1232 = confuse(f1232);
+ }
+
+ Expect.isTrue(m1232 is F1232);
+ Expect.isTrue(m1232 is core.List<core.int> Function(int x, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1232) is F1232);
+ // In checked mode, verifies the type.
+ x1232 = m1232;
+ l1232 = m1232;
+ x1232 = confuse(m1232);
+ l1232 = confuse(m1232);
+
+ }
+
+ void testF1332() {
+ // List<T> Function(int x0, {int x}) Function()
+ Expect.isTrue(f1332 is F1332);
+ Expect.isTrue(confuse(f1332) is F1332);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {int x}) Function() l1332;
+ // The static function f1332 sets `T` to `int`.
+ if (!tIsBool) {
+ x1332 = f1332 as dynamic;
+ l1332 = f1332 as dynamic;
+ x1332 = confuse(f1332);
+ l1332 = confuse(f1332);
+ }
+
+ Expect.isTrue(m1332 is F1332);
+ Expect.isTrue(m1332 is List<T> Function(int x0, {int x}) Function());
+ Expect.isTrue(confuse(m1332) is F1332);
+ // In checked mode, verifies the type.
+ x1332 = m1332;
+ l1332 = m1332;
+ x1332 = confuse(m1332);
+ l1332 = confuse(m1332);
+ if (!tIsBool) {
+ Expect.isTrue(f1332 is F1332<int>);
+ Expect.isFalse(f1332 is F1332<bool>);
+ Expect.isTrue(confuse(f1332) is F1332<int>);
+ Expect.isFalse(confuse(f1332) is F1332<bool>);
+ Expect.equals(tIsDynamic, m1332 is F1332<bool>);
+ Expect.equals(tIsDynamic, confuse(m1332) is F1332<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1332 = (f1332 as dynamic); });
+ Expect.throws(() { x1332 = confuse(f1332); });
+ List<T> Function(int x0, {int x}) Function() l1332;
+ Expect.throws(() { l1332 = (f1332 as dynamic); });
+ Expect.throws(() { l1332 = confuse(f1332); });
+ }
+ List<T> Function(int x0, {int x}) Function() l1332 = m1332;
+ // In checked mode, verifies the type.
+ x1332 = m1332;
+ x1332 = confuse(m1332);
+ }
+ }
+
+ void testF1432() {
+ // List<T> Function([core.List<core.int> x]) Function()
+ Expect.isTrue(f1432 is F1432);
+ Expect.isTrue(confuse(f1432) is F1432);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x]) Function() l1432;
+ // The static function f1432 sets `T` to `int`.
+ if (!tIsBool) {
+ x1432 = f1432 as dynamic;
+ l1432 = f1432 as dynamic;
+ x1432 = confuse(f1432);
+ l1432 = confuse(f1432);
+ }
+
+ Expect.isTrue(m1432 is F1432);
+ Expect.isTrue(m1432 is List<T> Function([core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1432) is F1432);
+ // In checked mode, verifies the type.
+ x1432 = m1432;
+ l1432 = m1432;
+ x1432 = confuse(m1432);
+ l1432 = confuse(m1432);
+ if (!tIsBool) {
+ Expect.isTrue(f1432 is F1432<int>);
+ Expect.isFalse(f1432 is F1432<bool>);
+ Expect.isTrue(confuse(f1432) is F1432<int>);
+ Expect.isFalse(confuse(f1432) is F1432<bool>);
+ Expect.equals(tIsDynamic, m1432 is F1432<bool>);
+ Expect.equals(tIsDynamic, confuse(m1432) is F1432<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1432 = (f1432 as dynamic); });
+ Expect.throws(() { x1432 = confuse(f1432); });
+ List<T> Function([core.List<core.int> x]) Function() l1432;
+ Expect.throws(() { l1432 = (f1432 as dynamic); });
+ Expect.throws(() { l1432 = confuse(f1432); });
+ }
+ List<T> Function([core.List<core.int> x]) Function() l1432 = m1432;
+ // In checked mode, verifies the type.
+ x1432 = m1432;
+ x1432 = confuse(m1432);
+ }
+ }
+
+ void testF1532() {
+ // Function(int y, [int x]) Function()
+ Expect.isTrue(f1532 is F1532);
+ Expect.isTrue(confuse(f1532) is F1532);
+ // In checked mode, verifies the type.
+ Function(int y, [int x]) Function() l1532;
+ // The static function f1532 sets `T` to `int`.
+ if (!tIsBool) {
+ x1532 = f1532 as dynamic;
+ l1532 = f1532 as dynamic;
+ x1532 = confuse(f1532);
+ l1532 = confuse(f1532);
+ }
+
+ Expect.isTrue(m1532 is F1532);
+ Expect.isTrue(m1532 is Function(int y, [int x]) Function());
+ Expect.isTrue(confuse(m1532) is F1532);
+ // In checked mode, verifies the type.
+ x1532 = m1532;
+ l1532 = m1532;
+ x1532 = confuse(m1532);
+ l1532 = confuse(m1532);
+
+ }
+
+ void testF1632() {
+ // Function(int x1, [List<Function> x2]) Function()
+ Expect.isTrue(f1632 is F1632);
+ Expect.isTrue(confuse(f1632) is F1632);
+ // In checked mode, verifies the type.
+ Function(int x1, [List<Function> x2]) Function() l1632;
+ // The static function f1632 sets `T` to `int`.
+ if (!tIsBool) {
+ x1632 = f1632 as dynamic;
+ l1632 = f1632 as dynamic;
+ x1632 = confuse(f1632);
+ l1632 = confuse(f1632);
+ }
+
+ Expect.isTrue(m1632 is F1632);
+ Expect.isTrue(m1632 is Function(int x1, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m1632) is F1632);
+ // In checked mode, verifies the type.
+ x1632 = m1632;
+ l1632 = m1632;
+ x1632 = confuse(m1632);
+ l1632 = confuse(m1632);
+
+ }
+
+ void testF1732() {
+ // Function(int x0, {List<T> x}) Function()
+ Expect.isTrue(f1732 is F1732);
+ Expect.isTrue(confuse(f1732) is F1732);
+ // In checked mode, verifies the type.
+ Function(int x0, {List<T> x}) Function() l1732;
+ // The static function f1732 sets `T` to `int`.
+ if (!tIsBool) {
+ x1732 = f1732 as dynamic;
+ l1732 = f1732 as dynamic;
+ x1732 = confuse(f1732);
+ l1732 = confuse(f1732);
+ }
+
+ Expect.isTrue(m1732 is F1732);
+ Expect.isTrue(m1732 is Function(int x0, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1732) is F1732);
+ // In checked mode, verifies the type.
+ x1732 = m1732;
+ l1732 = m1732;
+ x1732 = confuse(m1732);
+ l1732 = confuse(m1732);
+ if (!tIsBool) {
+ Expect.isTrue(f1732 is F1732<int>);
+ Expect.isFalse(f1732 is F1732<bool>);
+ Expect.isTrue(confuse(f1732) is F1732<int>);
+ Expect.isFalse(confuse(f1732) is F1732<bool>);
+ Expect.equals(tIsDynamic, m1732 is F1732<bool>);
+ Expect.equals(tIsDynamic, confuse(m1732) is F1732<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1732 = (f1732 as dynamic); });
+ Expect.throws(() { x1732 = confuse(f1732); });
+ Function(int x0, {List<T> x}) Function() l1732;
+ Expect.throws(() { l1732 = (f1732 as dynamic); });
+ Expect.throws(() { l1732 = confuse(f1732); });
+ }
+ Function(int x0, {List<T> x}) Function() l1732 = m1732;
+ // In checked mode, verifies the type.
+ x1732 = m1732;
+ x1732 = confuse(m1732);
+ }
+ }
+
+ void testF1832() {
+ // List<Function> Function<A>(A x) Function()
+ Expect.isTrue(f1832 is F1832);
+ Expect.isTrue(confuse(f1832) is F1832);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(A x) Function() l1832;
+ // The static function f1832 sets `T` to `int`.
+ if (!tIsBool) {
+ x1832 = f1832 as dynamic;
+ l1832 = f1832 as dynamic;
+ x1832 = confuse(f1832);
+ l1832 = confuse(f1832);
+ }
+
+ Expect.isTrue(m1832 is F1832);
+ Expect.isTrue(m1832 is List<Function> Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1832) is F1832);
+ // In checked mode, verifies the type.
+ x1832 = m1832;
+ l1832 = m1832;
+ x1832 = confuse(m1832);
+ l1832 = confuse(m1832);
+
+ }
+
+ void testF1932() {
+ // Function<A>(List<A> x) Function()
+ Expect.isTrue(f1932 is F1932);
+ Expect.isTrue(confuse(f1932) is F1932);
+ // In checked mode, verifies the type.
+ Function<A>(List<A> x) Function() l1932;
+ // The static function f1932 sets `T` to `int`.
+ if (!tIsBool) {
+ x1932 = f1932 as dynamic;
+ l1932 = f1932 as dynamic;
+ x1932 = confuse(f1932);
+ l1932 = confuse(f1932);
+ }
+
+ Expect.isTrue(m1932 is F1932);
+ Expect.isTrue(m1932 is Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1932) is F1932);
+ // In checked mode, verifies the type.
+ x1932 = m1932;
+ l1932 = m1932;
+ x1932 = confuse(m1932);
+ l1932 = confuse(m1932);
+
+ }
+
+
+}
+
+class C33<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(core.List<core.int> x) x33;
+ List<Function> Function(int y, {Function x}) x133;
+ List<T> Function(int x0, {int x}) x233;
+ Function(int x0, {List<T> x}) x333;
+ int Function({int x}) Function(int x) x433;
+ int Function(core.List<core.int> x) Function(int x) x533;
+ Function Function(int x1, [int x]) Function(int x) x633;
+ Function Function([List<Function> x1]) Function(int x) x733;
+ Function Function({List<T> x}) Function(int x) x833;
+ List<Function> Function(int y, {Function x}) Function(int x) x933;
+ List<Function> Function(int x1, [List<T> x]) Function(int x) x1033;
+ core.List<core.int> Function(Function x1) Function(int x) x1133;
+ core.List<core.int> Function(int x, [core.List<core.int> x1]) Function(int x) x1233;
+ List<T> Function(int x1, {int x}) Function(int x) x1333;
+ List<T> Function([core.List<core.int> x]) Function(int x) x1433;
+ Function(int y, [int x]) Function(int x) x1533;
+ Function(int x2, [List<Function> x3]) Function(int x) x1633;
+ Function(int x1, {List<T> x}) Function(int x) x1733;
+ List<Function> Function<A>(A x) Function(int x) x1833;
+ Function<A>(List<A> x) Function(int x) x1933;
+
+
+ C33({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m33(core.List<core.int> x) => null;
+ List<Function> m133(int y, {Function x}) => null;
+ List<T> m233(int x0, {int x}) => null;
+ m333(int x0, {List<T> x}) => null;
+ int Function({int x}) m433(int x) => null;
+ int Function(core.List<core.int> x) m533(int x) => null;
+ Function Function(int x0, [int x]) m633(int x) => null;
+ Function Function([List<Function> x0]) m733(int x) => null;
+ Function Function({List<T> x}) m833(int x) => null;
+ List<Function> Function(int y, {Function x}) m933(int x) => null;
+ List<Function> Function(int x0, [List<T> x]) m1033(int x) => null;
+ core.List<core.int> Function(Function x0) m1133(int x) => null;
+ core.List<core.int> Function(int x, [core.List<core.int> x0]) m1233(int x) => null;
+ List<T> Function(int x0, {int x}) m1333(int x) => null;
+ List<T> Function([core.List<core.int> x]) m1433(int x) => null;
+ Function(int y, [int x]) m1533(int x) => null;
+ Function(int x0, [List<Function> x1]) m1633(int x) => null;
+ Function(int x0, {List<T> x}) m1733(int x) => null;
+ List<Function> Function<A>(A x) m1833(int x) => null;
+ Function<A>(List<A> x) m1933(int x) => null;
+
+
+ runTests() {
+ testF33();
+ testF133();
+ testF233();
+ testF333();
+ testF433();
+ testF533();
+ testF633();
+ testF733();
+ testF833();
+ testF933();
+ testF1033();
+ testF1133();
+ testF1233();
+ testF1333();
+ testF1433();
+ testF1533();
+ testF1633();
+ testF1733();
+ testF1833();
+ testF1933();
+ }
+
+ void testF33() {
+ // int Function(core.List<core.int> x)
+ Expect.isTrue(f33 is F33);
+ Expect.isTrue(confuse(f33) is F33);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x) l33;
+ // The static function f33 sets `T` to `int`.
+ if (!tIsBool) {
+ x33 = f33 as dynamic;
+ l33 = f33 as dynamic;
+ x33 = confuse(f33);
+ l33 = confuse(f33);
+ }
+
+ Expect.isTrue(m33 is F33);
+ Expect.isTrue(m33 is int Function(core.List<core.int> x));
+ Expect.isTrue(confuse(m33) is F33);
+ // In checked mode, verifies the type.
+ x33 = m33;
+ l33 = m33;
+ x33 = confuse(m33);
+ l33 = confuse(m33);
+
+ }
+
+ void testF133() {
+ // List<Function> Function(int y, {Function x})
+ Expect.isTrue(f133 is F133);
+ Expect.isTrue(confuse(f133) is F133);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {Function x}) l133;
+ // The static function f133 sets `T` to `int`.
+ if (!tIsBool) {
+ x133 = f133 as dynamic;
+ l133 = f133 as dynamic;
+ x133 = confuse(f133);
+ l133 = confuse(f133);
+ }
+
+ Expect.isTrue(m133 is F133);
+ Expect.isTrue(m133 is List<Function> Function(int y, {Function x}));
+ Expect.isTrue(confuse(m133) is F133);
+ // In checked mode, verifies the type.
+ x133 = m133;
+ l133 = m133;
+ x133 = confuse(m133);
+ l133 = confuse(m133);
+
+ }
+
+ void testF233() {
+ // List<T> Function(int x0, {int x})
+ Expect.isTrue(f233 is F233);
+ Expect.isTrue(confuse(f233) is F233);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {int x}) l233;
+ // The static function f233 sets `T` to `int`.
+ if (!tIsBool) {
+ x233 = f233 as dynamic;
+ l233 = f233 as dynamic;
+ x233 = confuse(f233);
+ l233 = confuse(f233);
+ }
+
+ Expect.isTrue(m233 is F233);
+ Expect.isTrue(m233 is List<T> Function(int x0, {int x}));
+ Expect.isTrue(confuse(m233) is F233);
+ // In checked mode, verifies the type.
+ x233 = m233;
+ l233 = m233;
+ x233 = confuse(m233);
+ l233 = confuse(m233);
+ if (!tIsBool) {
+ Expect.isTrue(f233 is F233<int>);
+ Expect.isFalse(f233 is F233<bool>);
+ Expect.isTrue(confuse(f233) is F233<int>);
+ Expect.isFalse(confuse(f233) is F233<bool>);
+ Expect.equals(tIsDynamic, m233 is F233<bool>);
+ Expect.equals(tIsDynamic, confuse(m233) is F233<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x233 = (f233 as dynamic); });
+ Expect.throws(() { x233 = confuse(f233); });
+ List<T> Function(int x0, {int x}) l233;
+ Expect.throws(() { l233 = (f233 as dynamic); });
+ Expect.throws(() { l233 = confuse(f233); });
+ }
+ List<T> Function(int x0, {int x}) l233 = m233;
+ // In checked mode, verifies the type.
+ x233 = m233;
+ x233 = confuse(m233);
+ }
+ }
+
+ void testF333() {
+ // Function(int x0, {List<T> x})
+ Expect.isTrue(f333 is F333);
+ Expect.isTrue(confuse(f333) is F333);
+ // In checked mode, verifies the type.
+ Function(int x0, {List<T> x}) l333;
+ // The static function f333 sets `T` to `int`.
+ if (!tIsBool) {
+ x333 = f333 as dynamic;
+ l333 = f333 as dynamic;
+ x333 = confuse(f333);
+ l333 = confuse(f333);
+ }
+
+ Expect.isTrue(m333 is F333);
+ Expect.isTrue(m333 is Function(int x0, {List<T> x}));
+ Expect.isTrue(confuse(m333) is F333);
+ // In checked mode, verifies the type.
+ x333 = m333;
+ l333 = m333;
+ x333 = confuse(m333);
+ l333 = confuse(m333);
+ if (!tIsBool) {
+ Expect.isTrue(f333 is F333<int>);
+ Expect.isFalse(f333 is F333<bool>);
+ Expect.isTrue(confuse(f333) is F333<int>);
+ Expect.isFalse(confuse(f333) is F333<bool>);
+ Expect.equals(tIsDynamic, m333 is F333<bool>);
+ Expect.equals(tIsDynamic, confuse(m333) is F333<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x333 = (f333 as dynamic); });
+ Expect.throws(() { x333 = confuse(f333); });
+ Function(int x0, {List<T> x}) l333;
+ Expect.throws(() { l333 = (f333 as dynamic); });
+ Expect.throws(() { l333 = confuse(f333); });
+ }
+ Function(int x0, {List<T> x}) l333 = m333;
+ // In checked mode, verifies the type.
+ x333 = m333;
+ x333 = confuse(m333);
+ }
+ }
+
+ void testF433() {
+ // int Function({int x}) Function(int x)
+ Expect.isTrue(f433 is F433);
+ Expect.isTrue(confuse(f433) is F433);
+ // In checked mode, verifies the type.
+ int Function({int x}) Function(int x) l433;
+ // The static function f433 sets `T` to `int`.
+ if (!tIsBool) {
+ x433 = f433 as dynamic;
+ l433 = f433 as dynamic;
+ x433 = confuse(f433);
+ l433 = confuse(f433);
+ }
+
+ Expect.isTrue(m433 is F433);
+ Expect.isTrue(m433 is int Function({int x}) Function(int x));
+ Expect.isTrue(confuse(m433) is F433);
+ // In checked mode, verifies the type.
+ x433 = m433;
+ l433 = m433;
+ x433 = confuse(m433);
+ l433 = confuse(m433);
+
+ }
+
+ void testF533() {
+ // int Function(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f533 is F533);
+ Expect.isTrue(confuse(f533) is F533);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x) Function(int x) l533;
+ // The static function f533 sets `T` to `int`.
+ if (!tIsBool) {
+ x533 = f533 as dynamic;
+ l533 = f533 as dynamic;
+ x533 = confuse(f533);
+ l533 = confuse(f533);
+ }
+
+ Expect.isTrue(m533 is F533);
+ Expect.isTrue(m533 is int Function(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m533) is F533);
+ // In checked mode, verifies the type.
+ x533 = m533;
+ l533 = m533;
+ x533 = confuse(m533);
+ l533 = confuse(m533);
+
+ }
+
+ void testF633() {
+ // Function Function(int x1, [int x]) Function(int x)
+ Expect.isTrue(f633 is F633);
+ Expect.isTrue(confuse(f633) is F633);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [int x]) Function(int x) l633;
+ // The static function f633 sets `T` to `int`.
+ if (!tIsBool) {
+ x633 = f633 as dynamic;
+ l633 = f633 as dynamic;
+ x633 = confuse(f633);
+ l633 = confuse(f633);
+ }
+
+ Expect.isTrue(m633 is F633);
+ Expect.isTrue(m633 is Function Function(int x1, [int x]) Function(int x));
+ Expect.isTrue(confuse(m633) is F633);
+ // In checked mode, verifies the type.
+ x633 = m633;
+ l633 = m633;
+ x633 = confuse(m633);
+ l633 = confuse(m633);
+
+ }
+
+ void testF733() {
+ // Function Function([List<Function> x1]) Function(int x)
+ Expect.isTrue(f733 is F733);
+ Expect.isTrue(confuse(f733) is F733);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x1]) Function(int x) l733;
+ // The static function f733 sets `T` to `int`.
+ if (!tIsBool) {
+ x733 = f733 as dynamic;
+ l733 = f733 as dynamic;
+ x733 = confuse(f733);
+ l733 = confuse(f733);
+ }
+
+ Expect.isTrue(m733 is F733);
+ Expect.isTrue(m733 is Function Function([List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m733) is F733);
+ // In checked mode, verifies the type.
+ x733 = m733;
+ l733 = m733;
+ x733 = confuse(m733);
+ l733 = confuse(m733);
+
+ }
+
+ void testF833() {
+ // Function Function({List<T> x}) Function(int x)
+ Expect.isTrue(f833 is F833);
+ Expect.isTrue(confuse(f833) is F833);
+ // In checked mode, verifies the type.
+ Function Function({List<T> x}) Function(int x) l833;
+ // The static function f833 sets `T` to `int`.
+ if (!tIsBool) {
+ x833 = f833 as dynamic;
+ l833 = f833 as dynamic;
+ x833 = confuse(f833);
+ l833 = confuse(f833);
+ }
+
+ Expect.isTrue(m833 is F833);
+ Expect.isTrue(m833 is Function Function({List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m833) is F833);
+ // In checked mode, verifies the type.
+ x833 = m833;
+ l833 = m833;
+ x833 = confuse(m833);
+ l833 = confuse(m833);
+ if (!tIsBool) {
+ Expect.isTrue(f833 is F833<int>);
+ Expect.isFalse(f833 is F833<bool>);
+ Expect.isTrue(confuse(f833) is F833<int>);
+ Expect.isFalse(confuse(f833) is F833<bool>);
+ Expect.equals(tIsDynamic, m833 is F833<bool>);
+ Expect.equals(tIsDynamic, confuse(m833) is F833<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x833 = (f833 as dynamic); });
+ Expect.throws(() { x833 = confuse(f833); });
+ Function Function({List<T> x}) Function(int x) l833;
+ Expect.throws(() { l833 = (f833 as dynamic); });
+ Expect.throws(() { l833 = confuse(f833); });
+ }
+ Function Function({List<T> x}) Function(int x) l833 = m833;
+ // In checked mode, verifies the type.
+ x833 = m833;
+ x833 = confuse(m833);
+ }
+ }
+
+ void testF933() {
+ // List<Function> Function(int y, {Function x}) Function(int x)
+ Expect.isTrue(f933 is F933);
+ Expect.isTrue(confuse(f933) is F933);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {Function x}) Function(int x) l933;
+ // The static function f933 sets `T` to `int`.
+ if (!tIsBool) {
+ x933 = f933 as dynamic;
+ l933 = f933 as dynamic;
+ x933 = confuse(f933);
+ l933 = confuse(f933);
+ }
+
+ Expect.isTrue(m933 is F933);
+ Expect.isTrue(m933 is List<Function> Function(int y, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m933) is F933);
+ // In checked mode, verifies the type.
+ x933 = m933;
+ l933 = m933;
+ x933 = confuse(m933);
+ l933 = confuse(m933);
+
+ }
+
+ void testF1033() {
+ // List<Function> Function(int x1, [List<T> x]) Function(int x)
+ Expect.isTrue(f1033 is F1033);
+ Expect.isTrue(confuse(f1033) is F1033);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<T> x]) Function(int x) l1033;
+ // The static function f1033 sets `T` to `int`.
+ if (!tIsBool) {
+ x1033 = f1033 as dynamic;
+ l1033 = f1033 as dynamic;
+ x1033 = confuse(f1033);
+ l1033 = confuse(f1033);
+ }
+
+ Expect.isTrue(m1033 is F1033);
+ Expect.isTrue(m1033 is List<Function> Function(int x1, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1033) is F1033);
+ // In checked mode, verifies the type.
+ x1033 = m1033;
+ l1033 = m1033;
+ x1033 = confuse(m1033);
+ l1033 = confuse(m1033);
+ if (!tIsBool) {
+ Expect.isTrue(f1033 is F1033<int>);
+ Expect.isFalse(f1033 is F1033<bool>);
+ Expect.isTrue(confuse(f1033) is F1033<int>);
+ Expect.isFalse(confuse(f1033) is F1033<bool>);
+ Expect.equals(tIsDynamic, m1033 is F1033<bool>);
+ Expect.equals(tIsDynamic, confuse(m1033) is F1033<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1033 = (f1033 as dynamic); });
+ Expect.throws(() { x1033 = confuse(f1033); });
+ List<Function> Function(int x1, [List<T> x]) Function(int x) l1033;
+ Expect.throws(() { l1033 = (f1033 as dynamic); });
+ Expect.throws(() { l1033 = confuse(f1033); });
+ }
+ List<Function> Function(int x1, [List<T> x]) Function(int x) l1033 = m1033;
+ // In checked mode, verifies the type.
+ x1033 = m1033;
+ x1033 = confuse(m1033);
+ }
+ }
+
+ void testF1133() {
+ // core.List<core.int> Function(Function x1) Function(int x)
+ Expect.isTrue(f1133 is F1133);
+ Expect.isTrue(confuse(f1133) is F1133);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x1) Function(int x) l1133;
+ // The static function f1133 sets `T` to `int`.
+ if (!tIsBool) {
+ x1133 = f1133 as dynamic;
+ l1133 = f1133 as dynamic;
+ x1133 = confuse(f1133);
+ l1133 = confuse(f1133);
+ }
+
+ Expect.isTrue(m1133 is F1133);
+ Expect.isTrue(m1133 is core.List<core.int> Function(Function x1) Function(int x));
+ Expect.isTrue(confuse(m1133) is F1133);
+ // In checked mode, verifies the type.
+ x1133 = m1133;
+ l1133 = m1133;
+ x1133 = confuse(m1133);
+ l1133 = confuse(m1133);
+
+ }
+
+ void testF1233() {
+ // core.List<core.int> Function(int x, [core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1233 is F1233);
+ Expect.isTrue(confuse(f1233) is F1233);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [core.List<core.int> x1]) Function(int x) l1233;
+ // The static function f1233 sets `T` to `int`.
+ if (!tIsBool) {
+ x1233 = f1233 as dynamic;
+ l1233 = f1233 as dynamic;
+ x1233 = confuse(f1233);
+ l1233 = confuse(f1233);
+ }
+
+ Expect.isTrue(m1233 is F1233);
+ Expect.isTrue(m1233 is core.List<core.int> Function(int x, [core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1233) is F1233);
+ // In checked mode, verifies the type.
+ x1233 = m1233;
+ l1233 = m1233;
+ x1233 = confuse(m1233);
+ l1233 = confuse(m1233);
+
+ }
+
+ void testF1333() {
+ // List<T> Function(int x1, {int x}) Function(int x)
+ Expect.isTrue(f1333 is F1333);
+ Expect.isTrue(confuse(f1333) is F1333);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {int x}) Function(int x) l1333;
+ // The static function f1333 sets `T` to `int`.
+ if (!tIsBool) {
+ x1333 = f1333 as dynamic;
+ l1333 = f1333 as dynamic;
+ x1333 = confuse(f1333);
+ l1333 = confuse(f1333);
+ }
+
+ Expect.isTrue(m1333 is F1333);
+ Expect.isTrue(m1333 is List<T> Function(int x1, {int x}) Function(int x));
+ Expect.isTrue(confuse(m1333) is F1333);
+ // In checked mode, verifies the type.
+ x1333 = m1333;
+ l1333 = m1333;
+ x1333 = confuse(m1333);
+ l1333 = confuse(m1333);
+ if (!tIsBool) {
+ Expect.isTrue(f1333 is F1333<int>);
+ Expect.isFalse(f1333 is F1333<bool>);
+ Expect.isTrue(confuse(f1333) is F1333<int>);
+ Expect.isFalse(confuse(f1333) is F1333<bool>);
+ Expect.equals(tIsDynamic, m1333 is F1333<bool>);
+ Expect.equals(tIsDynamic, confuse(m1333) is F1333<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1333 = (f1333 as dynamic); });
+ Expect.throws(() { x1333 = confuse(f1333); });
+ List<T> Function(int x1, {int x}) Function(int x) l1333;
+ Expect.throws(() { l1333 = (f1333 as dynamic); });
+ Expect.throws(() { l1333 = confuse(f1333); });
+ }
+ List<T> Function(int x1, {int x}) Function(int x) l1333 = m1333;
+ // In checked mode, verifies the type.
+ x1333 = m1333;
+ x1333 = confuse(m1333);
+ }
+ }
+
+ void testF1433() {
+ // List<T> Function([core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1433 is F1433);
+ Expect.isTrue(confuse(f1433) is F1433);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x]) Function(int x) l1433;
+ // The static function f1433 sets `T` to `int`.
+ if (!tIsBool) {
+ x1433 = f1433 as dynamic;
+ l1433 = f1433 as dynamic;
+ x1433 = confuse(f1433);
+ l1433 = confuse(f1433);
+ }
+
+ Expect.isTrue(m1433 is F1433);
+ Expect.isTrue(m1433 is List<T> Function([core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1433) is F1433);
+ // In checked mode, verifies the type.
+ x1433 = m1433;
+ l1433 = m1433;
+ x1433 = confuse(m1433);
+ l1433 = confuse(m1433);
+ if (!tIsBool) {
+ Expect.isTrue(f1433 is F1433<int>);
+ Expect.isFalse(f1433 is F1433<bool>);
+ Expect.isTrue(confuse(f1433) is F1433<int>);
+ Expect.isFalse(confuse(f1433) is F1433<bool>);
+ Expect.equals(tIsDynamic, m1433 is F1433<bool>);
+ Expect.equals(tIsDynamic, confuse(m1433) is F1433<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1433 = (f1433 as dynamic); });
+ Expect.throws(() { x1433 = confuse(f1433); });
+ List<T> Function([core.List<core.int> x]) Function(int x) l1433;
+ Expect.throws(() { l1433 = (f1433 as dynamic); });
+ Expect.throws(() { l1433 = confuse(f1433); });
+ }
+ List<T> Function([core.List<core.int> x]) Function(int x) l1433 = m1433;
+ // In checked mode, verifies the type.
+ x1433 = m1433;
+ x1433 = confuse(m1433);
+ }
+ }
+
+ void testF1533() {
+ // Function(int y, [int x]) Function(int x)
+ Expect.isTrue(f1533 is F1533);
+ Expect.isTrue(confuse(f1533) is F1533);
+ // In checked mode, verifies the type.
+ Function(int y, [int x]) Function(int x) l1533;
+ // The static function f1533 sets `T` to `int`.
+ if (!tIsBool) {
+ x1533 = f1533 as dynamic;
+ l1533 = f1533 as dynamic;
+ x1533 = confuse(f1533);
+ l1533 = confuse(f1533);
+ }
+
+ Expect.isTrue(m1533 is F1533);
+ Expect.isTrue(m1533 is Function(int y, [int x]) Function(int x));
+ Expect.isTrue(confuse(m1533) is F1533);
+ // In checked mode, verifies the type.
+ x1533 = m1533;
+ l1533 = m1533;
+ x1533 = confuse(m1533);
+ l1533 = confuse(m1533);
+
+ }
+
+ void testF1633() {
+ // Function(int x2, [List<Function> x3]) Function(int x)
+ Expect.isTrue(f1633 is F1633);
+ Expect.isTrue(confuse(f1633) is F1633);
+ // In checked mode, verifies the type.
+ Function(int x2, [List<Function> x3]) Function(int x) l1633;
+ // The static function f1633 sets `T` to `int`.
+ if (!tIsBool) {
+ x1633 = f1633 as dynamic;
+ l1633 = f1633 as dynamic;
+ x1633 = confuse(f1633);
+ l1633 = confuse(f1633);
+ }
+
+ Expect.isTrue(m1633 is F1633);
+ Expect.isTrue(m1633 is Function(int x2, [List<Function> x3]) Function(int x));
+ Expect.isTrue(confuse(m1633) is F1633);
+ // In checked mode, verifies the type.
+ x1633 = m1633;
+ l1633 = m1633;
+ x1633 = confuse(m1633);
+ l1633 = confuse(m1633);
+
+ }
+
+ void testF1733() {
+ // Function(int x1, {List<T> x}) Function(int x)
+ Expect.isTrue(f1733 is F1733);
+ Expect.isTrue(confuse(f1733) is F1733);
+ // In checked mode, verifies the type.
+ Function(int x1, {List<T> x}) Function(int x) l1733;
+ // The static function f1733 sets `T` to `int`.
+ if (!tIsBool) {
+ x1733 = f1733 as dynamic;
+ l1733 = f1733 as dynamic;
+ x1733 = confuse(f1733);
+ l1733 = confuse(f1733);
+ }
+
+ Expect.isTrue(m1733 is F1733);
+ Expect.isTrue(m1733 is Function(int x1, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1733) is F1733);
+ // In checked mode, verifies the type.
+ x1733 = m1733;
+ l1733 = m1733;
+ x1733 = confuse(m1733);
+ l1733 = confuse(m1733);
+ if (!tIsBool) {
+ Expect.isTrue(f1733 is F1733<int>);
+ Expect.isFalse(f1733 is F1733<bool>);
+ Expect.isTrue(confuse(f1733) is F1733<int>);
+ Expect.isFalse(confuse(f1733) is F1733<bool>);
+ Expect.equals(tIsDynamic, m1733 is F1733<bool>);
+ Expect.equals(tIsDynamic, confuse(m1733) is F1733<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1733 = (f1733 as dynamic); });
+ Expect.throws(() { x1733 = confuse(f1733); });
+ Function(int x1, {List<T> x}) Function(int x) l1733;
+ Expect.throws(() { l1733 = (f1733 as dynamic); });
+ Expect.throws(() { l1733 = confuse(f1733); });
+ }
+ Function(int x1, {List<T> x}) Function(int x) l1733 = m1733;
+ // In checked mode, verifies the type.
+ x1733 = m1733;
+ x1733 = confuse(m1733);
+ }
+ }
+
+ void testF1833() {
+ // List<Function> Function<A>(A x) Function(int x)
+ Expect.isTrue(f1833 is F1833);
+ Expect.isTrue(confuse(f1833) is F1833);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(A x) Function(int x) l1833;
+ // The static function f1833 sets `T` to `int`.
+ if (!tIsBool) {
+ x1833 = f1833 as dynamic;
+ l1833 = f1833 as dynamic;
+ x1833 = confuse(f1833);
+ l1833 = confuse(f1833);
+ }
+
+ Expect.isTrue(m1833 is F1833);
+ Expect.isTrue(m1833 is List<Function> Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1833) is F1833);
+ // In checked mode, verifies the type.
+ x1833 = m1833;
+ l1833 = m1833;
+ x1833 = confuse(m1833);
+ l1833 = confuse(m1833);
+
+ }
+
+ void testF1933() {
+ // Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1933 is F1933);
+ Expect.isTrue(confuse(f1933) is F1933);
+ // In checked mode, verifies the type.
+ Function<A>(List<A> x) Function(int x) l1933;
+ // The static function f1933 sets `T` to `int`.
+ if (!tIsBool) {
+ x1933 = f1933 as dynamic;
+ l1933 = f1933 as dynamic;
+ x1933 = confuse(f1933);
+ l1933 = confuse(f1933);
+ }
+
+ Expect.isTrue(m1933 is F1933);
+ Expect.isTrue(m1933 is Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1933) is F1933);
+ // In checked mode, verifies the type.
+ x1933 = m1933;
+ l1933 = m1933;
+ x1933 = confuse(m1933);
+ l1933 = confuse(m1933);
+
+ }
+
+
+}
+
+class C34<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([core.List<core.int> x]) x34;
+ List<Function> Function(List<Function> x) x134;
+ List<T> Function(int y, {int x}) x234;
+ Function(int y, {List<T> x}) x334;
+ int Function({int x}) Function<B extends core.int>() x434;
+ int Function(core.List<core.int> x) Function<B extends core.int>() x534;
+ Function Function(int x1, [int x]) Function<B extends core.int>() x634;
+ Function Function([List<Function> x1]) Function<B extends core.int>() x734;
+ Function Function({List<T> x}) Function<B extends core.int>() x834;
+ List<Function> Function(int y, {Function x}) Function<B extends core.int>() x934;
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>() x1034;
+ core.List<core.int> Function(Function x1) Function<B extends core.int>() x1134;
+ core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() x1234;
+ List<T> Function(int x1, {int x}) Function<B extends core.int>() x1334;
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>() x1434;
+ Function(int y, [int x]) Function<B extends core.int>() x1534;
+ Function(int x2, [List<Function> x3]) Function<B extends core.int>() x1634;
+ Function(int x1, {List<T> x}) Function<B extends core.int>() x1734;
+ List<Function> Function<A>(A x) Function<B extends core.int>() x1834;
+ Function<A>(List<A> x) Function<B extends core.int>() x1934;
+
+
+ C34({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m34([core.List<core.int> x]) => null;
+ List<Function> m134(List<Function> x) => null;
+ List<T> m234(int y, {int x}) => null;
+ m334(int y, {List<T> x}) => null;
+ int Function({int x}) m434<B extends core.int>() => null;
+ int Function(core.List<core.int> x) m534<B extends core.int>() => null;
+ Function Function(int x0, [int x]) m634<B extends core.int>() => null;
+ Function Function([List<Function> x0]) m734<B extends core.int>() => null;
+ Function Function({List<T> x}) m834<B extends core.int>() => null;
+ List<Function> Function(int y, {Function x}) m934<B extends core.int>() => null;
+ List<Function> Function(int x0, [List<T> x]) m1034<B extends core.int>() => null;
+ core.List<core.int> Function(Function x0) m1134<B extends core.int>() => null;
+ core.List<core.int> Function(int x, [core.List<core.int> x0]) m1234<B extends core.int>() => null;
+ List<T> Function(int x0, {int x}) m1334<B extends core.int>() => null;
+ List<T> Function([core.List<core.int> x]) m1434<B extends core.int>() => null;
+ Function(int y, [int x]) m1534<B extends core.int>() => null;
+ Function(int x0, [List<Function> x1]) m1634<B extends core.int>() => null;
+ Function(int x0, {List<T> x}) m1734<B extends core.int>() => null;
+ List<Function> Function<A>(A x) m1834<B extends core.int>() => null;
+ Function<A>(List<A> x) m1934<B extends core.int>() => null;
+
+
+ runTests() {
+ testF34();
+ testF134();
+ testF234();
+ testF334();
+ testF434();
+ testF534();
+ testF634();
+ testF734();
+ testF834();
+ testF934();
+ testF1034();
+ testF1134();
+ testF1234();
+ testF1334();
+ testF1434();
+ testF1534();
+ testF1634();
+ testF1734();
+ testF1834();
+ testF1934();
+ }
+
+ void testF34() {
+ // int Function([core.List<core.int> x])
+ Expect.isTrue(f34 is F34);
+ Expect.isTrue(confuse(f34) is F34);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x]) l34;
+ // The static function f34 sets `T` to `int`.
+ if (!tIsBool) {
+ x34 = f34 as dynamic;
+ l34 = f34 as dynamic;
+ x34 = confuse(f34);
+ l34 = confuse(f34);
+ }
+
+ Expect.isTrue(m34 is F34);
+ Expect.isTrue(m34 is int Function([core.List<core.int> x]));
+ Expect.isTrue(confuse(m34) is F34);
+ // In checked mode, verifies the type.
+ x34 = m34;
+ l34 = m34;
+ x34 = confuse(m34);
+ l34 = confuse(m34);
+
+ }
+
+ void testF134() {
+ // List<Function> Function(List<Function> x)
+ Expect.isTrue(f134 is F134);
+ Expect.isTrue(confuse(f134) is F134);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x) l134;
+ // The static function f134 sets `T` to `int`.
+ if (!tIsBool) {
+ x134 = f134 as dynamic;
+ l134 = f134 as dynamic;
+ x134 = confuse(f134);
+ l134 = confuse(f134);
+ }
+
+ Expect.isTrue(m134 is F134);
+ Expect.isTrue(m134 is List<Function> Function(List<Function> x));
+ Expect.isTrue(confuse(m134) is F134);
+ // In checked mode, verifies the type.
+ x134 = m134;
+ l134 = m134;
+ x134 = confuse(m134);
+ l134 = confuse(m134);
+
+ }
+
+ void testF234() {
+ // List<T> Function(int y, {int x})
+ Expect.isTrue(f234 is F234);
+ Expect.isTrue(confuse(f234) is F234);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {int x}) l234;
+ // The static function f234 sets `T` to `int`.
+ if (!tIsBool) {
+ x234 = f234 as dynamic;
+ l234 = f234 as dynamic;
+ x234 = confuse(f234);
+ l234 = confuse(f234);
+ }
+
+ Expect.isTrue(m234 is F234);
+ Expect.isTrue(m234 is List<T> Function(int y, {int x}));
+ Expect.isTrue(confuse(m234) is F234);
+ // In checked mode, verifies the type.
+ x234 = m234;
+ l234 = m234;
+ x234 = confuse(m234);
+ l234 = confuse(m234);
+ if (!tIsBool) {
+ Expect.isTrue(f234 is F234<int>);
+ Expect.isFalse(f234 is F234<bool>);
+ Expect.isTrue(confuse(f234) is F234<int>);
+ Expect.isFalse(confuse(f234) is F234<bool>);
+ Expect.equals(tIsDynamic, m234 is F234<bool>);
+ Expect.equals(tIsDynamic, confuse(m234) is F234<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x234 = (f234 as dynamic); });
+ Expect.throws(() { x234 = confuse(f234); });
+ List<T> Function(int y, {int x}) l234;
+ Expect.throws(() { l234 = (f234 as dynamic); });
+ Expect.throws(() { l234 = confuse(f234); });
+ }
+ List<T> Function(int y, {int x}) l234 = m234;
+ // In checked mode, verifies the type.
+ x234 = m234;
+ x234 = confuse(m234);
+ }
+ }
+
+ void testF334() {
+ // Function(int y, {List<T> x})
+ Expect.isTrue(f334 is F334);
+ Expect.isTrue(confuse(f334) is F334);
+ // In checked mode, verifies the type.
+ Function(int y, {List<T> x}) l334;
+ // The static function f334 sets `T` to `int`.
+ if (!tIsBool) {
+ x334 = f334 as dynamic;
+ l334 = f334 as dynamic;
+ x334 = confuse(f334);
+ l334 = confuse(f334);
+ }
+
+ Expect.isTrue(m334 is F334);
+ Expect.isTrue(m334 is Function(int y, {List<T> x}));
+ Expect.isTrue(confuse(m334) is F334);
+ // In checked mode, verifies the type.
+ x334 = m334;
+ l334 = m334;
+ x334 = confuse(m334);
+ l334 = confuse(m334);
+ if (!tIsBool) {
+ Expect.isTrue(f334 is F334<int>);
+ Expect.isFalse(f334 is F334<bool>);
+ Expect.isTrue(confuse(f334) is F334<int>);
+ Expect.isFalse(confuse(f334) is F334<bool>);
+ Expect.equals(tIsDynamic, m334 is F334<bool>);
+ Expect.equals(tIsDynamic, confuse(m334) is F334<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x334 = (f334 as dynamic); });
+ Expect.throws(() { x334 = confuse(f334); });
+ Function(int y, {List<T> x}) l334;
+ Expect.throws(() { l334 = (f334 as dynamic); });
+ Expect.throws(() { l334 = confuse(f334); });
+ }
+ Function(int y, {List<T> x}) l334 = m334;
+ // In checked mode, verifies the type.
+ x334 = m334;
+ x334 = confuse(m334);
+ }
+ }
+
+ void testF434() {
+ // int Function({int x}) Function<B extends core.int>()
+ Expect.isTrue(f434 is F434);
+ Expect.isTrue(confuse(f434) is F434);
+ // In checked mode, verifies the type.
+ int Function({int x}) Function<B extends core.int>() l434;
+ // The static function f434 sets `T` to `int`.
+ if (!tIsBool) {
+ x434 = f434 as dynamic;
+ l434 = f434 as dynamic;
+ x434 = confuse(f434);
+ l434 = confuse(f434);
+ }
+
+ Expect.isTrue(m434 is F434);
+ Expect.isTrue(m434 is int Function({int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m434) is F434);
+ // In checked mode, verifies the type.
+ x434 = m434;
+ l434 = m434;
+ x434 = confuse(m434);
+ l434 = confuse(m434);
+
+ }
+
+ void testF534() {
+ // int Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f534 is F534);
+ Expect.isTrue(confuse(f534) is F534);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x) Function<B extends core.int>() l534;
+ // The static function f534 sets `T` to `int`.
+ if (!tIsBool) {
+ x534 = f534 as dynamic;
+ l534 = f534 as dynamic;
+ x534 = confuse(f534);
+ l534 = confuse(f534);
+ }
+
+ Expect.isTrue(m534 is F534);
+ Expect.isTrue(m534 is int Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m534) is F534);
+ // In checked mode, verifies the type.
+ x534 = m534;
+ l534 = m534;
+ x534 = confuse(m534);
+ l534 = confuse(m534);
+
+ }
+
+ void testF634() {
+ // Function Function(int x1, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f634 is F634);
+ Expect.isTrue(confuse(f634) is F634);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [int x]) Function<B extends core.int>() l634;
+ // The static function f634 sets `T` to `int`.
+ if (!tIsBool) {
+ x634 = f634 as dynamic;
+ l634 = f634 as dynamic;
+ x634 = confuse(f634);
+ l634 = confuse(f634);
+ }
+
+ Expect.isTrue(m634 is F634);
+ Expect.isTrue(m634 is Function Function(int x1, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m634) is F634);
+ // In checked mode, verifies the type.
+ x634 = m634;
+ l634 = m634;
+ x634 = confuse(m634);
+ l634 = confuse(m634);
+
+ }
+
+ void testF734() {
+ // Function Function([List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f734 is F734);
+ Expect.isTrue(confuse(f734) is F734);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x1]) Function<B extends core.int>() l734;
+ // The static function f734 sets `T` to `int`.
+ if (!tIsBool) {
+ x734 = f734 as dynamic;
+ l734 = f734 as dynamic;
+ x734 = confuse(f734);
+ l734 = confuse(f734);
+ }
+
+ Expect.isTrue(m734 is F734);
+ Expect.isTrue(m734 is Function Function([List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m734) is F734);
+ // In checked mode, verifies the type.
+ x734 = m734;
+ l734 = m734;
+ x734 = confuse(m734);
+ l734 = confuse(m734);
+
+ }
+
+ void testF834() {
+ // Function Function({List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f834 is F834);
+ Expect.isTrue(confuse(f834) is F834);
+ // In checked mode, verifies the type.
+ Function Function({List<T> x}) Function<B extends core.int>() l834;
+ // The static function f834 sets `T` to `int`.
+ if (!tIsBool) {
+ x834 = f834 as dynamic;
+ l834 = f834 as dynamic;
+ x834 = confuse(f834);
+ l834 = confuse(f834);
+ }
+
+ Expect.isTrue(m834 is F834);
+ Expect.isTrue(m834 is Function Function({List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m834) is F834);
+ // In checked mode, verifies the type.
+ x834 = m834;
+ l834 = m834;
+ x834 = confuse(m834);
+ l834 = confuse(m834);
+ if (!tIsBool) {
+ Expect.isTrue(f834 is F834<int>);
+ Expect.isFalse(f834 is F834<bool>);
+ Expect.isTrue(confuse(f834) is F834<int>);
+ Expect.isFalse(confuse(f834) is F834<bool>);
+ Expect.equals(tIsDynamic, m834 is F834<bool>);
+ Expect.equals(tIsDynamic, confuse(m834) is F834<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x834 = (f834 as dynamic); });
+ Expect.throws(() { x834 = confuse(f834); });
+ Function Function({List<T> x}) Function<B extends core.int>() l834;
+ Expect.throws(() { l834 = (f834 as dynamic); });
+ Expect.throws(() { l834 = confuse(f834); });
+ }
+ Function Function({List<T> x}) Function<B extends core.int>() l834 = m834;
+ // In checked mode, verifies the type.
+ x834 = m834;
+ x834 = confuse(m834);
+ }
+ }
+
+ void testF934() {
+ // List<Function> Function(int y, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f934 is F934);
+ Expect.isTrue(confuse(f934) is F934);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {Function x}) Function<B extends core.int>() l934;
+ // The static function f934 sets `T` to `int`.
+ if (!tIsBool) {
+ x934 = f934 as dynamic;
+ l934 = f934 as dynamic;
+ x934 = confuse(f934);
+ l934 = confuse(f934);
+ }
+
+ Expect.isTrue(m934 is F934);
+ Expect.isTrue(m934 is List<Function> Function(int y, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m934) is F934);
+ // In checked mode, verifies the type.
+ x934 = m934;
+ l934 = m934;
+ x934 = confuse(m934);
+ l934 = confuse(m934);
+
+ }
+
+ void testF1034() {
+ // List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1034 is F1034);
+ Expect.isTrue(confuse(f1034) is F1034);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>() l1034;
+ // The static function f1034 sets `T` to `int`.
+ if (!tIsBool) {
+ x1034 = f1034 as dynamic;
+ l1034 = f1034 as dynamic;
+ x1034 = confuse(f1034);
+ l1034 = confuse(f1034);
+ }
+
+ Expect.isTrue(m1034 is F1034);
+ Expect.isTrue(m1034 is List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1034) is F1034);
+ // In checked mode, verifies the type.
+ x1034 = m1034;
+ l1034 = m1034;
+ x1034 = confuse(m1034);
+ l1034 = confuse(m1034);
+ if (!tIsBool) {
+ Expect.isTrue(f1034 is F1034<int>);
+ Expect.isFalse(f1034 is F1034<bool>);
+ Expect.isTrue(confuse(f1034) is F1034<int>);
+ Expect.isFalse(confuse(f1034) is F1034<bool>);
+ Expect.equals(tIsDynamic, m1034 is F1034<bool>);
+ Expect.equals(tIsDynamic, confuse(m1034) is F1034<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1034 = (f1034 as dynamic); });
+ Expect.throws(() { x1034 = confuse(f1034); });
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>() l1034;
+ Expect.throws(() { l1034 = (f1034 as dynamic); });
+ Expect.throws(() { l1034 = confuse(f1034); });
+ }
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>() l1034 = m1034;
+ // In checked mode, verifies the type.
+ x1034 = m1034;
+ x1034 = confuse(m1034);
+ }
+ }
+
+ void testF1134() {
+ // core.List<core.int> Function(Function x1) Function<B extends core.int>()
+ Expect.isTrue(f1134 is F1134);
+ Expect.isTrue(confuse(f1134) is F1134);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x1) Function<B extends core.int>() l1134;
+ // The static function f1134 sets `T` to `int`.
+ if (!tIsBool) {
+ x1134 = f1134 as dynamic;
+ l1134 = f1134 as dynamic;
+ x1134 = confuse(f1134);
+ l1134 = confuse(f1134);
+ }
+
+ Expect.isTrue(m1134 is F1134);
+ Expect.isTrue(m1134 is core.List<core.int> Function(Function x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1134) is F1134);
+ // In checked mode, verifies the type.
+ x1134 = m1134;
+ l1134 = m1134;
+ x1134 = confuse(m1134);
+ l1134 = confuse(m1134);
+
+ }
+
+ void testF1234() {
+ // core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1234 is F1234);
+ Expect.isTrue(confuse(f1234) is F1234);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l1234;
+ // The static function f1234 sets `T` to `int`.
+ if (!tIsBool) {
+ x1234 = f1234 as dynamic;
+ l1234 = f1234 as dynamic;
+ x1234 = confuse(f1234);
+ l1234 = confuse(f1234);
+ }
+
+ Expect.isTrue(m1234 is F1234);
+ Expect.isTrue(m1234 is core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1234) is F1234);
+ // In checked mode, verifies the type.
+ x1234 = m1234;
+ l1234 = m1234;
+ x1234 = confuse(m1234);
+ l1234 = confuse(m1234);
+
+ }
+
+ void testF1334() {
+ // List<T> Function(int x1, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f1334 is F1334);
+ Expect.isTrue(confuse(f1334) is F1334);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {int x}) Function<B extends core.int>() l1334;
+ // The static function f1334 sets `T` to `int`.
+ if (!tIsBool) {
+ x1334 = f1334 as dynamic;
+ l1334 = f1334 as dynamic;
+ x1334 = confuse(f1334);
+ l1334 = confuse(f1334);
+ }
+
+ Expect.isTrue(m1334 is F1334);
+ Expect.isTrue(m1334 is List<T> Function(int x1, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1334) is F1334);
+ // In checked mode, verifies the type.
+ x1334 = m1334;
+ l1334 = m1334;
+ x1334 = confuse(m1334);
+ l1334 = confuse(m1334);
+ if (!tIsBool) {
+ Expect.isTrue(f1334 is F1334<int>);
+ Expect.isFalse(f1334 is F1334<bool>);
+ Expect.isTrue(confuse(f1334) is F1334<int>);
+ Expect.isFalse(confuse(f1334) is F1334<bool>);
+ Expect.equals(tIsDynamic, m1334 is F1334<bool>);
+ Expect.equals(tIsDynamic, confuse(m1334) is F1334<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1334 = (f1334 as dynamic); });
+ Expect.throws(() { x1334 = confuse(f1334); });
+ List<T> Function(int x1, {int x}) Function<B extends core.int>() l1334;
+ Expect.throws(() { l1334 = (f1334 as dynamic); });
+ Expect.throws(() { l1334 = confuse(f1334); });
+ }
+ List<T> Function(int x1, {int x}) Function<B extends core.int>() l1334 = m1334;
+ // In checked mode, verifies the type.
+ x1334 = m1334;
+ x1334 = confuse(m1334);
+ }
+ }
+
+ void testF1434() {
+ // List<T> Function([core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1434 is F1434);
+ Expect.isTrue(confuse(f1434) is F1434);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>() l1434;
+ // The static function f1434 sets `T` to `int`.
+ if (!tIsBool) {
+ x1434 = f1434 as dynamic;
+ l1434 = f1434 as dynamic;
+ x1434 = confuse(f1434);
+ l1434 = confuse(f1434);
+ }
+
+ Expect.isTrue(m1434 is F1434);
+ Expect.isTrue(m1434 is List<T> Function([core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1434) is F1434);
+ // In checked mode, verifies the type.
+ x1434 = m1434;
+ l1434 = m1434;
+ x1434 = confuse(m1434);
+ l1434 = confuse(m1434);
+ if (!tIsBool) {
+ Expect.isTrue(f1434 is F1434<int>);
+ Expect.isFalse(f1434 is F1434<bool>);
+ Expect.isTrue(confuse(f1434) is F1434<int>);
+ Expect.isFalse(confuse(f1434) is F1434<bool>);
+ Expect.equals(tIsDynamic, m1434 is F1434<bool>);
+ Expect.equals(tIsDynamic, confuse(m1434) is F1434<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1434 = (f1434 as dynamic); });
+ Expect.throws(() { x1434 = confuse(f1434); });
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>() l1434;
+ Expect.throws(() { l1434 = (f1434 as dynamic); });
+ Expect.throws(() { l1434 = confuse(f1434); });
+ }
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>() l1434 = m1434;
+ // In checked mode, verifies the type.
+ x1434 = m1434;
+ x1434 = confuse(m1434);
+ }
+ }
+
+ void testF1534() {
+ // Function(int y, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f1534 is F1534);
+ Expect.isTrue(confuse(f1534) is F1534);
+ // In checked mode, verifies the type.
+ Function(int y, [int x]) Function<B extends core.int>() l1534;
+ // The static function f1534 sets `T` to `int`.
+ if (!tIsBool) {
+ x1534 = f1534 as dynamic;
+ l1534 = f1534 as dynamic;
+ x1534 = confuse(f1534);
+ l1534 = confuse(f1534);
+ }
+
+ Expect.isTrue(m1534 is F1534);
+ Expect.isTrue(m1534 is Function(int y, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1534) is F1534);
+ // In checked mode, verifies the type.
+ x1534 = m1534;
+ l1534 = m1534;
+ x1534 = confuse(m1534);
+ l1534 = confuse(m1534);
+
+ }
+
+ void testF1634() {
+ // Function(int x2, [List<Function> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1634 is F1634);
+ Expect.isTrue(confuse(f1634) is F1634);
+ // In checked mode, verifies the type.
+ Function(int x2, [List<Function> x3]) Function<B extends core.int>() l1634;
+ // The static function f1634 sets `T` to `int`.
+ if (!tIsBool) {
+ x1634 = f1634 as dynamic;
+ l1634 = f1634 as dynamic;
+ x1634 = confuse(f1634);
+ l1634 = confuse(f1634);
+ }
+
+ Expect.isTrue(m1634 is F1634);
+ Expect.isTrue(m1634 is Function(int x2, [List<Function> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1634) is F1634);
+ // In checked mode, verifies the type.
+ x1634 = m1634;
+ l1634 = m1634;
+ x1634 = confuse(m1634);
+ l1634 = confuse(m1634);
+
+ }
+
+ void testF1734() {
+ // Function(int x1, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1734 is F1734);
+ Expect.isTrue(confuse(f1734) is F1734);
+ // In checked mode, verifies the type.
+ Function(int x1, {List<T> x}) Function<B extends core.int>() l1734;
+ // The static function f1734 sets `T` to `int`.
+ if (!tIsBool) {
+ x1734 = f1734 as dynamic;
+ l1734 = f1734 as dynamic;
+ x1734 = confuse(f1734);
+ l1734 = confuse(f1734);
+ }
+
+ Expect.isTrue(m1734 is F1734);
+ Expect.isTrue(m1734 is Function(int x1, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1734) is F1734);
+ // In checked mode, verifies the type.
+ x1734 = m1734;
+ l1734 = m1734;
+ x1734 = confuse(m1734);
+ l1734 = confuse(m1734);
+ if (!tIsBool) {
+ Expect.isTrue(f1734 is F1734<int>);
+ Expect.isFalse(f1734 is F1734<bool>);
+ Expect.isTrue(confuse(f1734) is F1734<int>);
+ Expect.isFalse(confuse(f1734) is F1734<bool>);
+ Expect.equals(tIsDynamic, m1734 is F1734<bool>);
+ Expect.equals(tIsDynamic, confuse(m1734) is F1734<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1734 = (f1734 as dynamic); });
+ Expect.throws(() { x1734 = confuse(f1734); });
+ Function(int x1, {List<T> x}) Function<B extends core.int>() l1734;
+ Expect.throws(() { l1734 = (f1734 as dynamic); });
+ Expect.throws(() { l1734 = confuse(f1734); });
+ }
+ Function(int x1, {List<T> x}) Function<B extends core.int>() l1734 = m1734;
+ // In checked mode, verifies the type.
+ x1734 = m1734;
+ x1734 = confuse(m1734);
+ }
+ }
+
+ void testF1834() {
+ // List<Function> Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1834 is F1834);
+ Expect.isTrue(confuse(f1834) is F1834);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(A x) Function<B extends core.int>() l1834;
+ // The static function f1834 sets `T` to `int`.
+ if (!tIsBool) {
+ x1834 = f1834 as dynamic;
+ l1834 = f1834 as dynamic;
+ x1834 = confuse(f1834);
+ l1834 = confuse(f1834);
+ }
+
+ Expect.isTrue(m1834 is F1834);
+ Expect.isTrue(m1834 is List<Function> Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1834) is F1834);
+ // In checked mode, verifies the type.
+ x1834 = m1834;
+ l1834 = m1834;
+ x1834 = confuse(m1834);
+ l1834 = confuse(m1834);
+
+ }
+
+ void testF1934() {
+ // Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1934 is F1934);
+ Expect.isTrue(confuse(f1934) is F1934);
+ // In checked mode, verifies the type.
+ Function<A>(List<A> x) Function<B extends core.int>() l1934;
+ // The static function f1934 sets `T` to `int`.
+ if (!tIsBool) {
+ x1934 = f1934 as dynamic;
+ l1934 = f1934 as dynamic;
+ x1934 = confuse(f1934);
+ l1934 = confuse(f1934);
+ }
+
+ Expect.isTrue(m1934 is F1934);
+ Expect.isTrue(m1934 is Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1934) is F1934);
+ // In checked mode, verifies the type.
+ x1934 = m1934;
+ l1934 = m1934;
+ x1934 = confuse(m1934);
+ l1934 = confuse(m1934);
+
+ }
+
+
+}
+
+class C35<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, [core.List<core.int> x]) x35;
+ List<Function> Function([List<Function> x]) x135;
+ List<T> Function(Function x) x235;
+ Function() x335;
+ int Function({int x}) Function<B extends core.int>(int x) x435;
+ int Function(core.List<core.int> x) Function<B extends core.int>(int x) x535;
+ Function Function(int x1, [int x]) Function<B extends core.int>(int x) x635;
+ Function Function([List<Function> x1]) Function<B extends core.int>(int x) x735;
+ Function Function({List<T> x}) Function<B extends core.int>(int x) x835;
+ List<Function> Function(int y, {Function x}) Function<B extends core.int>(int x) x935;
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x1035;
+ core.List<core.int> Function(Function x1) Function<B extends core.int>(int x) x1135;
+ core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) x1235;
+ List<T> Function(int x1, {int x}) Function<B extends core.int>(int x) x1335;
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x) x1435;
+ Function(int y, [int x]) Function<B extends core.int>(int x) x1535;
+ Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) x1635;
+ Function(int x1, {List<T> x}) Function<B extends core.int>(int x) x1735;
+ List<Function> Function<A>(A x) Function<B extends core.int>(int x) x1835;
+ Function<A>(List<A> x) Function<B extends core.int>(int x) x1935;
+
+
+ C35({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m35(int x0, [core.List<core.int> x]) => null;
+ List<Function> m135([List<Function> x]) => null;
+ List<T> m235(Function x) => null;
+ m335() => null;
+ int Function({int x}) m435<B extends core.int>(int x) => null;
+ int Function(core.List<core.int> x) m535<B extends core.int>(int x) => null;
+ Function Function(int x0, [int x]) m635<B extends core.int>(int x) => null;
+ Function Function([List<Function> x0]) m735<B extends core.int>(int x) => null;
+ Function Function({List<T> x}) m835<B extends core.int>(int x) => null;
+ List<Function> Function(int y, {Function x}) m935<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [List<T> x]) m1035<B extends core.int>(int x) => null;
+ core.List<core.int> Function(Function x0) m1135<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x, [core.List<core.int> x0]) m1235<B extends core.int>(int x) => null;
+ List<T> Function(int x0, {int x}) m1335<B extends core.int>(int x) => null;
+ List<T> Function([core.List<core.int> x]) m1435<B extends core.int>(int x) => null;
+ Function(int y, [int x]) m1535<B extends core.int>(int x) => null;
+ Function(int x0, [List<Function> x1]) m1635<B extends core.int>(int x) => null;
+ Function(int x0, {List<T> x}) m1735<B extends core.int>(int x) => null;
+ List<Function> Function<A>(A x) m1835<B extends core.int>(int x) => null;
+ Function<A>(List<A> x) m1935<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF35();
+ testF135();
+ testF235();
+ testF335();
+ testF435();
+ testF535();
+ testF635();
+ testF735();
+ testF835();
+ testF935();
+ testF1035();
+ testF1135();
+ testF1235();
+ testF1335();
+ testF1435();
+ testF1535();
+ testF1635();
+ testF1735();
+ testF1835();
+ testF1935();
+ }
+
+ void testF35() {
+ // int Function(int x0, [core.List<core.int> x])
+ Expect.isTrue(f35 is F35);
+ Expect.isTrue(confuse(f35) is F35);
+ // In checked mode, verifies the type.
+ int Function(int x0, [core.List<core.int> x]) l35;
+ // The static function f35 sets `T` to `int`.
+ if (!tIsBool) {
+ x35 = f35 as dynamic;
+ l35 = f35 as dynamic;
+ x35 = confuse(f35);
+ l35 = confuse(f35);
+ }
+
+ Expect.isTrue(m35 is F35);
+ Expect.isTrue(m35 is int Function(int x0, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m35) is F35);
+ // In checked mode, verifies the type.
+ x35 = m35;
+ l35 = m35;
+ x35 = confuse(m35);
+ l35 = confuse(m35);
+
+ }
+
+ void testF135() {
+ // List<Function> Function([List<Function> x])
+ Expect.isTrue(f135 is F135);
+ Expect.isTrue(confuse(f135) is F135);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x]) l135;
+ // The static function f135 sets `T` to `int`.
+ if (!tIsBool) {
+ x135 = f135 as dynamic;
+ l135 = f135 as dynamic;
+ x135 = confuse(f135);
+ l135 = confuse(f135);
+ }
+
+ Expect.isTrue(m135 is F135);
+ Expect.isTrue(m135 is List<Function> Function([List<Function> x]));
+ Expect.isTrue(confuse(m135) is F135);
+ // In checked mode, verifies the type.
+ x135 = m135;
+ l135 = m135;
+ x135 = confuse(m135);
+ l135 = confuse(m135);
+
+ }
+
+ void testF235() {
+ // List<T> Function(Function x)
+ Expect.isTrue(f235 is F235);
+ Expect.isTrue(confuse(f235) is F235);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x) l235;
+ // The static function f235 sets `T` to `int`.
+ if (!tIsBool) {
+ x235 = f235 as dynamic;
+ l235 = f235 as dynamic;
+ x235 = confuse(f235);
+ l235 = confuse(f235);
+ }
+
+ Expect.isTrue(m235 is F235);
+ Expect.isTrue(m235 is List<T> Function(Function x));
+ Expect.isTrue(confuse(m235) is F235);
+ // In checked mode, verifies the type.
+ x235 = m235;
+ l235 = m235;
+ x235 = confuse(m235);
+ l235 = confuse(m235);
+ if (!tIsBool) {
+ Expect.isTrue(f235 is F235<int>);
+ Expect.isFalse(f235 is F235<bool>);
+ Expect.isTrue(confuse(f235) is F235<int>);
+ Expect.isFalse(confuse(f235) is F235<bool>);
+ Expect.equals(tIsDynamic, m235 is F235<bool>);
+ Expect.equals(tIsDynamic, confuse(m235) is F235<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x235 = (f235 as dynamic); });
+ Expect.throws(() { x235 = confuse(f235); });
+ List<T> Function(Function x) l235;
+ Expect.throws(() { l235 = (f235 as dynamic); });
+ Expect.throws(() { l235 = confuse(f235); });
+ }
+ List<T> Function(Function x) l235 = m235;
+ // In checked mode, verifies the type.
+ x235 = m235;
+ x235 = confuse(m235);
+ }
+ }
+
+ void testF335() {
+ // Function()
+ Expect.isTrue(f335 is F335);
+ Expect.isTrue(confuse(f335) is F335);
+ // In checked mode, verifies the type.
+ Function() l335;
+ // The static function f335 sets `T` to `int`.
+ if (!tIsBool) {
+ x335 = f335 as dynamic;
+ l335 = f335 as dynamic;
+ x335 = confuse(f335);
+ l335 = confuse(f335);
+ }
+
+ Expect.isTrue(m335 is F335);
+ Expect.isTrue(m335 is Function());
+ Expect.isTrue(confuse(m335) is F335);
+ // In checked mode, verifies the type.
+ x335 = m335;
+ l335 = m335;
+ x335 = confuse(m335);
+ l335 = confuse(m335);
+
+ }
+
+ void testF435() {
+ // int Function({int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f435 is F435);
+ Expect.isTrue(confuse(f435) is F435);
+ // In checked mode, verifies the type.
+ int Function({int x}) Function<B extends core.int>(int x) l435;
+ // The static function f435 sets `T` to `int`.
+ if (!tIsBool) {
+ x435 = f435 as dynamic;
+ l435 = f435 as dynamic;
+ x435 = confuse(f435);
+ l435 = confuse(f435);
+ }
+
+ Expect.isTrue(m435 is F435);
+ Expect.isTrue(m435 is int Function({int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m435) is F435);
+ // In checked mode, verifies the type.
+ x435 = m435;
+ l435 = m435;
+ x435 = confuse(m435);
+ l435 = confuse(m435);
+
+ }
+
+ void testF535() {
+ // int Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f535 is F535);
+ Expect.isTrue(confuse(f535) is F535);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x) Function<B extends core.int>(int x) l535;
+ // The static function f535 sets `T` to `int`.
+ if (!tIsBool) {
+ x535 = f535 as dynamic;
+ l535 = f535 as dynamic;
+ x535 = confuse(f535);
+ l535 = confuse(f535);
+ }
+
+ Expect.isTrue(m535 is F535);
+ Expect.isTrue(m535 is int Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m535) is F535);
+ // In checked mode, verifies the type.
+ x535 = m535;
+ l535 = m535;
+ x535 = confuse(m535);
+ l535 = confuse(m535);
+
+ }
+
+ void testF635() {
+ // Function Function(int x1, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f635 is F635);
+ Expect.isTrue(confuse(f635) is F635);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [int x]) Function<B extends core.int>(int x) l635;
+ // The static function f635 sets `T` to `int`.
+ if (!tIsBool) {
+ x635 = f635 as dynamic;
+ l635 = f635 as dynamic;
+ x635 = confuse(f635);
+ l635 = confuse(f635);
+ }
+
+ Expect.isTrue(m635 is F635);
+ Expect.isTrue(m635 is Function Function(int x1, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m635) is F635);
+ // In checked mode, verifies the type.
+ x635 = m635;
+ l635 = m635;
+ x635 = confuse(m635);
+ l635 = confuse(m635);
+
+ }
+
+ void testF735() {
+ // Function Function([List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f735 is F735);
+ Expect.isTrue(confuse(f735) is F735);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x1]) Function<B extends core.int>(int x) l735;
+ // The static function f735 sets `T` to `int`.
+ if (!tIsBool) {
+ x735 = f735 as dynamic;
+ l735 = f735 as dynamic;
+ x735 = confuse(f735);
+ l735 = confuse(f735);
+ }
+
+ Expect.isTrue(m735 is F735);
+ Expect.isTrue(m735 is Function Function([List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m735) is F735);
+ // In checked mode, verifies the type.
+ x735 = m735;
+ l735 = m735;
+ x735 = confuse(m735);
+ l735 = confuse(m735);
+
+ }
+
+ void testF835() {
+ // Function Function({List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f835 is F835);
+ Expect.isTrue(confuse(f835) is F835);
+ // In checked mode, verifies the type.
+ Function Function({List<T> x}) Function<B extends core.int>(int x) l835;
+ // The static function f835 sets `T` to `int`.
+ if (!tIsBool) {
+ x835 = f835 as dynamic;
+ l835 = f835 as dynamic;
+ x835 = confuse(f835);
+ l835 = confuse(f835);
+ }
+
+ Expect.isTrue(m835 is F835);
+ Expect.isTrue(m835 is Function Function({List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m835) is F835);
+ // In checked mode, verifies the type.
+ x835 = m835;
+ l835 = m835;
+ x835 = confuse(m835);
+ l835 = confuse(m835);
+ if (!tIsBool) {
+ Expect.isTrue(f835 is F835<int>);
+ Expect.isFalse(f835 is F835<bool>);
+ Expect.isTrue(confuse(f835) is F835<int>);
+ Expect.isFalse(confuse(f835) is F835<bool>);
+ Expect.equals(tIsDynamic, m835 is F835<bool>);
+ Expect.equals(tIsDynamic, confuse(m835) is F835<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x835 = (f835 as dynamic); });
+ Expect.throws(() { x835 = confuse(f835); });
+ Function Function({List<T> x}) Function<B extends core.int>(int x) l835;
+ Expect.throws(() { l835 = (f835 as dynamic); });
+ Expect.throws(() { l835 = confuse(f835); });
+ }
+ Function Function({List<T> x}) Function<B extends core.int>(int x) l835 = m835;
+ // In checked mode, verifies the type.
+ x835 = m835;
+ x835 = confuse(m835);
+ }
+ }
+
+ void testF935() {
+ // List<Function> Function(int y, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f935 is F935);
+ Expect.isTrue(confuse(f935) is F935);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {Function x}) Function<B extends core.int>(int x) l935;
+ // The static function f935 sets `T` to `int`.
+ if (!tIsBool) {
+ x935 = f935 as dynamic;
+ l935 = f935 as dynamic;
+ x935 = confuse(f935);
+ l935 = confuse(f935);
+ }
+
+ Expect.isTrue(m935 is F935);
+ Expect.isTrue(m935 is List<Function> Function(int y, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m935) is F935);
+ // In checked mode, verifies the type.
+ x935 = m935;
+ l935 = m935;
+ x935 = confuse(m935);
+ l935 = confuse(m935);
+
+ }
+
+ void testF1035() {
+ // List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1035 is F1035);
+ Expect.isTrue(confuse(f1035) is F1035);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1035;
+ // The static function f1035 sets `T` to `int`.
+ if (!tIsBool) {
+ x1035 = f1035 as dynamic;
+ l1035 = f1035 as dynamic;
+ x1035 = confuse(f1035);
+ l1035 = confuse(f1035);
+ }
+
+ Expect.isTrue(m1035 is F1035);
+ Expect.isTrue(m1035 is List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1035) is F1035);
+ // In checked mode, verifies the type.
+ x1035 = m1035;
+ l1035 = m1035;
+ x1035 = confuse(m1035);
+ l1035 = confuse(m1035);
+ if (!tIsBool) {
+ Expect.isTrue(f1035 is F1035<int>);
+ Expect.isFalse(f1035 is F1035<bool>);
+ Expect.isTrue(confuse(f1035) is F1035<int>);
+ Expect.isFalse(confuse(f1035) is F1035<bool>);
+ Expect.equals(tIsDynamic, m1035 is F1035<bool>);
+ Expect.equals(tIsDynamic, confuse(m1035) is F1035<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1035 = (f1035 as dynamic); });
+ Expect.throws(() { x1035 = confuse(f1035); });
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1035;
+ Expect.throws(() { l1035 = (f1035 as dynamic); });
+ Expect.throws(() { l1035 = confuse(f1035); });
+ }
+ List<Function> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1035 = m1035;
+ // In checked mode, verifies the type.
+ x1035 = m1035;
+ x1035 = confuse(m1035);
+ }
+ }
+
+ void testF1135() {
+ // core.List<core.int> Function(Function x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1135 is F1135);
+ Expect.isTrue(confuse(f1135) is F1135);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x1) Function<B extends core.int>(int x) l1135;
+ // The static function f1135 sets `T` to `int`.
+ if (!tIsBool) {
+ x1135 = f1135 as dynamic;
+ l1135 = f1135 as dynamic;
+ x1135 = confuse(f1135);
+ l1135 = confuse(f1135);
+ }
+
+ Expect.isTrue(m1135 is F1135);
+ Expect.isTrue(m1135 is core.List<core.int> Function(Function x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1135) is F1135);
+ // In checked mode, verifies the type.
+ x1135 = m1135;
+ l1135 = m1135;
+ x1135 = confuse(m1135);
+ l1135 = confuse(m1135);
+
+ }
+
+ void testF1235() {
+ // core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1235 is F1235);
+ Expect.isTrue(confuse(f1235) is F1235);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l1235;
+ // The static function f1235 sets `T` to `int`.
+ if (!tIsBool) {
+ x1235 = f1235 as dynamic;
+ l1235 = f1235 as dynamic;
+ x1235 = confuse(f1235);
+ l1235 = confuse(f1235);
+ }
+
+ Expect.isTrue(m1235 is F1235);
+ Expect.isTrue(m1235 is core.List<core.int> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1235) is F1235);
+ // In checked mode, verifies the type.
+ x1235 = m1235;
+ l1235 = m1235;
+ x1235 = confuse(m1235);
+ l1235 = confuse(m1235);
+
+ }
+
+ void testF1335() {
+ // List<T> Function(int x1, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1335 is F1335);
+ Expect.isTrue(confuse(f1335) is F1335);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {int x}) Function<B extends core.int>(int x) l1335;
+ // The static function f1335 sets `T` to `int`.
+ if (!tIsBool) {
+ x1335 = f1335 as dynamic;
+ l1335 = f1335 as dynamic;
+ x1335 = confuse(f1335);
+ l1335 = confuse(f1335);
+ }
+
+ Expect.isTrue(m1335 is F1335);
+ Expect.isTrue(m1335 is List<T> Function(int x1, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1335) is F1335);
+ // In checked mode, verifies the type.
+ x1335 = m1335;
+ l1335 = m1335;
+ x1335 = confuse(m1335);
+ l1335 = confuse(m1335);
+ if (!tIsBool) {
+ Expect.isTrue(f1335 is F1335<int>);
+ Expect.isFalse(f1335 is F1335<bool>);
+ Expect.isTrue(confuse(f1335) is F1335<int>);
+ Expect.isFalse(confuse(f1335) is F1335<bool>);
+ Expect.equals(tIsDynamic, m1335 is F1335<bool>);
+ Expect.equals(tIsDynamic, confuse(m1335) is F1335<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1335 = (f1335 as dynamic); });
+ Expect.throws(() { x1335 = confuse(f1335); });
+ List<T> Function(int x1, {int x}) Function<B extends core.int>(int x) l1335;
+ Expect.throws(() { l1335 = (f1335 as dynamic); });
+ Expect.throws(() { l1335 = confuse(f1335); });
+ }
+ List<T> Function(int x1, {int x}) Function<B extends core.int>(int x) l1335 = m1335;
+ // In checked mode, verifies the type.
+ x1335 = m1335;
+ x1335 = confuse(m1335);
+ }
+ }
+
+ void testF1435() {
+ // List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1435 is F1435);
+ Expect.isTrue(confuse(f1435) is F1435);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x) l1435;
+ // The static function f1435 sets `T` to `int`.
+ if (!tIsBool) {
+ x1435 = f1435 as dynamic;
+ l1435 = f1435 as dynamic;
+ x1435 = confuse(f1435);
+ l1435 = confuse(f1435);
+ }
+
+ Expect.isTrue(m1435 is F1435);
+ Expect.isTrue(m1435 is List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1435) is F1435);
+ // In checked mode, verifies the type.
+ x1435 = m1435;
+ l1435 = m1435;
+ x1435 = confuse(m1435);
+ l1435 = confuse(m1435);
+ if (!tIsBool) {
+ Expect.isTrue(f1435 is F1435<int>);
+ Expect.isFalse(f1435 is F1435<bool>);
+ Expect.isTrue(confuse(f1435) is F1435<int>);
+ Expect.isFalse(confuse(f1435) is F1435<bool>);
+ Expect.equals(tIsDynamic, m1435 is F1435<bool>);
+ Expect.equals(tIsDynamic, confuse(m1435) is F1435<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1435 = (f1435 as dynamic); });
+ Expect.throws(() { x1435 = confuse(f1435); });
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x) l1435;
+ Expect.throws(() { l1435 = (f1435 as dynamic); });
+ Expect.throws(() { l1435 = confuse(f1435); });
+ }
+ List<T> Function([core.List<core.int> x]) Function<B extends core.int>(int x) l1435 = m1435;
+ // In checked mode, verifies the type.
+ x1435 = m1435;
+ x1435 = confuse(m1435);
+ }
+ }
+
+ void testF1535() {
+ // Function(int y, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1535 is F1535);
+ Expect.isTrue(confuse(f1535) is F1535);
+ // In checked mode, verifies the type.
+ Function(int y, [int x]) Function<B extends core.int>(int x) l1535;
+ // The static function f1535 sets `T` to `int`.
+ if (!tIsBool) {
+ x1535 = f1535 as dynamic;
+ l1535 = f1535 as dynamic;
+ x1535 = confuse(f1535);
+ l1535 = confuse(f1535);
+ }
+
+ Expect.isTrue(m1535 is F1535);
+ Expect.isTrue(m1535 is Function(int y, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1535) is F1535);
+ // In checked mode, verifies the type.
+ x1535 = m1535;
+ l1535 = m1535;
+ x1535 = confuse(m1535);
+ l1535 = confuse(m1535);
+
+ }
+
+ void testF1635() {
+ // Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1635 is F1635);
+ Expect.isTrue(confuse(f1635) is F1635);
+ // In checked mode, verifies the type.
+ Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l1635;
+ // The static function f1635 sets `T` to `int`.
+ if (!tIsBool) {
+ x1635 = f1635 as dynamic;
+ l1635 = f1635 as dynamic;
+ x1635 = confuse(f1635);
+ l1635 = confuse(f1635);
+ }
+
+ Expect.isTrue(m1635 is F1635);
+ Expect.isTrue(m1635 is Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1635) is F1635);
+ // In checked mode, verifies the type.
+ x1635 = m1635;
+ l1635 = m1635;
+ x1635 = confuse(m1635);
+ l1635 = confuse(m1635);
+
+ }
+
+ void testF1735() {
+ // Function(int x1, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1735 is F1735);
+ Expect.isTrue(confuse(f1735) is F1735);
+ // In checked mode, verifies the type.
+ Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1735;
+ // The static function f1735 sets `T` to `int`.
+ if (!tIsBool) {
+ x1735 = f1735 as dynamic;
+ l1735 = f1735 as dynamic;
+ x1735 = confuse(f1735);
+ l1735 = confuse(f1735);
+ }
+
+ Expect.isTrue(m1735 is F1735);
+ Expect.isTrue(m1735 is Function(int x1, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1735) is F1735);
+ // In checked mode, verifies the type.
+ x1735 = m1735;
+ l1735 = m1735;
+ x1735 = confuse(m1735);
+ l1735 = confuse(m1735);
+ if (!tIsBool) {
+ Expect.isTrue(f1735 is F1735<int>);
+ Expect.isFalse(f1735 is F1735<bool>);
+ Expect.isTrue(confuse(f1735) is F1735<int>);
+ Expect.isFalse(confuse(f1735) is F1735<bool>);
+ Expect.equals(tIsDynamic, m1735 is F1735<bool>);
+ Expect.equals(tIsDynamic, confuse(m1735) is F1735<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1735 = (f1735 as dynamic); });
+ Expect.throws(() { x1735 = confuse(f1735); });
+ Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1735;
+ Expect.throws(() { l1735 = (f1735 as dynamic); });
+ Expect.throws(() { l1735 = confuse(f1735); });
+ }
+ Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1735 = m1735;
+ // In checked mode, verifies the type.
+ x1735 = m1735;
+ x1735 = confuse(m1735);
+ }
+ }
+
+ void testF1835() {
+ // List<Function> Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1835 is F1835);
+ Expect.isTrue(confuse(f1835) is F1835);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(A x) Function<B extends core.int>(int x) l1835;
+ // The static function f1835 sets `T` to `int`.
+ if (!tIsBool) {
+ x1835 = f1835 as dynamic;
+ l1835 = f1835 as dynamic;
+ x1835 = confuse(f1835);
+ l1835 = confuse(f1835);
+ }
+
+ Expect.isTrue(m1835 is F1835);
+ Expect.isTrue(m1835 is List<Function> Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1835) is F1835);
+ // In checked mode, verifies the type.
+ x1835 = m1835;
+ l1835 = m1835;
+ x1835 = confuse(m1835);
+ l1835 = confuse(m1835);
+
+ }
+
+ void testF1935() {
+ // Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1935 is F1935);
+ Expect.isTrue(confuse(f1935) is F1935);
+ // In checked mode, verifies the type.
+ Function<A>(List<A> x) Function<B extends core.int>(int x) l1935;
+ // The static function f1935 sets `T` to `int`.
+ if (!tIsBool) {
+ x1935 = f1935 as dynamic;
+ l1935 = f1935 as dynamic;
+ x1935 = confuse(f1935);
+ l1935 = confuse(f1935);
+ }
+
+ Expect.isTrue(m1935 is F1935);
+ Expect.isTrue(m1935 is Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1935) is F1935);
+ // In checked mode, verifies the type.
+ x1935 = m1935;
+ l1935 = m1935;
+ x1935 = confuse(m1935);
+ l1935 = confuse(m1935);
+
+ }
+
+
+}
+
+class C36<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, [core.List<core.int> x]) x36;
+ List<Function> Function(int x0, [List<Function> x]) x136;
+ List<T> Function([Function x]) x236;
+ int Function<A>(int x) x336;
+ int Function(int x0, {int x}) Function() x436;
+ int Function([core.List<core.int> x]) Function() x536;
+ Function Function(int y, [int x]) Function() x636;
+ Function Function(int x1, [List<Function> x2]) Function() x736;
+ Function Function(int x0, {List<T> x}) Function() x836;
+ List<Function> Function(List<Function> x) Function() x936;
+ List<Function> Function(int y, [List<T> x]) Function() x1036;
+ core.List<core.int> Function([Function x1]) Function() x1136;
+ core.List<core.int> Function({core.List<core.int> x}) Function() x1236;
+ List<T> Function(int y, {int x}) Function() x1336;
+ List<T> Function(int x0, [core.List<core.int> x]) Function() x1436;
+ Function(int x0) Function() x1536;
+ Function(int x, [List<Function> x2]) Function() x1636;
+ Function(int y, {List<T> x}) Function() x1736;
+ List<Function> Function<A>(List<A> x) Function() x1836;
+ A Function<A>(int x) Function() x1936;
+
+
+ C36({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m36(int y, [core.List<core.int> x]) => null;
+ List<Function> m136(int x0, [List<Function> x]) => null;
+ List<T> m236([Function x]) => null;
+ int m336<A>(int x) => null;
+ int Function(int x0, {int x}) m436() => null;
+ int Function([core.List<core.int> x]) m536() => null;
+ Function Function(int y, [int x]) m636() => null;
+ Function Function(int x0, [List<Function> x1]) m736() => null;
+ Function Function(int x0, {List<T> x}) m836() => null;
+ List<Function> Function(List<Function> x) m936() => null;
+ List<Function> Function(int y, [List<T> x]) m1036() => null;
+ core.List<core.int> Function([Function x0]) m1136() => null;
+ core.List<core.int> Function({core.List<core.int> x}) m1236() => null;
+ List<T> Function(int y, {int x}) m1336() => null;
+ List<T> Function(int x0, [core.List<core.int> x]) m1436() => null;
+ Function(int x0) m1536() => null;
+ Function(int x, [List<Function> x0]) m1636() => null;
+ Function(int y, {List<T> x}) m1736() => null;
+ List<Function> Function<A>(List<A> x) m1836() => null;
+ A Function<A>(int x) m1936() => null;
+
+
+ runTests() {
+ testF36();
+ testF136();
+ testF236();
+ testF336();
+ testF436();
+ testF536();
+ testF636();
+ testF736();
+ testF836();
+ testF936();
+ testF1036();
+ testF1136();
+ testF1236();
+ testF1336();
+ testF1436();
+ testF1536();
+ testF1636();
+ testF1736();
+ testF1836();
+ testF1936();
+ }
+
+ void testF36() {
+ // int Function(int y, [core.List<core.int> x])
+ Expect.isTrue(f36 is F36);
+ Expect.isTrue(confuse(f36) is F36);
+ // In checked mode, verifies the type.
+ int Function(int y, [core.List<core.int> x]) l36;
+ // The static function f36 sets `T` to `int`.
+ if (!tIsBool) {
+ x36 = f36 as dynamic;
+ l36 = f36 as dynamic;
+ x36 = confuse(f36);
+ l36 = confuse(f36);
+ }
+
+ Expect.isTrue(m36 is F36);
+ Expect.isTrue(m36 is int Function(int y, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m36) is F36);
+ // In checked mode, verifies the type.
+ x36 = m36;
+ l36 = m36;
+ x36 = confuse(m36);
+ l36 = confuse(m36);
+
+ }
+
+ void testF136() {
+ // List<Function> Function(int x0, [List<Function> x])
+ Expect.isTrue(f136 is F136);
+ Expect.isTrue(confuse(f136) is F136);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [List<Function> x]) l136;
+ // The static function f136 sets `T` to `int`.
+ if (!tIsBool) {
+ x136 = f136 as dynamic;
+ l136 = f136 as dynamic;
+ x136 = confuse(f136);
+ l136 = confuse(f136);
+ }
+
+ Expect.isTrue(m136 is F136);
+ Expect.isTrue(m136 is List<Function> Function(int x0, [List<Function> x]));
+ Expect.isTrue(confuse(m136) is F136);
+ // In checked mode, verifies the type.
+ x136 = m136;
+ l136 = m136;
+ x136 = confuse(m136);
+ l136 = confuse(m136);
+
+ }
+
+ void testF236() {
+ // List<T> Function([Function x])
+ Expect.isTrue(f236 is F236);
+ Expect.isTrue(confuse(f236) is F236);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x]) l236;
+ // The static function f236 sets `T` to `int`.
+ if (!tIsBool) {
+ x236 = f236 as dynamic;
+ l236 = f236 as dynamic;
+ x236 = confuse(f236);
+ l236 = confuse(f236);
+ }
+
+ Expect.isTrue(m236 is F236);
+ Expect.isTrue(m236 is List<T> Function([Function x]));
+ Expect.isTrue(confuse(m236) is F236);
+ // In checked mode, verifies the type.
+ x236 = m236;
+ l236 = m236;
+ x236 = confuse(m236);
+ l236 = confuse(m236);
+ if (!tIsBool) {
+ Expect.isTrue(f236 is F236<int>);
+ Expect.isFalse(f236 is F236<bool>);
+ Expect.isTrue(confuse(f236) is F236<int>);
+ Expect.isFalse(confuse(f236) is F236<bool>);
+ Expect.equals(tIsDynamic, m236 is F236<bool>);
+ Expect.equals(tIsDynamic, confuse(m236) is F236<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x236 = (f236 as dynamic); });
+ Expect.throws(() { x236 = confuse(f236); });
+ List<T> Function([Function x]) l236;
+ Expect.throws(() { l236 = (f236 as dynamic); });
+ Expect.throws(() { l236 = confuse(f236); });
+ }
+ List<T> Function([Function x]) l236 = m236;
+ // In checked mode, verifies the type.
+ x236 = m236;
+ x236 = confuse(m236);
+ }
+ }
+
+ void testF336() {
+ // int Function<A>(int x)
+ Expect.isTrue(f336 is F336);
+ Expect.isTrue(confuse(f336) is F336);
+ // In checked mode, verifies the type.
+ int Function<A>(int x) l336;
+ // The static function f336 sets `T` to `int`.
+ if (!tIsBool) {
+ x336 = f336 as dynamic;
+ l336 = f336 as dynamic;
+ x336 = confuse(f336);
+ l336 = confuse(f336);
+ }
+
+ Expect.isTrue(m336 is F336);
+ Expect.isTrue(m336 is int Function<A>(int x));
+ Expect.isTrue(confuse(m336) is F336);
+ // In checked mode, verifies the type.
+ x336 = m336;
+ l336 = m336;
+ x336 = confuse(m336);
+ l336 = confuse(m336);
+
+ }
+
+ void testF436() {
+ // int Function(int x0, {int x}) Function()
+ Expect.isTrue(f436 is F436);
+ Expect.isTrue(confuse(f436) is F436);
+ // In checked mode, verifies the type.
+ int Function(int x0, {int x}) Function() l436;
+ // The static function f436 sets `T` to `int`.
+ if (!tIsBool) {
+ x436 = f436 as dynamic;
+ l436 = f436 as dynamic;
+ x436 = confuse(f436);
+ l436 = confuse(f436);
+ }
+
+ Expect.isTrue(m436 is F436);
+ Expect.isTrue(m436 is int Function(int x0, {int x}) Function());
+ Expect.isTrue(confuse(m436) is F436);
+ // In checked mode, verifies the type.
+ x436 = m436;
+ l436 = m436;
+ x436 = confuse(m436);
+ l436 = confuse(m436);
+
+ }
+
+ void testF536() {
+ // int Function([core.List<core.int> x]) Function()
+ Expect.isTrue(f536 is F536);
+ Expect.isTrue(confuse(f536) is F536);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x]) Function() l536;
+ // The static function f536 sets `T` to `int`.
+ if (!tIsBool) {
+ x536 = f536 as dynamic;
+ l536 = f536 as dynamic;
+ x536 = confuse(f536);
+ l536 = confuse(f536);
+ }
+
+ Expect.isTrue(m536 is F536);
+ Expect.isTrue(m536 is int Function([core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m536) is F536);
+ // In checked mode, verifies the type.
+ x536 = m536;
+ l536 = m536;
+ x536 = confuse(m536);
+ l536 = confuse(m536);
+
+ }
+
+ void testF636() {
+ // Function Function(int y, [int x]) Function()
+ Expect.isTrue(f636 is F636);
+ Expect.isTrue(confuse(f636) is F636);
+ // In checked mode, verifies the type.
+ Function Function(int y, [int x]) Function() l636;
+ // The static function f636 sets `T` to `int`.
+ if (!tIsBool) {
+ x636 = f636 as dynamic;
+ l636 = f636 as dynamic;
+ x636 = confuse(f636);
+ l636 = confuse(f636);
+ }
+
+ Expect.isTrue(m636 is F636);
+ Expect.isTrue(m636 is Function Function(int y, [int x]) Function());
+ Expect.isTrue(confuse(m636) is F636);
+ // In checked mode, verifies the type.
+ x636 = m636;
+ l636 = m636;
+ x636 = confuse(m636);
+ l636 = confuse(m636);
+
+ }
+
+ void testF736() {
+ // Function Function(int x1, [List<Function> x2]) Function()
+ Expect.isTrue(f736 is F736);
+ Expect.isTrue(confuse(f736) is F736);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<Function> x2]) Function() l736;
+ // The static function f736 sets `T` to `int`.
+ if (!tIsBool) {
+ x736 = f736 as dynamic;
+ l736 = f736 as dynamic;
+ x736 = confuse(f736);
+ l736 = confuse(f736);
+ }
+
+ Expect.isTrue(m736 is F736);
+ Expect.isTrue(m736 is Function Function(int x1, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m736) is F736);
+ // In checked mode, verifies the type.
+ x736 = m736;
+ l736 = m736;
+ x736 = confuse(m736);
+ l736 = confuse(m736);
+
+ }
+
+ void testF836() {
+ // Function Function(int x0, {List<T> x}) Function()
+ Expect.isTrue(f836 is F836);
+ Expect.isTrue(confuse(f836) is F836);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {List<T> x}) Function() l836;
+ // The static function f836 sets `T` to `int`.
+ if (!tIsBool) {
+ x836 = f836 as dynamic;
+ l836 = f836 as dynamic;
+ x836 = confuse(f836);
+ l836 = confuse(f836);
+ }
+
+ Expect.isTrue(m836 is F836);
+ Expect.isTrue(m836 is Function Function(int x0, {List<T> x}) Function());
+ Expect.isTrue(confuse(m836) is F836);
+ // In checked mode, verifies the type.
+ x836 = m836;
+ l836 = m836;
+ x836 = confuse(m836);
+ l836 = confuse(m836);
+ if (!tIsBool) {
+ Expect.isTrue(f836 is F836<int>);
+ Expect.isFalse(f836 is F836<bool>);
+ Expect.isTrue(confuse(f836) is F836<int>);
+ Expect.isFalse(confuse(f836) is F836<bool>);
+ Expect.equals(tIsDynamic, m836 is F836<bool>);
+ Expect.equals(tIsDynamic, confuse(m836) is F836<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x836 = (f836 as dynamic); });
+ Expect.throws(() { x836 = confuse(f836); });
+ Function Function(int x0, {List<T> x}) Function() l836;
+ Expect.throws(() { l836 = (f836 as dynamic); });
+ Expect.throws(() { l836 = confuse(f836); });
+ }
+ Function Function(int x0, {List<T> x}) Function() l836 = m836;
+ // In checked mode, verifies the type.
+ x836 = m836;
+ x836 = confuse(m836);
+ }
+ }
+
+ void testF936() {
+ // List<Function> Function(List<Function> x) Function()
+ Expect.isTrue(f936 is F936);
+ Expect.isTrue(confuse(f936) is F936);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x) Function() l936;
+ // The static function f936 sets `T` to `int`.
+ if (!tIsBool) {
+ x936 = f936 as dynamic;
+ l936 = f936 as dynamic;
+ x936 = confuse(f936);
+ l936 = confuse(f936);
+ }
+
+ Expect.isTrue(m936 is F936);
+ Expect.isTrue(m936 is List<Function> Function(List<Function> x) Function());
+ Expect.isTrue(confuse(m936) is F936);
+ // In checked mode, verifies the type.
+ x936 = m936;
+ l936 = m936;
+ x936 = confuse(m936);
+ l936 = confuse(m936);
+
+ }
+
+ void testF1036() {
+ // List<Function> Function(int y, [List<T> x]) Function()
+ Expect.isTrue(f1036 is F1036);
+ Expect.isTrue(confuse(f1036) is F1036);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<T> x]) Function() l1036;
+ // The static function f1036 sets `T` to `int`.
+ if (!tIsBool) {
+ x1036 = f1036 as dynamic;
+ l1036 = f1036 as dynamic;
+ x1036 = confuse(f1036);
+ l1036 = confuse(f1036);
+ }
+
+ Expect.isTrue(m1036 is F1036);
+ Expect.isTrue(m1036 is List<Function> Function(int y, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1036) is F1036);
+ // In checked mode, verifies the type.
+ x1036 = m1036;
+ l1036 = m1036;
+ x1036 = confuse(m1036);
+ l1036 = confuse(m1036);
+ if (!tIsBool) {
+ Expect.isTrue(f1036 is F1036<int>);
+ Expect.isFalse(f1036 is F1036<bool>);
+ Expect.isTrue(confuse(f1036) is F1036<int>);
+ Expect.isFalse(confuse(f1036) is F1036<bool>);
+ Expect.equals(tIsDynamic, m1036 is F1036<bool>);
+ Expect.equals(tIsDynamic, confuse(m1036) is F1036<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1036 = (f1036 as dynamic); });
+ Expect.throws(() { x1036 = confuse(f1036); });
+ List<Function> Function(int y, [List<T> x]) Function() l1036;
+ Expect.throws(() { l1036 = (f1036 as dynamic); });
+ Expect.throws(() { l1036 = confuse(f1036); });
+ }
+ List<Function> Function(int y, [List<T> x]) Function() l1036 = m1036;
+ // In checked mode, verifies the type.
+ x1036 = m1036;
+ x1036 = confuse(m1036);
+ }
+ }
+
+ void testF1136() {
+ // core.List<core.int> Function([Function x1]) Function()
+ Expect.isTrue(f1136 is F1136);
+ Expect.isTrue(confuse(f1136) is F1136);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x1]) Function() l1136;
+ // The static function f1136 sets `T` to `int`.
+ if (!tIsBool) {
+ x1136 = f1136 as dynamic;
+ l1136 = f1136 as dynamic;
+ x1136 = confuse(f1136);
+ l1136 = confuse(f1136);
+ }
+
+ Expect.isTrue(m1136 is F1136);
+ Expect.isTrue(m1136 is core.List<core.int> Function([Function x1]) Function());
+ Expect.isTrue(confuse(m1136) is F1136);
+ // In checked mode, verifies the type.
+ x1136 = m1136;
+ l1136 = m1136;
+ x1136 = confuse(m1136);
+ l1136 = confuse(m1136);
+
+ }
+
+ void testF1236() {
+ // core.List<core.int> Function({core.List<core.int> x}) Function()
+ Expect.isTrue(f1236 is F1236);
+ Expect.isTrue(confuse(f1236) is F1236);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({core.List<core.int> x}) Function() l1236;
+ // The static function f1236 sets `T` to `int`.
+ if (!tIsBool) {
+ x1236 = f1236 as dynamic;
+ l1236 = f1236 as dynamic;
+ x1236 = confuse(f1236);
+ l1236 = confuse(f1236);
+ }
+
+ Expect.isTrue(m1236 is F1236);
+ Expect.isTrue(m1236 is core.List<core.int> Function({core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1236) is F1236);
+ // In checked mode, verifies the type.
+ x1236 = m1236;
+ l1236 = m1236;
+ x1236 = confuse(m1236);
+ l1236 = confuse(m1236);
+
+ }
+
+ void testF1336() {
+ // List<T> Function(int y, {int x}) Function()
+ Expect.isTrue(f1336 is F1336);
+ Expect.isTrue(confuse(f1336) is F1336);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {int x}) Function() l1336;
+ // The static function f1336 sets `T` to `int`.
+ if (!tIsBool) {
+ x1336 = f1336 as dynamic;
+ l1336 = f1336 as dynamic;
+ x1336 = confuse(f1336);
+ l1336 = confuse(f1336);
+ }
+
+ Expect.isTrue(m1336 is F1336);
+ Expect.isTrue(m1336 is List<T> Function(int y, {int x}) Function());
+ Expect.isTrue(confuse(m1336) is F1336);
+ // In checked mode, verifies the type.
+ x1336 = m1336;
+ l1336 = m1336;
+ x1336 = confuse(m1336);
+ l1336 = confuse(m1336);
+ if (!tIsBool) {
+ Expect.isTrue(f1336 is F1336<int>);
+ Expect.isFalse(f1336 is F1336<bool>);
+ Expect.isTrue(confuse(f1336) is F1336<int>);
+ Expect.isFalse(confuse(f1336) is F1336<bool>);
+ Expect.equals(tIsDynamic, m1336 is F1336<bool>);
+ Expect.equals(tIsDynamic, confuse(m1336) is F1336<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1336 = (f1336 as dynamic); });
+ Expect.throws(() { x1336 = confuse(f1336); });
+ List<T> Function(int y, {int x}) Function() l1336;
+ Expect.throws(() { l1336 = (f1336 as dynamic); });
+ Expect.throws(() { l1336 = confuse(f1336); });
+ }
+ List<T> Function(int y, {int x}) Function() l1336 = m1336;
+ // In checked mode, verifies the type.
+ x1336 = m1336;
+ x1336 = confuse(m1336);
+ }
+ }
+
+ void testF1436() {
+ // List<T> Function(int x0, [core.List<core.int> x]) Function()
+ Expect.isTrue(f1436 is F1436);
+ Expect.isTrue(confuse(f1436) is F1436);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [core.List<core.int> x]) Function() l1436;
+ // The static function f1436 sets `T` to `int`.
+ if (!tIsBool) {
+ x1436 = f1436 as dynamic;
+ l1436 = f1436 as dynamic;
+ x1436 = confuse(f1436);
+ l1436 = confuse(f1436);
+ }
+
+ Expect.isTrue(m1436 is F1436);
+ Expect.isTrue(m1436 is List<T> Function(int x0, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1436) is F1436);
+ // In checked mode, verifies the type.
+ x1436 = m1436;
+ l1436 = m1436;
+ x1436 = confuse(m1436);
+ l1436 = confuse(m1436);
+ if (!tIsBool) {
+ Expect.isTrue(f1436 is F1436<int>);
+ Expect.isFalse(f1436 is F1436<bool>);
+ Expect.isTrue(confuse(f1436) is F1436<int>);
+ Expect.isFalse(confuse(f1436) is F1436<bool>);
+ Expect.equals(tIsDynamic, m1436 is F1436<bool>);
+ Expect.equals(tIsDynamic, confuse(m1436) is F1436<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1436 = (f1436 as dynamic); });
+ Expect.throws(() { x1436 = confuse(f1436); });
+ List<T> Function(int x0, [core.List<core.int> x]) Function() l1436;
+ Expect.throws(() { l1436 = (f1436 as dynamic); });
+ Expect.throws(() { l1436 = confuse(f1436); });
+ }
+ List<T> Function(int x0, [core.List<core.int> x]) Function() l1436 = m1436;
+ // In checked mode, verifies the type.
+ x1436 = m1436;
+ x1436 = confuse(m1436);
+ }
+ }
+
+ void testF1536() {
+ // Function(int x0) Function()
+ Expect.isTrue(f1536 is F1536);
+ Expect.isTrue(confuse(f1536) is F1536);
+ // In checked mode, verifies the type.
+ Function(int x0) Function() l1536;
+ // The static function f1536 sets `T` to `int`.
+ if (!tIsBool) {
+ x1536 = f1536 as dynamic;
+ l1536 = f1536 as dynamic;
+ x1536 = confuse(f1536);
+ l1536 = confuse(f1536);
+ }
+
+ Expect.isTrue(m1536 is F1536);
+ Expect.isTrue(m1536 is Function(int x0) Function());
+ Expect.isTrue(confuse(m1536) is F1536);
+ // In checked mode, verifies the type.
+ x1536 = m1536;
+ l1536 = m1536;
+ x1536 = confuse(m1536);
+ l1536 = confuse(m1536);
+
+ }
+
+ void testF1636() {
+ // Function(int x, [List<Function> x2]) Function()
+ Expect.isTrue(f1636 is F1636);
+ Expect.isTrue(confuse(f1636) is F1636);
+ // In checked mode, verifies the type.
+ Function(int x, [List<Function> x2]) Function() l1636;
+ // The static function f1636 sets `T` to `int`.
+ if (!tIsBool) {
+ x1636 = f1636 as dynamic;
+ l1636 = f1636 as dynamic;
+ x1636 = confuse(f1636);
+ l1636 = confuse(f1636);
+ }
+
+ Expect.isTrue(m1636 is F1636);
+ Expect.isTrue(m1636 is Function(int x, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m1636) is F1636);
+ // In checked mode, verifies the type.
+ x1636 = m1636;
+ l1636 = m1636;
+ x1636 = confuse(m1636);
+ l1636 = confuse(m1636);
+
+ }
+
+ void testF1736() {
+ // Function(int y, {List<T> x}) Function()
+ Expect.isTrue(f1736 is F1736);
+ Expect.isTrue(confuse(f1736) is F1736);
+ // In checked mode, verifies the type.
+ Function(int y, {List<T> x}) Function() l1736;
+ // The static function f1736 sets `T` to `int`.
+ if (!tIsBool) {
+ x1736 = f1736 as dynamic;
+ l1736 = f1736 as dynamic;
+ x1736 = confuse(f1736);
+ l1736 = confuse(f1736);
+ }
+
+ Expect.isTrue(m1736 is F1736);
+ Expect.isTrue(m1736 is Function(int y, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1736) is F1736);
+ // In checked mode, verifies the type.
+ x1736 = m1736;
+ l1736 = m1736;
+ x1736 = confuse(m1736);
+ l1736 = confuse(m1736);
+ if (!tIsBool) {
+ Expect.isTrue(f1736 is F1736<int>);
+ Expect.isFalse(f1736 is F1736<bool>);
+ Expect.isTrue(confuse(f1736) is F1736<int>);
+ Expect.isFalse(confuse(f1736) is F1736<bool>);
+ Expect.equals(tIsDynamic, m1736 is F1736<bool>);
+ Expect.equals(tIsDynamic, confuse(m1736) is F1736<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1736 = (f1736 as dynamic); });
+ Expect.throws(() { x1736 = confuse(f1736); });
+ Function(int y, {List<T> x}) Function() l1736;
+ Expect.throws(() { l1736 = (f1736 as dynamic); });
+ Expect.throws(() { l1736 = confuse(f1736); });
+ }
+ Function(int y, {List<T> x}) Function() l1736 = m1736;
+ // In checked mode, verifies the type.
+ x1736 = m1736;
+ x1736 = confuse(m1736);
+ }
+ }
+
+ void testF1836() {
+ // List<Function> Function<A>(List<A> x) Function()
+ Expect.isTrue(f1836 is F1836);
+ Expect.isTrue(confuse(f1836) is F1836);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<A> x) Function() l1836;
+ // The static function f1836 sets `T` to `int`.
+ if (!tIsBool) {
+ x1836 = f1836 as dynamic;
+ l1836 = f1836 as dynamic;
+ x1836 = confuse(f1836);
+ l1836 = confuse(f1836);
+ }
+
+ Expect.isTrue(m1836 is F1836);
+ Expect.isTrue(m1836 is List<Function> Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1836) is F1836);
+ // In checked mode, verifies the type.
+ x1836 = m1836;
+ l1836 = m1836;
+ x1836 = confuse(m1836);
+ l1836 = confuse(m1836);
+
+ }
+
+ void testF1936() {
+ // A Function<A>(int x) Function()
+ Expect.isTrue(f1936 is F1936);
+ Expect.isTrue(confuse(f1936) is F1936);
+ // In checked mode, verifies the type.
+ A Function<A>(int x) Function() l1936;
+ // The static function f1936 sets `T` to `int`.
+ if (!tIsBool) {
+ x1936 = f1936 as dynamic;
+ l1936 = f1936 as dynamic;
+ x1936 = confuse(f1936);
+ l1936 = confuse(f1936);
+ }
+
+ Expect.isTrue(m1936 is F1936);
+ Expect.isTrue(m1936 is A Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1936) is F1936);
+ // In checked mode, verifies the type.
+ x1936 = m1936;
+ l1936 = m1936;
+ x1936 = confuse(m1936);
+ l1936 = confuse(m1936);
+
+ }
+
+
+}
+
+class C37<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(core.List<core.int> x0) x37;
+ List<Function> Function(int y, [List<Function> x]) x137;
+ List<T> Function(int x0, [Function x]) x237;
+ int Function<A>(Function x) x337;
+ int Function(int x1, {int x}) Function(int x) x437;
+ int Function([core.List<core.int> x]) Function(int x) x537;
+ Function Function(int y, [int x]) Function(int x) x637;
+ Function Function(int x2, [List<Function> x3]) Function(int x) x737;
+ Function Function(int x1, {List<T> x}) Function(int x) x837;
+ List<Function> Function(List<Function> x) Function(int x) x937;
+ List<Function> Function(int y, [List<T> x]) Function(int x) x1037;
+ core.List<core.int> Function([Function x1]) Function(int x) x1137;
+ core.List<core.int> Function({core.List<core.int> x}) Function(int x) x1237;
+ List<T> Function(int y, {int x}) Function(int x) x1337;
+ List<T> Function(int x1, [core.List<core.int> x]) Function(int x) x1437;
+ Function(int x1) Function(int x) x1537;
+ Function(int x, [List<Function> x1]) Function(int x) x1637;
+ Function(int y, {List<T> x}) Function(int x) x1737;
+ List<Function> Function<A>(List<A> x) Function(int x) x1837;
+ A Function<A>(int x) Function(int x) x1937;
+
+
+ C37({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m37(core.List<core.int> x0) => null;
+ List<Function> m137(int y, [List<Function> x]) => null;
+ List<T> m237(int x0, [Function x]) => null;
+ int m337<A>(Function x) => null;
+ int Function(int x0, {int x}) m437(int x) => null;
+ int Function([core.List<core.int> x]) m537(int x) => null;
+ Function Function(int y, [int x]) m637(int x) => null;
+ Function Function(int x0, [List<Function> x1]) m737(int x) => null;
+ Function Function(int x0, {List<T> x}) m837(int x) => null;
+ List<Function> Function(List<Function> x) m937(int x) => null;
+ List<Function> Function(int y, [List<T> x]) m1037(int x) => null;
+ core.List<core.int> Function([Function x0]) m1137(int x) => null;
+ core.List<core.int> Function({core.List<core.int> x}) m1237(int x) => null;
+ List<T> Function(int y, {int x}) m1337(int x) => null;
+ List<T> Function(int x0, [core.List<core.int> x]) m1437(int x) => null;
+ Function(int x0) m1537(int x) => null;
+ Function(int x, [List<Function> x0]) m1637(int x) => null;
+ Function(int y, {List<T> x}) m1737(int x) => null;
+ List<Function> Function<A>(List<A> x) m1837(int x) => null;
+ A Function<A>(int x) m1937(int x) => null;
+
+
+ runTests() {
+ testF37();
+ testF137();
+ testF237();
+ testF337();
+ testF437();
+ testF537();
+ testF637();
+ testF737();
+ testF837();
+ testF937();
+ testF1037();
+ testF1137();
+ testF1237();
+ testF1337();
+ testF1437();
+ testF1537();
+ testF1637();
+ testF1737();
+ testF1837();
+ testF1937();
+ }
+
+ void testF37() {
+ // int Function(core.List<core.int> x0)
+ Expect.isTrue(f37 is F37);
+ Expect.isTrue(confuse(f37) is F37);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x0) l37;
+ // The static function f37 sets `T` to `int`.
+ if (!tIsBool) {
+ x37 = f37 as dynamic;
+ l37 = f37 as dynamic;
+ x37 = confuse(f37);
+ l37 = confuse(f37);
+ }
+
+ Expect.isTrue(m37 is F37);
+ Expect.isTrue(m37 is int Function(core.List<core.int> x0));
+ Expect.isTrue(confuse(m37) is F37);
+ // In checked mode, verifies the type.
+ x37 = m37;
+ l37 = m37;
+ x37 = confuse(m37);
+ l37 = confuse(m37);
+
+ }
+
+ void testF137() {
+ // List<Function> Function(int y, [List<Function> x])
+ Expect.isTrue(f137 is F137);
+ Expect.isTrue(confuse(f137) is F137);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<Function> x]) l137;
+ // The static function f137 sets `T` to `int`.
+ if (!tIsBool) {
+ x137 = f137 as dynamic;
+ l137 = f137 as dynamic;
+ x137 = confuse(f137);
+ l137 = confuse(f137);
+ }
+
+ Expect.isTrue(m137 is F137);
+ Expect.isTrue(m137 is List<Function> Function(int y, [List<Function> x]));
+ Expect.isTrue(confuse(m137) is F137);
+ // In checked mode, verifies the type.
+ x137 = m137;
+ l137 = m137;
+ x137 = confuse(m137);
+ l137 = confuse(m137);
+
+ }
+
+ void testF237() {
+ // List<T> Function(int x0, [Function x])
+ Expect.isTrue(f237 is F237);
+ Expect.isTrue(confuse(f237) is F237);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [Function x]) l237;
+ // The static function f237 sets `T` to `int`.
+ if (!tIsBool) {
+ x237 = f237 as dynamic;
+ l237 = f237 as dynamic;
+ x237 = confuse(f237);
+ l237 = confuse(f237);
+ }
+
+ Expect.isTrue(m237 is F237);
+ Expect.isTrue(m237 is List<T> Function(int x0, [Function x]));
+ Expect.isTrue(confuse(m237) is F237);
+ // In checked mode, verifies the type.
+ x237 = m237;
+ l237 = m237;
+ x237 = confuse(m237);
+ l237 = confuse(m237);
+ if (!tIsBool) {
+ Expect.isTrue(f237 is F237<int>);
+ Expect.isFalse(f237 is F237<bool>);
+ Expect.isTrue(confuse(f237) is F237<int>);
+ Expect.isFalse(confuse(f237) is F237<bool>);
+ Expect.equals(tIsDynamic, m237 is F237<bool>);
+ Expect.equals(tIsDynamic, confuse(m237) is F237<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x237 = (f237 as dynamic); });
+ Expect.throws(() { x237 = confuse(f237); });
+ List<T> Function(int x0, [Function x]) l237;
+ Expect.throws(() { l237 = (f237 as dynamic); });
+ Expect.throws(() { l237 = confuse(f237); });
+ }
+ List<T> Function(int x0, [Function x]) l237 = m237;
+ // In checked mode, verifies the type.
+ x237 = m237;
+ x237 = confuse(m237);
+ }
+ }
+
+ void testF337() {
+ // int Function<A>(Function x)
+ Expect.isTrue(f337 is F337);
+ Expect.isTrue(confuse(f337) is F337);
+ // In checked mode, verifies the type.
+ int Function<A>(Function x) l337;
+ // The static function f337 sets `T` to `int`.
+ if (!tIsBool) {
+ x337 = f337 as dynamic;
+ l337 = f337 as dynamic;
+ x337 = confuse(f337);
+ l337 = confuse(f337);
+ }
+
+ Expect.isTrue(m337 is F337);
+ Expect.isTrue(m337 is int Function<A>(Function x));
+ Expect.isTrue(confuse(m337) is F337);
+ // In checked mode, verifies the type.
+ x337 = m337;
+ l337 = m337;
+ x337 = confuse(m337);
+ l337 = confuse(m337);
+
+ }
+
+ void testF437() {
+ // int Function(int x1, {int x}) Function(int x)
+ Expect.isTrue(f437 is F437);
+ Expect.isTrue(confuse(f437) is F437);
+ // In checked mode, verifies the type.
+ int Function(int x1, {int x}) Function(int x) l437;
+ // The static function f437 sets `T` to `int`.
+ if (!tIsBool) {
+ x437 = f437 as dynamic;
+ l437 = f437 as dynamic;
+ x437 = confuse(f437);
+ l437 = confuse(f437);
+ }
+
+ Expect.isTrue(m437 is F437);
+ Expect.isTrue(m437 is int Function(int x1, {int x}) Function(int x));
+ Expect.isTrue(confuse(m437) is F437);
+ // In checked mode, verifies the type.
+ x437 = m437;
+ l437 = m437;
+ x437 = confuse(m437);
+ l437 = confuse(m437);
+
+ }
+
+ void testF537() {
+ // int Function([core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f537 is F537);
+ Expect.isTrue(confuse(f537) is F537);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x]) Function(int x) l537;
+ // The static function f537 sets `T` to `int`.
+ if (!tIsBool) {
+ x537 = f537 as dynamic;
+ l537 = f537 as dynamic;
+ x537 = confuse(f537);
+ l537 = confuse(f537);
+ }
+
+ Expect.isTrue(m537 is F537);
+ Expect.isTrue(m537 is int Function([core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m537) is F537);
+ // In checked mode, verifies the type.
+ x537 = m537;
+ l537 = m537;
+ x537 = confuse(m537);
+ l537 = confuse(m537);
+
+ }
+
+ void testF637() {
+ // Function Function(int y, [int x]) Function(int x)
+ Expect.isTrue(f637 is F637);
+ Expect.isTrue(confuse(f637) is F637);
+ // In checked mode, verifies the type.
+ Function Function(int y, [int x]) Function(int x) l637;
+ // The static function f637 sets `T` to `int`.
+ if (!tIsBool) {
+ x637 = f637 as dynamic;
+ l637 = f637 as dynamic;
+ x637 = confuse(f637);
+ l637 = confuse(f637);
+ }
+
+ Expect.isTrue(m637 is F637);
+ Expect.isTrue(m637 is Function Function(int y, [int x]) Function(int x));
+ Expect.isTrue(confuse(m637) is F637);
+ // In checked mode, verifies the type.
+ x637 = m637;
+ l637 = m637;
+ x637 = confuse(m637);
+ l637 = confuse(m637);
+
+ }
+
+ void testF737() {
+ // Function Function(int x2, [List<Function> x3]) Function(int x)
+ Expect.isTrue(f737 is F737);
+ Expect.isTrue(confuse(f737) is F737);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [List<Function> x3]) Function(int x) l737;
+ // The static function f737 sets `T` to `int`.
+ if (!tIsBool) {
+ x737 = f737 as dynamic;
+ l737 = f737 as dynamic;
+ x737 = confuse(f737);
+ l737 = confuse(f737);
+ }
+
+ Expect.isTrue(m737 is F737);
+ Expect.isTrue(m737 is Function Function(int x2, [List<Function> x3]) Function(int x));
+ Expect.isTrue(confuse(m737) is F737);
+ // In checked mode, verifies the type.
+ x737 = m737;
+ l737 = m737;
+ x737 = confuse(m737);
+ l737 = confuse(m737);
+
+ }
+
+ void testF837() {
+ // Function Function(int x1, {List<T> x}) Function(int x)
+ Expect.isTrue(f837 is F837);
+ Expect.isTrue(confuse(f837) is F837);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {List<T> x}) Function(int x) l837;
+ // The static function f837 sets `T` to `int`.
+ if (!tIsBool) {
+ x837 = f837 as dynamic;
+ l837 = f837 as dynamic;
+ x837 = confuse(f837);
+ l837 = confuse(f837);
+ }
+
+ Expect.isTrue(m837 is F837);
+ Expect.isTrue(m837 is Function Function(int x1, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m837) is F837);
+ // In checked mode, verifies the type.
+ x837 = m837;
+ l837 = m837;
+ x837 = confuse(m837);
+ l837 = confuse(m837);
+ if (!tIsBool) {
+ Expect.isTrue(f837 is F837<int>);
+ Expect.isFalse(f837 is F837<bool>);
+ Expect.isTrue(confuse(f837) is F837<int>);
+ Expect.isFalse(confuse(f837) is F837<bool>);
+ Expect.equals(tIsDynamic, m837 is F837<bool>);
+ Expect.equals(tIsDynamic, confuse(m837) is F837<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x837 = (f837 as dynamic); });
+ Expect.throws(() { x837 = confuse(f837); });
+ Function Function(int x1, {List<T> x}) Function(int x) l837;
+ Expect.throws(() { l837 = (f837 as dynamic); });
+ Expect.throws(() { l837 = confuse(f837); });
+ }
+ Function Function(int x1, {List<T> x}) Function(int x) l837 = m837;
+ // In checked mode, verifies the type.
+ x837 = m837;
+ x837 = confuse(m837);
+ }
+ }
+
+ void testF937() {
+ // List<Function> Function(List<Function> x) Function(int x)
+ Expect.isTrue(f937 is F937);
+ Expect.isTrue(confuse(f937) is F937);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x) Function(int x) l937;
+ // The static function f937 sets `T` to `int`.
+ if (!tIsBool) {
+ x937 = f937 as dynamic;
+ l937 = f937 as dynamic;
+ x937 = confuse(f937);
+ l937 = confuse(f937);
+ }
+
+ Expect.isTrue(m937 is F937);
+ Expect.isTrue(m937 is List<Function> Function(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m937) is F937);
+ // In checked mode, verifies the type.
+ x937 = m937;
+ l937 = m937;
+ x937 = confuse(m937);
+ l937 = confuse(m937);
+
+ }
+
+ void testF1037() {
+ // List<Function> Function(int y, [List<T> x]) Function(int x)
+ Expect.isTrue(f1037 is F1037);
+ Expect.isTrue(confuse(f1037) is F1037);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<T> x]) Function(int x) l1037;
+ // The static function f1037 sets `T` to `int`.
+ if (!tIsBool) {
+ x1037 = f1037 as dynamic;
+ l1037 = f1037 as dynamic;
+ x1037 = confuse(f1037);
+ l1037 = confuse(f1037);
+ }
+
+ Expect.isTrue(m1037 is F1037);
+ Expect.isTrue(m1037 is List<Function> Function(int y, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1037) is F1037);
+ // In checked mode, verifies the type.
+ x1037 = m1037;
+ l1037 = m1037;
+ x1037 = confuse(m1037);
+ l1037 = confuse(m1037);
+ if (!tIsBool) {
+ Expect.isTrue(f1037 is F1037<int>);
+ Expect.isFalse(f1037 is F1037<bool>);
+ Expect.isTrue(confuse(f1037) is F1037<int>);
+ Expect.isFalse(confuse(f1037) is F1037<bool>);
+ Expect.equals(tIsDynamic, m1037 is F1037<bool>);
+ Expect.equals(tIsDynamic, confuse(m1037) is F1037<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1037 = (f1037 as dynamic); });
+ Expect.throws(() { x1037 = confuse(f1037); });
+ List<Function> Function(int y, [List<T> x]) Function(int x) l1037;
+ Expect.throws(() { l1037 = (f1037 as dynamic); });
+ Expect.throws(() { l1037 = confuse(f1037); });
+ }
+ List<Function> Function(int y, [List<T> x]) Function(int x) l1037 = m1037;
+ // In checked mode, verifies the type.
+ x1037 = m1037;
+ x1037 = confuse(m1037);
+ }
+ }
+
+ void testF1137() {
+ // core.List<core.int> Function([Function x1]) Function(int x)
+ Expect.isTrue(f1137 is F1137);
+ Expect.isTrue(confuse(f1137) is F1137);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x1]) Function(int x) l1137;
+ // The static function f1137 sets `T` to `int`.
+ if (!tIsBool) {
+ x1137 = f1137 as dynamic;
+ l1137 = f1137 as dynamic;
+ x1137 = confuse(f1137);
+ l1137 = confuse(f1137);
+ }
+
+ Expect.isTrue(m1137 is F1137);
+ Expect.isTrue(m1137 is core.List<core.int> Function([Function x1]) Function(int x));
+ Expect.isTrue(confuse(m1137) is F1137);
+ // In checked mode, verifies the type.
+ x1137 = m1137;
+ l1137 = m1137;
+ x1137 = confuse(m1137);
+ l1137 = confuse(m1137);
+
+ }
+
+ void testF1237() {
+ // core.List<core.int> Function({core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1237 is F1237);
+ Expect.isTrue(confuse(f1237) is F1237);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({core.List<core.int> x}) Function(int x) l1237;
+ // The static function f1237 sets `T` to `int`.
+ if (!tIsBool) {
+ x1237 = f1237 as dynamic;
+ l1237 = f1237 as dynamic;
+ x1237 = confuse(f1237);
+ l1237 = confuse(f1237);
+ }
+
+ Expect.isTrue(m1237 is F1237);
+ Expect.isTrue(m1237 is core.List<core.int> Function({core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1237) is F1237);
+ // In checked mode, verifies the type.
+ x1237 = m1237;
+ l1237 = m1237;
+ x1237 = confuse(m1237);
+ l1237 = confuse(m1237);
+
+ }
+
+ void testF1337() {
+ // List<T> Function(int y, {int x}) Function(int x)
+ Expect.isTrue(f1337 is F1337);
+ Expect.isTrue(confuse(f1337) is F1337);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {int x}) Function(int x) l1337;
+ // The static function f1337 sets `T` to `int`.
+ if (!tIsBool) {
+ x1337 = f1337 as dynamic;
+ l1337 = f1337 as dynamic;
+ x1337 = confuse(f1337);
+ l1337 = confuse(f1337);
+ }
+
+ Expect.isTrue(m1337 is F1337);
+ Expect.isTrue(m1337 is List<T> Function(int y, {int x}) Function(int x));
+ Expect.isTrue(confuse(m1337) is F1337);
+ // In checked mode, verifies the type.
+ x1337 = m1337;
+ l1337 = m1337;
+ x1337 = confuse(m1337);
+ l1337 = confuse(m1337);
+ if (!tIsBool) {
+ Expect.isTrue(f1337 is F1337<int>);
+ Expect.isFalse(f1337 is F1337<bool>);
+ Expect.isTrue(confuse(f1337) is F1337<int>);
+ Expect.isFalse(confuse(f1337) is F1337<bool>);
+ Expect.equals(tIsDynamic, m1337 is F1337<bool>);
+ Expect.equals(tIsDynamic, confuse(m1337) is F1337<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1337 = (f1337 as dynamic); });
+ Expect.throws(() { x1337 = confuse(f1337); });
+ List<T> Function(int y, {int x}) Function(int x) l1337;
+ Expect.throws(() { l1337 = (f1337 as dynamic); });
+ Expect.throws(() { l1337 = confuse(f1337); });
+ }
+ List<T> Function(int y, {int x}) Function(int x) l1337 = m1337;
+ // In checked mode, verifies the type.
+ x1337 = m1337;
+ x1337 = confuse(m1337);
+ }
+ }
+
+ void testF1437() {
+ // List<T> Function(int x1, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1437 is F1437);
+ Expect.isTrue(confuse(f1437) is F1437);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [core.List<core.int> x]) Function(int x) l1437;
+ // The static function f1437 sets `T` to `int`.
+ if (!tIsBool) {
+ x1437 = f1437 as dynamic;
+ l1437 = f1437 as dynamic;
+ x1437 = confuse(f1437);
+ l1437 = confuse(f1437);
+ }
+
+ Expect.isTrue(m1437 is F1437);
+ Expect.isTrue(m1437 is List<T> Function(int x1, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1437) is F1437);
+ // In checked mode, verifies the type.
+ x1437 = m1437;
+ l1437 = m1437;
+ x1437 = confuse(m1437);
+ l1437 = confuse(m1437);
+ if (!tIsBool) {
+ Expect.isTrue(f1437 is F1437<int>);
+ Expect.isFalse(f1437 is F1437<bool>);
+ Expect.isTrue(confuse(f1437) is F1437<int>);
+ Expect.isFalse(confuse(f1437) is F1437<bool>);
+ Expect.equals(tIsDynamic, m1437 is F1437<bool>);
+ Expect.equals(tIsDynamic, confuse(m1437) is F1437<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1437 = (f1437 as dynamic); });
+ Expect.throws(() { x1437 = confuse(f1437); });
+ List<T> Function(int x1, [core.List<core.int> x]) Function(int x) l1437;
+ Expect.throws(() { l1437 = (f1437 as dynamic); });
+ Expect.throws(() { l1437 = confuse(f1437); });
+ }
+ List<T> Function(int x1, [core.List<core.int> x]) Function(int x) l1437 = m1437;
+ // In checked mode, verifies the type.
+ x1437 = m1437;
+ x1437 = confuse(m1437);
+ }
+ }
+
+ void testF1537() {
+ // Function(int x1) Function(int x)
+ Expect.isTrue(f1537 is F1537);
+ Expect.isTrue(confuse(f1537) is F1537);
+ // In checked mode, verifies the type.
+ Function(int x1) Function(int x) l1537;
+ // The static function f1537 sets `T` to `int`.
+ if (!tIsBool) {
+ x1537 = f1537 as dynamic;
+ l1537 = f1537 as dynamic;
+ x1537 = confuse(f1537);
+ l1537 = confuse(f1537);
+ }
+
+ Expect.isTrue(m1537 is F1537);
+ Expect.isTrue(m1537 is Function(int x1) Function(int x));
+ Expect.isTrue(confuse(m1537) is F1537);
+ // In checked mode, verifies the type.
+ x1537 = m1537;
+ l1537 = m1537;
+ x1537 = confuse(m1537);
+ l1537 = confuse(m1537);
+
+ }
+
+ void testF1637() {
+ // Function(int x, [List<Function> x1]) Function(int x)
+ Expect.isTrue(f1637 is F1637);
+ Expect.isTrue(confuse(f1637) is F1637);
+ // In checked mode, verifies the type.
+ Function(int x, [List<Function> x1]) Function(int x) l1637;
+ // The static function f1637 sets `T` to `int`.
+ if (!tIsBool) {
+ x1637 = f1637 as dynamic;
+ l1637 = f1637 as dynamic;
+ x1637 = confuse(f1637);
+ l1637 = confuse(f1637);
+ }
+
+ Expect.isTrue(m1637 is F1637);
+ Expect.isTrue(m1637 is Function(int x, [List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m1637) is F1637);
+ // In checked mode, verifies the type.
+ x1637 = m1637;
+ l1637 = m1637;
+ x1637 = confuse(m1637);
+ l1637 = confuse(m1637);
+
+ }
+
+ void testF1737() {
+ // Function(int y, {List<T> x}) Function(int x)
+ Expect.isTrue(f1737 is F1737);
+ Expect.isTrue(confuse(f1737) is F1737);
+ // In checked mode, verifies the type.
+ Function(int y, {List<T> x}) Function(int x) l1737;
+ // The static function f1737 sets `T` to `int`.
+ if (!tIsBool) {
+ x1737 = f1737 as dynamic;
+ l1737 = f1737 as dynamic;
+ x1737 = confuse(f1737);
+ l1737 = confuse(f1737);
+ }
+
+ Expect.isTrue(m1737 is F1737);
+ Expect.isTrue(m1737 is Function(int y, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1737) is F1737);
+ // In checked mode, verifies the type.
+ x1737 = m1737;
+ l1737 = m1737;
+ x1737 = confuse(m1737);
+ l1737 = confuse(m1737);
+ if (!tIsBool) {
+ Expect.isTrue(f1737 is F1737<int>);
+ Expect.isFalse(f1737 is F1737<bool>);
+ Expect.isTrue(confuse(f1737) is F1737<int>);
+ Expect.isFalse(confuse(f1737) is F1737<bool>);
+ Expect.equals(tIsDynamic, m1737 is F1737<bool>);
+ Expect.equals(tIsDynamic, confuse(m1737) is F1737<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1737 = (f1737 as dynamic); });
+ Expect.throws(() { x1737 = confuse(f1737); });
+ Function(int y, {List<T> x}) Function(int x) l1737;
+ Expect.throws(() { l1737 = (f1737 as dynamic); });
+ Expect.throws(() { l1737 = confuse(f1737); });
+ }
+ Function(int y, {List<T> x}) Function(int x) l1737 = m1737;
+ // In checked mode, verifies the type.
+ x1737 = m1737;
+ x1737 = confuse(m1737);
+ }
+ }
+
+ void testF1837() {
+ // List<Function> Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1837 is F1837);
+ Expect.isTrue(confuse(f1837) is F1837);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<A> x) Function(int x) l1837;
+ // The static function f1837 sets `T` to `int`.
+ if (!tIsBool) {
+ x1837 = f1837 as dynamic;
+ l1837 = f1837 as dynamic;
+ x1837 = confuse(f1837);
+ l1837 = confuse(f1837);
+ }
+
+ Expect.isTrue(m1837 is F1837);
+ Expect.isTrue(m1837 is List<Function> Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1837) is F1837);
+ // In checked mode, verifies the type.
+ x1837 = m1837;
+ l1837 = m1837;
+ x1837 = confuse(m1837);
+ l1837 = confuse(m1837);
+
+ }
+
+ void testF1937() {
+ // A Function<A>(int x) Function(int x)
+ Expect.isTrue(f1937 is F1937);
+ Expect.isTrue(confuse(f1937) is F1937);
+ // In checked mode, verifies the type.
+ A Function<A>(int x) Function(int x) l1937;
+ // The static function f1937 sets `T` to `int`.
+ if (!tIsBool) {
+ x1937 = f1937 as dynamic;
+ l1937 = f1937 as dynamic;
+ x1937 = confuse(f1937);
+ l1937 = confuse(f1937);
+ }
+
+ Expect.isTrue(m1937 is F1937);
+ Expect.isTrue(m1937 is A Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1937) is F1937);
+ // In checked mode, verifies the type.
+ x1937 = m1937;
+ l1937 = m1937;
+ x1937 = confuse(m1937);
+ l1937 = confuse(m1937);
+
+ }
+
+
+}
+
+class C38<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([core.List<core.int> x1]) x38;
+ List<Function> Function(List<Function> x0) x138;
+ List<T> Function(int y, [Function x]) x238;
+ int Function<A>(List<Function> x) x338;
+ int Function(int x1, {int x}) Function<B extends core.int>() x438;
+ int Function([core.List<core.int> x]) Function<B extends core.int>() x538;
+ Function Function(int y, [int x]) Function<B extends core.int>() x638;
+ Function Function(int x2, [List<Function> x3]) Function<B extends core.int>() x738;
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>() x838;
+ List<Function> Function(List<Function> x) Function<B extends core.int>() x938;
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>() x1038;
+ core.List<core.int> Function([Function x1]) Function<B extends core.int>() x1138;
+ core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>() x1238;
+ List<T> Function(int y, {int x}) Function<B extends core.int>() x1338;
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() x1438;
+ Function(int x1) Function<B extends core.int>() x1538;
+ Function(int x, [List<Function> x1]) Function<B extends core.int>() x1638;
+ Function(int y, {List<T> x}) Function<B extends core.int>() x1738;
+ List<Function> Function<A>(List<A> x) Function<B extends core.int>() x1838;
+ A Function<A>(int x) Function<B extends core.int>() x1938;
+
+
+ C38({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m38([core.List<core.int> x0]) => null;
+ List<Function> m138(List<Function> x0) => null;
+ List<T> m238(int y, [Function x]) => null;
+ int m338<A>(List<Function> x) => null;
+ int Function(int x0, {int x}) m438<B extends core.int>() => null;
+ int Function([core.List<core.int> x]) m538<B extends core.int>() => null;
+ Function Function(int y, [int x]) m638<B extends core.int>() => null;
+ Function Function(int x0, [List<Function> x1]) m738<B extends core.int>() => null;
+ Function Function(int x0, {List<T> x}) m838<B extends core.int>() => null;
+ List<Function> Function(List<Function> x) m938<B extends core.int>() => null;
+ List<Function> Function(int y, [List<T> x]) m1038<B extends core.int>() => null;
+ core.List<core.int> Function([Function x0]) m1138<B extends core.int>() => null;
+ core.List<core.int> Function({core.List<core.int> x}) m1238<B extends core.int>() => null;
+ List<T> Function(int y, {int x}) m1338<B extends core.int>() => null;
+ List<T> Function(int x0, [core.List<core.int> x]) m1438<B extends core.int>() => null;
+ Function(int x0) m1538<B extends core.int>() => null;
+ Function(int x, [List<Function> x0]) m1638<B extends core.int>() => null;
+ Function(int y, {List<T> x}) m1738<B extends core.int>() => null;
+ List<Function> Function<A>(List<A> x) m1838<B extends core.int>() => null;
+ A Function<A>(int x) m1938<B extends core.int>() => null;
+
+
+ runTests() {
+ testF38();
+ testF138();
+ testF238();
+ testF338();
+ testF438();
+ testF538();
+ testF638();
+ testF738();
+ testF838();
+ testF938();
+ testF1038();
+ testF1138();
+ testF1238();
+ testF1338();
+ testF1438();
+ testF1538();
+ testF1638();
+ testF1738();
+ testF1838();
+ testF1938();
+ }
+
+ void testF38() {
+ // int Function([core.List<core.int> x1])
+ Expect.isTrue(f38 is F38);
+ Expect.isTrue(confuse(f38) is F38);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x1]) l38;
+ // The static function f38 sets `T` to `int`.
+ if (!tIsBool) {
+ x38 = f38 as dynamic;
+ l38 = f38 as dynamic;
+ x38 = confuse(f38);
+ l38 = confuse(f38);
+ }
+
+ Expect.isTrue(m38 is F38);
+ Expect.isTrue(m38 is int Function([core.List<core.int> x1]));
+ Expect.isTrue(confuse(m38) is F38);
+ // In checked mode, verifies the type.
+ x38 = m38;
+ l38 = m38;
+ x38 = confuse(m38);
+ l38 = confuse(m38);
+
+ }
+
+ void testF138() {
+ // List<Function> Function(List<Function> x0)
+ Expect.isTrue(f138 is F138);
+ Expect.isTrue(confuse(f138) is F138);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x0) l138;
+ // The static function f138 sets `T` to `int`.
+ if (!tIsBool) {
+ x138 = f138 as dynamic;
+ l138 = f138 as dynamic;
+ x138 = confuse(f138);
+ l138 = confuse(f138);
+ }
+
+ Expect.isTrue(m138 is F138);
+ Expect.isTrue(m138 is List<Function> Function(List<Function> x0));
+ Expect.isTrue(confuse(m138) is F138);
+ // In checked mode, verifies the type.
+ x138 = m138;
+ l138 = m138;
+ x138 = confuse(m138);
+ l138 = confuse(m138);
+
+ }
+
+ void testF238() {
+ // List<T> Function(int y, [Function x])
+ Expect.isTrue(f238 is F238);
+ Expect.isTrue(confuse(f238) is F238);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [Function x]) l238;
+ // The static function f238 sets `T` to `int`.
+ if (!tIsBool) {
+ x238 = f238 as dynamic;
+ l238 = f238 as dynamic;
+ x238 = confuse(f238);
+ l238 = confuse(f238);
+ }
+
+ Expect.isTrue(m238 is F238);
+ Expect.isTrue(m238 is List<T> Function(int y, [Function x]));
+ Expect.isTrue(confuse(m238) is F238);
+ // In checked mode, verifies the type.
+ x238 = m238;
+ l238 = m238;
+ x238 = confuse(m238);
+ l238 = confuse(m238);
+ if (!tIsBool) {
+ Expect.isTrue(f238 is F238<int>);
+ Expect.isFalse(f238 is F238<bool>);
+ Expect.isTrue(confuse(f238) is F238<int>);
+ Expect.isFalse(confuse(f238) is F238<bool>);
+ Expect.equals(tIsDynamic, m238 is F238<bool>);
+ Expect.equals(tIsDynamic, confuse(m238) is F238<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x238 = (f238 as dynamic); });
+ Expect.throws(() { x238 = confuse(f238); });
+ List<T> Function(int y, [Function x]) l238;
+ Expect.throws(() { l238 = (f238 as dynamic); });
+ Expect.throws(() { l238 = confuse(f238); });
+ }
+ List<T> Function(int y, [Function x]) l238 = m238;
+ // In checked mode, verifies the type.
+ x238 = m238;
+ x238 = confuse(m238);
+ }
+ }
+
+ void testF338() {
+ // int Function<A>(List<Function> x)
+ Expect.isTrue(f338 is F338);
+ Expect.isTrue(confuse(f338) is F338);
+ // In checked mode, verifies the type.
+ int Function<A>(List<Function> x) l338;
+ // The static function f338 sets `T` to `int`.
+ if (!tIsBool) {
+ x338 = f338 as dynamic;
+ l338 = f338 as dynamic;
+ x338 = confuse(f338);
+ l338 = confuse(f338);
+ }
+
+ Expect.isTrue(m338 is F338);
+ Expect.isTrue(m338 is int Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m338) is F338);
+ // In checked mode, verifies the type.
+ x338 = m338;
+ l338 = m338;
+ x338 = confuse(m338);
+ l338 = confuse(m338);
+
+ }
+
+ void testF438() {
+ // int Function(int x1, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f438 is F438);
+ Expect.isTrue(confuse(f438) is F438);
+ // In checked mode, verifies the type.
+ int Function(int x1, {int x}) Function<B extends core.int>() l438;
+ // The static function f438 sets `T` to `int`.
+ if (!tIsBool) {
+ x438 = f438 as dynamic;
+ l438 = f438 as dynamic;
+ x438 = confuse(f438);
+ l438 = confuse(f438);
+ }
+
+ Expect.isTrue(m438 is F438);
+ Expect.isTrue(m438 is int Function(int x1, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m438) is F438);
+ // In checked mode, verifies the type.
+ x438 = m438;
+ l438 = m438;
+ x438 = confuse(m438);
+ l438 = confuse(m438);
+
+ }
+
+ void testF538() {
+ // int Function([core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f538 is F538);
+ Expect.isTrue(confuse(f538) is F538);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x]) Function<B extends core.int>() l538;
+ // The static function f538 sets `T` to `int`.
+ if (!tIsBool) {
+ x538 = f538 as dynamic;
+ l538 = f538 as dynamic;
+ x538 = confuse(f538);
+ l538 = confuse(f538);
+ }
+
+ Expect.isTrue(m538 is F538);
+ Expect.isTrue(m538 is int Function([core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m538) is F538);
+ // In checked mode, verifies the type.
+ x538 = m538;
+ l538 = m538;
+ x538 = confuse(m538);
+ l538 = confuse(m538);
+
+ }
+
+ void testF638() {
+ // Function Function(int y, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f638 is F638);
+ Expect.isTrue(confuse(f638) is F638);
+ // In checked mode, verifies the type.
+ Function Function(int y, [int x]) Function<B extends core.int>() l638;
+ // The static function f638 sets `T` to `int`.
+ if (!tIsBool) {
+ x638 = f638 as dynamic;
+ l638 = f638 as dynamic;
+ x638 = confuse(f638);
+ l638 = confuse(f638);
+ }
+
+ Expect.isTrue(m638 is F638);
+ Expect.isTrue(m638 is Function Function(int y, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m638) is F638);
+ // In checked mode, verifies the type.
+ x638 = m638;
+ l638 = m638;
+ x638 = confuse(m638);
+ l638 = confuse(m638);
+
+ }
+
+ void testF738() {
+ // Function Function(int x2, [List<Function> x3]) Function<B extends core.int>()
+ Expect.isTrue(f738 is F738);
+ Expect.isTrue(confuse(f738) is F738);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [List<Function> x3]) Function<B extends core.int>() l738;
+ // The static function f738 sets `T` to `int`.
+ if (!tIsBool) {
+ x738 = f738 as dynamic;
+ l738 = f738 as dynamic;
+ x738 = confuse(f738);
+ l738 = confuse(f738);
+ }
+
+ Expect.isTrue(m738 is F738);
+ Expect.isTrue(m738 is Function Function(int x2, [List<Function> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m738) is F738);
+ // In checked mode, verifies the type.
+ x738 = m738;
+ l738 = m738;
+ x738 = confuse(m738);
+ l738 = confuse(m738);
+
+ }
+
+ void testF838() {
+ // Function Function(int x1, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f838 is F838);
+ Expect.isTrue(confuse(f838) is F838);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>() l838;
+ // The static function f838 sets `T` to `int`.
+ if (!tIsBool) {
+ x838 = f838 as dynamic;
+ l838 = f838 as dynamic;
+ x838 = confuse(f838);
+ l838 = confuse(f838);
+ }
+
+ Expect.isTrue(m838 is F838);
+ Expect.isTrue(m838 is Function Function(int x1, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m838) is F838);
+ // In checked mode, verifies the type.
+ x838 = m838;
+ l838 = m838;
+ x838 = confuse(m838);
+ l838 = confuse(m838);
+ if (!tIsBool) {
+ Expect.isTrue(f838 is F838<int>);
+ Expect.isFalse(f838 is F838<bool>);
+ Expect.isTrue(confuse(f838) is F838<int>);
+ Expect.isFalse(confuse(f838) is F838<bool>);
+ Expect.equals(tIsDynamic, m838 is F838<bool>);
+ Expect.equals(tIsDynamic, confuse(m838) is F838<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x838 = (f838 as dynamic); });
+ Expect.throws(() { x838 = confuse(f838); });
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>() l838;
+ Expect.throws(() { l838 = (f838 as dynamic); });
+ Expect.throws(() { l838 = confuse(f838); });
+ }
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>() l838 = m838;
+ // In checked mode, verifies the type.
+ x838 = m838;
+ x838 = confuse(m838);
+ }
+ }
+
+ void testF938() {
+ // List<Function> Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f938 is F938);
+ Expect.isTrue(confuse(f938) is F938);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x) Function<B extends core.int>() l938;
+ // The static function f938 sets `T` to `int`.
+ if (!tIsBool) {
+ x938 = f938 as dynamic;
+ l938 = f938 as dynamic;
+ x938 = confuse(f938);
+ l938 = confuse(f938);
+ }
+
+ Expect.isTrue(m938 is F938);
+ Expect.isTrue(m938 is List<Function> Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m938) is F938);
+ // In checked mode, verifies the type.
+ x938 = m938;
+ l938 = m938;
+ x938 = confuse(m938);
+ l938 = confuse(m938);
+
+ }
+
+ void testF1038() {
+ // List<Function> Function(int y, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1038 is F1038);
+ Expect.isTrue(confuse(f1038) is F1038);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>() l1038;
+ // The static function f1038 sets `T` to `int`.
+ if (!tIsBool) {
+ x1038 = f1038 as dynamic;
+ l1038 = f1038 as dynamic;
+ x1038 = confuse(f1038);
+ l1038 = confuse(f1038);
+ }
+
+ Expect.isTrue(m1038 is F1038);
+ Expect.isTrue(m1038 is List<Function> Function(int y, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1038) is F1038);
+ // In checked mode, verifies the type.
+ x1038 = m1038;
+ l1038 = m1038;
+ x1038 = confuse(m1038);
+ l1038 = confuse(m1038);
+ if (!tIsBool) {
+ Expect.isTrue(f1038 is F1038<int>);
+ Expect.isFalse(f1038 is F1038<bool>);
+ Expect.isTrue(confuse(f1038) is F1038<int>);
+ Expect.isFalse(confuse(f1038) is F1038<bool>);
+ Expect.equals(tIsDynamic, m1038 is F1038<bool>);
+ Expect.equals(tIsDynamic, confuse(m1038) is F1038<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1038 = (f1038 as dynamic); });
+ Expect.throws(() { x1038 = confuse(f1038); });
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>() l1038;
+ Expect.throws(() { l1038 = (f1038 as dynamic); });
+ Expect.throws(() { l1038 = confuse(f1038); });
+ }
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>() l1038 = m1038;
+ // In checked mode, verifies the type.
+ x1038 = m1038;
+ x1038 = confuse(m1038);
+ }
+ }
+
+ void testF1138() {
+ // core.List<core.int> Function([Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f1138 is F1138);
+ Expect.isTrue(confuse(f1138) is F1138);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x1]) Function<B extends core.int>() l1138;
+ // The static function f1138 sets `T` to `int`.
+ if (!tIsBool) {
+ x1138 = f1138 as dynamic;
+ l1138 = f1138 as dynamic;
+ x1138 = confuse(f1138);
+ l1138 = confuse(f1138);
+ }
+
+ Expect.isTrue(m1138 is F1138);
+ Expect.isTrue(m1138 is core.List<core.int> Function([Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1138) is F1138);
+ // In checked mode, verifies the type.
+ x1138 = m1138;
+ l1138 = m1138;
+ x1138 = confuse(m1138);
+ l1138 = confuse(m1138);
+
+ }
+
+ void testF1238() {
+ // core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1238 is F1238);
+ Expect.isTrue(confuse(f1238) is F1238);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>() l1238;
+ // The static function f1238 sets `T` to `int`.
+ if (!tIsBool) {
+ x1238 = f1238 as dynamic;
+ l1238 = f1238 as dynamic;
+ x1238 = confuse(f1238);
+ l1238 = confuse(f1238);
+ }
+
+ Expect.isTrue(m1238 is F1238);
+ Expect.isTrue(m1238 is core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1238) is F1238);
+ // In checked mode, verifies the type.
+ x1238 = m1238;
+ l1238 = m1238;
+ x1238 = confuse(m1238);
+ l1238 = confuse(m1238);
+
+ }
+
+ void testF1338() {
+ // List<T> Function(int y, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f1338 is F1338);
+ Expect.isTrue(confuse(f1338) is F1338);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {int x}) Function<B extends core.int>() l1338;
+ // The static function f1338 sets `T` to `int`.
+ if (!tIsBool) {
+ x1338 = f1338 as dynamic;
+ l1338 = f1338 as dynamic;
+ x1338 = confuse(f1338);
+ l1338 = confuse(f1338);
+ }
+
+ Expect.isTrue(m1338 is F1338);
+ Expect.isTrue(m1338 is List<T> Function(int y, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1338) is F1338);
+ // In checked mode, verifies the type.
+ x1338 = m1338;
+ l1338 = m1338;
+ x1338 = confuse(m1338);
+ l1338 = confuse(m1338);
+ if (!tIsBool) {
+ Expect.isTrue(f1338 is F1338<int>);
+ Expect.isFalse(f1338 is F1338<bool>);
+ Expect.isTrue(confuse(f1338) is F1338<int>);
+ Expect.isFalse(confuse(f1338) is F1338<bool>);
+ Expect.equals(tIsDynamic, m1338 is F1338<bool>);
+ Expect.equals(tIsDynamic, confuse(m1338) is F1338<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1338 = (f1338 as dynamic); });
+ Expect.throws(() { x1338 = confuse(f1338); });
+ List<T> Function(int y, {int x}) Function<B extends core.int>() l1338;
+ Expect.throws(() { l1338 = (f1338 as dynamic); });
+ Expect.throws(() { l1338 = confuse(f1338); });
+ }
+ List<T> Function(int y, {int x}) Function<B extends core.int>() l1338 = m1338;
+ // In checked mode, verifies the type.
+ x1338 = m1338;
+ x1338 = confuse(m1338);
+ }
+ }
+
+ void testF1438() {
+ // List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1438 is F1438);
+ Expect.isTrue(confuse(f1438) is F1438);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l1438;
+ // The static function f1438 sets `T` to `int`.
+ if (!tIsBool) {
+ x1438 = f1438 as dynamic;
+ l1438 = f1438 as dynamic;
+ x1438 = confuse(f1438);
+ l1438 = confuse(f1438);
+ }
+
+ Expect.isTrue(m1438 is F1438);
+ Expect.isTrue(m1438 is List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1438) is F1438);
+ // In checked mode, verifies the type.
+ x1438 = m1438;
+ l1438 = m1438;
+ x1438 = confuse(m1438);
+ l1438 = confuse(m1438);
+ if (!tIsBool) {
+ Expect.isTrue(f1438 is F1438<int>);
+ Expect.isFalse(f1438 is F1438<bool>);
+ Expect.isTrue(confuse(f1438) is F1438<int>);
+ Expect.isFalse(confuse(f1438) is F1438<bool>);
+ Expect.equals(tIsDynamic, m1438 is F1438<bool>);
+ Expect.equals(tIsDynamic, confuse(m1438) is F1438<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1438 = (f1438 as dynamic); });
+ Expect.throws(() { x1438 = confuse(f1438); });
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l1438;
+ Expect.throws(() { l1438 = (f1438 as dynamic); });
+ Expect.throws(() { l1438 = confuse(f1438); });
+ }
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l1438 = m1438;
+ // In checked mode, verifies the type.
+ x1438 = m1438;
+ x1438 = confuse(m1438);
+ }
+ }
+
+ void testF1538() {
+ // Function(int x1) Function<B extends core.int>()
+ Expect.isTrue(f1538 is F1538);
+ Expect.isTrue(confuse(f1538) is F1538);
+ // In checked mode, verifies the type.
+ Function(int x1) Function<B extends core.int>() l1538;
+ // The static function f1538 sets `T` to `int`.
+ if (!tIsBool) {
+ x1538 = f1538 as dynamic;
+ l1538 = f1538 as dynamic;
+ x1538 = confuse(f1538);
+ l1538 = confuse(f1538);
+ }
+
+ Expect.isTrue(m1538 is F1538);
+ Expect.isTrue(m1538 is Function(int x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1538) is F1538);
+ // In checked mode, verifies the type.
+ x1538 = m1538;
+ l1538 = m1538;
+ x1538 = confuse(m1538);
+ l1538 = confuse(m1538);
+
+ }
+
+ void testF1638() {
+ // Function(int x, [List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1638 is F1638);
+ Expect.isTrue(confuse(f1638) is F1638);
+ // In checked mode, verifies the type.
+ Function(int x, [List<Function> x1]) Function<B extends core.int>() l1638;
+ // The static function f1638 sets `T` to `int`.
+ if (!tIsBool) {
+ x1638 = f1638 as dynamic;
+ l1638 = f1638 as dynamic;
+ x1638 = confuse(f1638);
+ l1638 = confuse(f1638);
+ }
+
+ Expect.isTrue(m1638 is F1638);
+ Expect.isTrue(m1638 is Function(int x, [List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1638) is F1638);
+ // In checked mode, verifies the type.
+ x1638 = m1638;
+ l1638 = m1638;
+ x1638 = confuse(m1638);
+ l1638 = confuse(m1638);
+
+ }
+
+ void testF1738() {
+ // Function(int y, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1738 is F1738);
+ Expect.isTrue(confuse(f1738) is F1738);
+ // In checked mode, verifies the type.
+ Function(int y, {List<T> x}) Function<B extends core.int>() l1738;
+ // The static function f1738 sets `T` to `int`.
+ if (!tIsBool) {
+ x1738 = f1738 as dynamic;
+ l1738 = f1738 as dynamic;
+ x1738 = confuse(f1738);
+ l1738 = confuse(f1738);
+ }
+
+ Expect.isTrue(m1738 is F1738);
+ Expect.isTrue(m1738 is Function(int y, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1738) is F1738);
+ // In checked mode, verifies the type.
+ x1738 = m1738;
+ l1738 = m1738;
+ x1738 = confuse(m1738);
+ l1738 = confuse(m1738);
+ if (!tIsBool) {
+ Expect.isTrue(f1738 is F1738<int>);
+ Expect.isFalse(f1738 is F1738<bool>);
+ Expect.isTrue(confuse(f1738) is F1738<int>);
+ Expect.isFalse(confuse(f1738) is F1738<bool>);
+ Expect.equals(tIsDynamic, m1738 is F1738<bool>);
+ Expect.equals(tIsDynamic, confuse(m1738) is F1738<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1738 = (f1738 as dynamic); });
+ Expect.throws(() { x1738 = confuse(f1738); });
+ Function(int y, {List<T> x}) Function<B extends core.int>() l1738;
+ Expect.throws(() { l1738 = (f1738 as dynamic); });
+ Expect.throws(() { l1738 = confuse(f1738); });
+ }
+ Function(int y, {List<T> x}) Function<B extends core.int>() l1738 = m1738;
+ // In checked mode, verifies the type.
+ x1738 = m1738;
+ x1738 = confuse(m1738);
+ }
+ }
+
+ void testF1838() {
+ // List<Function> Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1838 is F1838);
+ Expect.isTrue(confuse(f1838) is F1838);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<A> x) Function<B extends core.int>() l1838;
+ // The static function f1838 sets `T` to `int`.
+ if (!tIsBool) {
+ x1838 = f1838 as dynamic;
+ l1838 = f1838 as dynamic;
+ x1838 = confuse(f1838);
+ l1838 = confuse(f1838);
+ }
+
+ Expect.isTrue(m1838 is F1838);
+ Expect.isTrue(m1838 is List<Function> Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1838) is F1838);
+ // In checked mode, verifies the type.
+ x1838 = m1838;
+ l1838 = m1838;
+ x1838 = confuse(m1838);
+ l1838 = confuse(m1838);
+
+ }
+
+ void testF1938() {
+ // A Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1938 is F1938);
+ Expect.isTrue(confuse(f1938) is F1938);
+ // In checked mode, verifies the type.
+ A Function<A>(int x) Function<B extends core.int>() l1938;
+ // The static function f1938 sets `T` to `int`.
+ if (!tIsBool) {
+ x1938 = f1938 as dynamic;
+ l1938 = f1938 as dynamic;
+ x1938 = confuse(f1938);
+ l1938 = confuse(f1938);
+ }
+
+ Expect.isTrue(m1938 is F1938);
+ Expect.isTrue(m1938 is A Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1938) is F1938);
+ // In checked mode, verifies the type.
+ x1938 = m1938;
+ l1938 = m1938;
+ x1938 = confuse(m1938);
+ l1938 = confuse(m1938);
+
+ }
+
+
+}
+
+class C39<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x1, [core.List<core.int> x2]) x39;
+ List<Function> Function([List<Function> x1]) x139;
+ List<T> Function(Function x0) x239;
+ int Function<A>(core.List<core.int> x) x339;
+ int Function(int x1, {int x}) Function<B extends core.int>(int x) x439;
+ int Function([core.List<core.int> x]) Function<B extends core.int>(int x) x539;
+ Function Function(int y, [int x]) Function<B extends core.int>(int x) x639;
+ Function Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) x739;
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x) x839;
+ List<Function> Function(List<Function> x) Function<B extends core.int>(int x) x939;
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x) x1039;
+ core.List<core.int> Function([Function x1]) Function<B extends core.int>(int x) x1139;
+ core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>(int x) x1239;
+ List<T> Function(int y, {int x}) Function<B extends core.int>(int x) x1339;
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) x1439;
+ Function(int x1) Function<B extends core.int>(int x) x1539;
+ Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) x1639;
+ Function(int y, {List<T> x}) Function<B extends core.int>(int x) x1739;
+ List<Function> Function<A>(List<A> x) Function<B extends core.int>(int x) x1839;
+ A Function<A>(int x) Function<B extends core.int>(int x) x1939;
+
+
+ C39({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m39(int x0, [core.List<core.int> x1]) => null;
+ List<Function> m139([List<Function> x0]) => null;
+ List<T> m239(Function x0) => null;
+ int m339<A>(core.List<core.int> x) => null;
+ int Function(int x0, {int x}) m439<B extends core.int>(int x) => null;
+ int Function([core.List<core.int> x]) m539<B extends core.int>(int x) => null;
+ Function Function(int y, [int x]) m639<B extends core.int>(int x) => null;
+ Function Function(int x0, [List<Function> x1]) m739<B extends core.int>(int x) => null;
+ Function Function(int x0, {List<T> x}) m839<B extends core.int>(int x) => null;
+ List<Function> Function(List<Function> x) m939<B extends core.int>(int x) => null;
+ List<Function> Function(int y, [List<T> x]) m1039<B extends core.int>(int x) => null;
+ core.List<core.int> Function([Function x0]) m1139<B extends core.int>(int x) => null;
+ core.List<core.int> Function({core.List<core.int> x}) m1239<B extends core.int>(int x) => null;
+ List<T> Function(int y, {int x}) m1339<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [core.List<core.int> x]) m1439<B extends core.int>(int x) => null;
+ Function(int x0) m1539<B extends core.int>(int x) => null;
+ Function(int x, [List<Function> x0]) m1639<B extends core.int>(int x) => null;
+ Function(int y, {List<T> x}) m1739<B extends core.int>(int x) => null;
+ List<Function> Function<A>(List<A> x) m1839<B extends core.int>(int x) => null;
+ A Function<A>(int x) m1939<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF39();
+ testF139();
+ testF239();
+ testF339();
+ testF439();
+ testF539();
+ testF639();
+ testF739();
+ testF839();
+ testF939();
+ testF1039();
+ testF1139();
+ testF1239();
+ testF1339();
+ testF1439();
+ testF1539();
+ testF1639();
+ testF1739();
+ testF1839();
+ testF1939();
+ }
+
+ void testF39() {
+ // int Function(int x1, [core.List<core.int> x2])
+ Expect.isTrue(f39 is F39);
+ Expect.isTrue(confuse(f39) is F39);
+ // In checked mode, verifies the type.
+ int Function(int x1, [core.List<core.int> x2]) l39;
+ // The static function f39 sets `T` to `int`.
+ if (!tIsBool) {
+ x39 = f39 as dynamic;
+ l39 = f39 as dynamic;
+ x39 = confuse(f39);
+ l39 = confuse(f39);
+ }
+
+ Expect.isTrue(m39 is F39);
+ Expect.isTrue(m39 is int Function(int x1, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m39) is F39);
+ // In checked mode, verifies the type.
+ x39 = m39;
+ l39 = m39;
+ x39 = confuse(m39);
+ l39 = confuse(m39);
+
+ }
+
+ void testF139() {
+ // List<Function> Function([List<Function> x1])
+ Expect.isTrue(f139 is F139);
+ Expect.isTrue(confuse(f139) is F139);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x1]) l139;
+ // The static function f139 sets `T` to `int`.
+ if (!tIsBool) {
+ x139 = f139 as dynamic;
+ l139 = f139 as dynamic;
+ x139 = confuse(f139);
+ l139 = confuse(f139);
+ }
+
+ Expect.isTrue(m139 is F139);
+ Expect.isTrue(m139 is List<Function> Function([List<Function> x1]));
+ Expect.isTrue(confuse(m139) is F139);
+ // In checked mode, verifies the type.
+ x139 = m139;
+ l139 = m139;
+ x139 = confuse(m139);
+ l139 = confuse(m139);
+
+ }
+
+ void testF239() {
+ // List<T> Function(Function x0)
+ Expect.isTrue(f239 is F239);
+ Expect.isTrue(confuse(f239) is F239);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x0) l239;
+ // The static function f239 sets `T` to `int`.
+ if (!tIsBool) {
+ x239 = f239 as dynamic;
+ l239 = f239 as dynamic;
+ x239 = confuse(f239);
+ l239 = confuse(f239);
+ }
+
+ Expect.isTrue(m239 is F239);
+ Expect.isTrue(m239 is List<T> Function(Function x0));
+ Expect.isTrue(confuse(m239) is F239);
+ // In checked mode, verifies the type.
+ x239 = m239;
+ l239 = m239;
+ x239 = confuse(m239);
+ l239 = confuse(m239);
+ if (!tIsBool) {
+ Expect.isTrue(f239 is F239<int>);
+ Expect.isFalse(f239 is F239<bool>);
+ Expect.isTrue(confuse(f239) is F239<int>);
+ Expect.isFalse(confuse(f239) is F239<bool>);
+ Expect.equals(tIsDynamic, m239 is F239<bool>);
+ Expect.equals(tIsDynamic, confuse(m239) is F239<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x239 = (f239 as dynamic); });
+ Expect.throws(() { x239 = confuse(f239); });
+ List<T> Function(Function x0) l239;
+ Expect.throws(() { l239 = (f239 as dynamic); });
+ Expect.throws(() { l239 = confuse(f239); });
+ }
+ List<T> Function(Function x0) l239 = m239;
+ // In checked mode, verifies the type.
+ x239 = m239;
+ x239 = confuse(m239);
+ }
+ }
+
+ void testF339() {
+ // int Function<A>(core.List<core.int> x)
+ Expect.isTrue(f339 is F339);
+ Expect.isTrue(confuse(f339) is F339);
+ // In checked mode, verifies the type.
+ int Function<A>(core.List<core.int> x) l339;
+ // The static function f339 sets `T` to `int`.
+ if (!tIsBool) {
+ x339 = f339 as dynamic;
+ l339 = f339 as dynamic;
+ x339 = confuse(f339);
+ l339 = confuse(f339);
+ }
+
+ Expect.isTrue(m339 is F339);
+ Expect.isTrue(m339 is int Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m339) is F339);
+ // In checked mode, verifies the type.
+ x339 = m339;
+ l339 = m339;
+ x339 = confuse(m339);
+ l339 = confuse(m339);
+
+ }
+
+ void testF439() {
+ // int Function(int x1, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f439 is F439);
+ Expect.isTrue(confuse(f439) is F439);
+ // In checked mode, verifies the type.
+ int Function(int x1, {int x}) Function<B extends core.int>(int x) l439;
+ // The static function f439 sets `T` to `int`.
+ if (!tIsBool) {
+ x439 = f439 as dynamic;
+ l439 = f439 as dynamic;
+ x439 = confuse(f439);
+ l439 = confuse(f439);
+ }
+
+ Expect.isTrue(m439 is F439);
+ Expect.isTrue(m439 is int Function(int x1, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m439) is F439);
+ // In checked mode, verifies the type.
+ x439 = m439;
+ l439 = m439;
+ x439 = confuse(m439);
+ l439 = confuse(m439);
+
+ }
+
+ void testF539() {
+ // int Function([core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f539 is F539);
+ Expect.isTrue(confuse(f539) is F539);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x]) Function<B extends core.int>(int x) l539;
+ // The static function f539 sets `T` to `int`.
+ if (!tIsBool) {
+ x539 = f539 as dynamic;
+ l539 = f539 as dynamic;
+ x539 = confuse(f539);
+ l539 = confuse(f539);
+ }
+
+ Expect.isTrue(m539 is F539);
+ Expect.isTrue(m539 is int Function([core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m539) is F539);
+ // In checked mode, verifies the type.
+ x539 = m539;
+ l539 = m539;
+ x539 = confuse(m539);
+ l539 = confuse(m539);
+
+ }
+
+ void testF639() {
+ // Function Function(int y, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f639 is F639);
+ Expect.isTrue(confuse(f639) is F639);
+ // In checked mode, verifies the type.
+ Function Function(int y, [int x]) Function<B extends core.int>(int x) l639;
+ // The static function f639 sets `T` to `int`.
+ if (!tIsBool) {
+ x639 = f639 as dynamic;
+ l639 = f639 as dynamic;
+ x639 = confuse(f639);
+ l639 = confuse(f639);
+ }
+
+ Expect.isTrue(m639 is F639);
+ Expect.isTrue(m639 is Function Function(int y, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m639) is F639);
+ // In checked mode, verifies the type.
+ x639 = m639;
+ l639 = m639;
+ x639 = confuse(m639);
+ l639 = confuse(m639);
+
+ }
+
+ void testF739() {
+ // Function Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f739 is F739);
+ Expect.isTrue(confuse(f739) is F739);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l739;
+ // The static function f739 sets `T` to `int`.
+ if (!tIsBool) {
+ x739 = f739 as dynamic;
+ l739 = f739 as dynamic;
+ x739 = confuse(f739);
+ l739 = confuse(f739);
+ }
+
+ Expect.isTrue(m739 is F739);
+ Expect.isTrue(m739 is Function Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m739) is F739);
+ // In checked mode, verifies the type.
+ x739 = m739;
+ l739 = m739;
+ x739 = confuse(m739);
+ l739 = confuse(m739);
+
+ }
+
+ void testF839() {
+ // Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f839 is F839);
+ Expect.isTrue(confuse(f839) is F839);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l839;
+ // The static function f839 sets `T` to `int`.
+ if (!tIsBool) {
+ x839 = f839 as dynamic;
+ l839 = f839 as dynamic;
+ x839 = confuse(f839);
+ l839 = confuse(f839);
+ }
+
+ Expect.isTrue(m839 is F839);
+ Expect.isTrue(m839 is Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m839) is F839);
+ // In checked mode, verifies the type.
+ x839 = m839;
+ l839 = m839;
+ x839 = confuse(m839);
+ l839 = confuse(m839);
+ if (!tIsBool) {
+ Expect.isTrue(f839 is F839<int>);
+ Expect.isFalse(f839 is F839<bool>);
+ Expect.isTrue(confuse(f839) is F839<int>);
+ Expect.isFalse(confuse(f839) is F839<bool>);
+ Expect.equals(tIsDynamic, m839 is F839<bool>);
+ Expect.equals(tIsDynamic, confuse(m839) is F839<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x839 = (f839 as dynamic); });
+ Expect.throws(() { x839 = confuse(f839); });
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l839;
+ Expect.throws(() { l839 = (f839 as dynamic); });
+ Expect.throws(() { l839 = confuse(f839); });
+ }
+ Function Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l839 = m839;
+ // In checked mode, verifies the type.
+ x839 = m839;
+ x839 = confuse(m839);
+ }
+ }
+
+ void testF939() {
+ // List<Function> Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f939 is F939);
+ Expect.isTrue(confuse(f939) is F939);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x) Function<B extends core.int>(int x) l939;
+ // The static function f939 sets `T` to `int`.
+ if (!tIsBool) {
+ x939 = f939 as dynamic;
+ l939 = f939 as dynamic;
+ x939 = confuse(f939);
+ l939 = confuse(f939);
+ }
+
+ Expect.isTrue(m939 is F939);
+ Expect.isTrue(m939 is List<Function> Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m939) is F939);
+ // In checked mode, verifies the type.
+ x939 = m939;
+ l939 = m939;
+ x939 = confuse(m939);
+ l939 = confuse(m939);
+
+ }
+
+ void testF1039() {
+ // List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1039 is F1039);
+ Expect.isTrue(confuse(f1039) is F1039);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1039;
+ // The static function f1039 sets `T` to `int`.
+ if (!tIsBool) {
+ x1039 = f1039 as dynamic;
+ l1039 = f1039 as dynamic;
+ x1039 = confuse(f1039);
+ l1039 = confuse(f1039);
+ }
+
+ Expect.isTrue(m1039 is F1039);
+ Expect.isTrue(m1039 is List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1039) is F1039);
+ // In checked mode, verifies the type.
+ x1039 = m1039;
+ l1039 = m1039;
+ x1039 = confuse(m1039);
+ l1039 = confuse(m1039);
+ if (!tIsBool) {
+ Expect.isTrue(f1039 is F1039<int>);
+ Expect.isFalse(f1039 is F1039<bool>);
+ Expect.isTrue(confuse(f1039) is F1039<int>);
+ Expect.isFalse(confuse(f1039) is F1039<bool>);
+ Expect.equals(tIsDynamic, m1039 is F1039<bool>);
+ Expect.equals(tIsDynamic, confuse(m1039) is F1039<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1039 = (f1039 as dynamic); });
+ Expect.throws(() { x1039 = confuse(f1039); });
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1039;
+ Expect.throws(() { l1039 = (f1039 as dynamic); });
+ Expect.throws(() { l1039 = confuse(f1039); });
+ }
+ List<Function> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1039 = m1039;
+ // In checked mode, verifies the type.
+ x1039 = m1039;
+ x1039 = confuse(m1039);
+ }
+ }
+
+ void testF1139() {
+ // core.List<core.int> Function([Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1139 is F1139);
+ Expect.isTrue(confuse(f1139) is F1139);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x1]) Function<B extends core.int>(int x) l1139;
+ // The static function f1139 sets `T` to `int`.
+ if (!tIsBool) {
+ x1139 = f1139 as dynamic;
+ l1139 = f1139 as dynamic;
+ x1139 = confuse(f1139);
+ l1139 = confuse(f1139);
+ }
+
+ Expect.isTrue(m1139 is F1139);
+ Expect.isTrue(m1139 is core.List<core.int> Function([Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1139) is F1139);
+ // In checked mode, verifies the type.
+ x1139 = m1139;
+ l1139 = m1139;
+ x1139 = confuse(m1139);
+ l1139 = confuse(m1139);
+
+ }
+
+ void testF1239() {
+ // core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1239 is F1239);
+ Expect.isTrue(confuse(f1239) is F1239);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>(int x) l1239;
+ // The static function f1239 sets `T` to `int`.
+ if (!tIsBool) {
+ x1239 = f1239 as dynamic;
+ l1239 = f1239 as dynamic;
+ x1239 = confuse(f1239);
+ l1239 = confuse(f1239);
+ }
+
+ Expect.isTrue(m1239 is F1239);
+ Expect.isTrue(m1239 is core.List<core.int> Function({core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1239) is F1239);
+ // In checked mode, verifies the type.
+ x1239 = m1239;
+ l1239 = m1239;
+ x1239 = confuse(m1239);
+ l1239 = confuse(m1239);
+
+ }
+
+ void testF1339() {
+ // List<T> Function(int y, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1339 is F1339);
+ Expect.isTrue(confuse(f1339) is F1339);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {int x}) Function<B extends core.int>(int x) l1339;
+ // The static function f1339 sets `T` to `int`.
+ if (!tIsBool) {
+ x1339 = f1339 as dynamic;
+ l1339 = f1339 as dynamic;
+ x1339 = confuse(f1339);
+ l1339 = confuse(f1339);
+ }
+
+ Expect.isTrue(m1339 is F1339);
+ Expect.isTrue(m1339 is List<T> Function(int y, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1339) is F1339);
+ // In checked mode, verifies the type.
+ x1339 = m1339;
+ l1339 = m1339;
+ x1339 = confuse(m1339);
+ l1339 = confuse(m1339);
+ if (!tIsBool) {
+ Expect.isTrue(f1339 is F1339<int>);
+ Expect.isFalse(f1339 is F1339<bool>);
+ Expect.isTrue(confuse(f1339) is F1339<int>);
+ Expect.isFalse(confuse(f1339) is F1339<bool>);
+ Expect.equals(tIsDynamic, m1339 is F1339<bool>);
+ Expect.equals(tIsDynamic, confuse(m1339) is F1339<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1339 = (f1339 as dynamic); });
+ Expect.throws(() { x1339 = confuse(f1339); });
+ List<T> Function(int y, {int x}) Function<B extends core.int>(int x) l1339;
+ Expect.throws(() { l1339 = (f1339 as dynamic); });
+ Expect.throws(() { l1339 = confuse(f1339); });
+ }
+ List<T> Function(int y, {int x}) Function<B extends core.int>(int x) l1339 = m1339;
+ // In checked mode, verifies the type.
+ x1339 = m1339;
+ x1339 = confuse(m1339);
+ }
+ }
+
+ void testF1439() {
+ // List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1439 is F1439);
+ Expect.isTrue(confuse(f1439) is F1439);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l1439;
+ // The static function f1439 sets `T` to `int`.
+ if (!tIsBool) {
+ x1439 = f1439 as dynamic;
+ l1439 = f1439 as dynamic;
+ x1439 = confuse(f1439);
+ l1439 = confuse(f1439);
+ }
+
+ Expect.isTrue(m1439 is F1439);
+ Expect.isTrue(m1439 is List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1439) is F1439);
+ // In checked mode, verifies the type.
+ x1439 = m1439;
+ l1439 = m1439;
+ x1439 = confuse(m1439);
+ l1439 = confuse(m1439);
+ if (!tIsBool) {
+ Expect.isTrue(f1439 is F1439<int>);
+ Expect.isFalse(f1439 is F1439<bool>);
+ Expect.isTrue(confuse(f1439) is F1439<int>);
+ Expect.isFalse(confuse(f1439) is F1439<bool>);
+ Expect.equals(tIsDynamic, m1439 is F1439<bool>);
+ Expect.equals(tIsDynamic, confuse(m1439) is F1439<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1439 = (f1439 as dynamic); });
+ Expect.throws(() { x1439 = confuse(f1439); });
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l1439;
+ Expect.throws(() { l1439 = (f1439 as dynamic); });
+ Expect.throws(() { l1439 = confuse(f1439); });
+ }
+ List<T> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l1439 = m1439;
+ // In checked mode, verifies the type.
+ x1439 = m1439;
+ x1439 = confuse(m1439);
+ }
+ }
+
+ void testF1539() {
+ // Function(int x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1539 is F1539);
+ Expect.isTrue(confuse(f1539) is F1539);
+ // In checked mode, verifies the type.
+ Function(int x1) Function<B extends core.int>(int x) l1539;
+ // The static function f1539 sets `T` to `int`.
+ if (!tIsBool) {
+ x1539 = f1539 as dynamic;
+ l1539 = f1539 as dynamic;
+ x1539 = confuse(f1539);
+ l1539 = confuse(f1539);
+ }
+
+ Expect.isTrue(m1539 is F1539);
+ Expect.isTrue(m1539 is Function(int x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1539) is F1539);
+ // In checked mode, verifies the type.
+ x1539 = m1539;
+ l1539 = m1539;
+ x1539 = confuse(m1539);
+ l1539 = confuse(m1539);
+
+ }
+
+ void testF1639() {
+ // Function(int x, [List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1639 is F1639);
+ Expect.isTrue(confuse(f1639) is F1639);
+ // In checked mode, verifies the type.
+ Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l1639;
+ // The static function f1639 sets `T` to `int`.
+ if (!tIsBool) {
+ x1639 = f1639 as dynamic;
+ l1639 = f1639 as dynamic;
+ x1639 = confuse(f1639);
+ l1639 = confuse(f1639);
+ }
+
+ Expect.isTrue(m1639 is F1639);
+ Expect.isTrue(m1639 is Function(int x, [List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1639) is F1639);
+ // In checked mode, verifies the type.
+ x1639 = m1639;
+ l1639 = m1639;
+ x1639 = confuse(m1639);
+ l1639 = confuse(m1639);
+
+ }
+
+ void testF1739() {
+ // Function(int y, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1739 is F1739);
+ Expect.isTrue(confuse(f1739) is F1739);
+ // In checked mode, verifies the type.
+ Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1739;
+ // The static function f1739 sets `T` to `int`.
+ if (!tIsBool) {
+ x1739 = f1739 as dynamic;
+ l1739 = f1739 as dynamic;
+ x1739 = confuse(f1739);
+ l1739 = confuse(f1739);
+ }
+
+ Expect.isTrue(m1739 is F1739);
+ Expect.isTrue(m1739 is Function(int y, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1739) is F1739);
+ // In checked mode, verifies the type.
+ x1739 = m1739;
+ l1739 = m1739;
+ x1739 = confuse(m1739);
+ l1739 = confuse(m1739);
+ if (!tIsBool) {
+ Expect.isTrue(f1739 is F1739<int>);
+ Expect.isFalse(f1739 is F1739<bool>);
+ Expect.isTrue(confuse(f1739) is F1739<int>);
+ Expect.isFalse(confuse(f1739) is F1739<bool>);
+ Expect.equals(tIsDynamic, m1739 is F1739<bool>);
+ Expect.equals(tIsDynamic, confuse(m1739) is F1739<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1739 = (f1739 as dynamic); });
+ Expect.throws(() { x1739 = confuse(f1739); });
+ Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1739;
+ Expect.throws(() { l1739 = (f1739 as dynamic); });
+ Expect.throws(() { l1739 = confuse(f1739); });
+ }
+ Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1739 = m1739;
+ // In checked mode, verifies the type.
+ x1739 = m1739;
+ x1739 = confuse(m1739);
+ }
+ }
+
+ void testF1839() {
+ // List<Function> Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1839 is F1839);
+ Expect.isTrue(confuse(f1839) is F1839);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<A> x) Function<B extends core.int>(int x) l1839;
+ // The static function f1839 sets `T` to `int`.
+ if (!tIsBool) {
+ x1839 = f1839 as dynamic;
+ l1839 = f1839 as dynamic;
+ x1839 = confuse(f1839);
+ l1839 = confuse(f1839);
+ }
+
+ Expect.isTrue(m1839 is F1839);
+ Expect.isTrue(m1839 is List<Function> Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1839) is F1839);
+ // In checked mode, verifies the type.
+ x1839 = m1839;
+ l1839 = m1839;
+ x1839 = confuse(m1839);
+ l1839 = confuse(m1839);
+
+ }
+
+ void testF1939() {
+ // A Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1939 is F1939);
+ Expect.isTrue(confuse(f1939) is F1939);
+ // In checked mode, verifies the type.
+ A Function<A>(int x) Function<B extends core.int>(int x) l1939;
+ // The static function f1939 sets `T` to `int`.
+ if (!tIsBool) {
+ x1939 = f1939 as dynamic;
+ l1939 = f1939 as dynamic;
+ x1939 = confuse(f1939);
+ l1939 = confuse(f1939);
+ }
+
+ Expect.isTrue(m1939 is F1939);
+ Expect.isTrue(m1939 is A Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1939) is F1939);
+ // In checked mode, verifies the type.
+ x1939 = m1939;
+ l1939 = m1939;
+ x1939 = confuse(m1939);
+ l1939 = confuse(m1939);
+
+ }
+
+
+}
+
+class C40<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x, [core.List<core.int> x2]) x40;
+ List<Function> Function(int x1, [List<Function> x2]) x140;
+ List<T> Function([Function x1]) x240;
+ int Function<A>(List<T> x) x340;
+ int Function(int y, {int x}) Function() x440;
+ int Function(int x0, [core.List<core.int> x]) Function() x540;
+ Function Function(int x0) Function() x640;
+ Function Function(int x, [List<Function> x2]) Function() x740;
+ Function Function(int y, {List<T> x}) Function() x840;
+ List<Function> Function([List<Function> x]) Function() x940;
+ List<Function> Function(List<T> x0) Function() x1040;
+ core.List<core.int> Function(int x1, [Function x2]) Function() x1140;
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) Function() x1240;
+ List<T> Function(Function x) Function() x1340;
+ List<T> Function(int y, [core.List<core.int> x]) Function() x1440;
+ Function([int x1]) Function() x1540;
+ Function({List<Function> x}) Function() x1640;
+ Function() Function() x1740;
+ core.List<core.int> Function<A>(int x) Function() x1840;
+ A Function<A>(Function x) Function() x1940;
+
+
+ C40({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m40(int x, [core.List<core.int> x0]) => null;
+ List<Function> m140(int x0, [List<Function> x1]) => null;
+ List<T> m240([Function x0]) => null;
+ int m340<A>(List<T> x) => null;
+ int Function(int y, {int x}) m440() => null;
+ int Function(int x0, [core.List<core.int> x]) m540() => null;
+ Function Function(int x0) m640() => null;
+ Function Function(int x, [List<Function> x0]) m740() => null;
+ Function Function(int y, {List<T> x}) m840() => null;
+ List<Function> Function([List<Function> x]) m940() => null;
+ List<Function> Function(List<T> x0) m1040() => null;
+ core.List<core.int> Function(int x0, [Function x1]) m1140() => null;
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) m1240() => null;
+ List<T> Function(Function x) m1340() => null;
+ List<T> Function(int y, [core.List<core.int> x]) m1440() => null;
+ Function([int x0]) m1540() => null;
+ Function({List<Function> x}) m1640() => null;
+ Function() m1740() => null;
+ core.List<core.int> Function<A>(int x) m1840() => null;
+ A Function<A>(Function x) m1940() => null;
+
+
+ runTests() {
+ testF40();
+ testF140();
+ testF240();
+ testF340();
+ testF440();
+ testF540();
+ testF640();
+ testF740();
+ testF840();
+ testF940();
+ testF1040();
+ testF1140();
+ testF1240();
+ testF1340();
+ testF1440();
+ testF1540();
+ testF1640();
+ testF1740();
+ testF1840();
+ testF1940();
+ }
+
+ void testF40() {
+ // int Function(int x, [core.List<core.int> x2])
+ Expect.isTrue(f40 is F40);
+ Expect.isTrue(confuse(f40) is F40);
+ // In checked mode, verifies the type.
+ int Function(int x, [core.List<core.int> x2]) l40;
+ // The static function f40 sets `T` to `int`.
+ if (!tIsBool) {
+ x40 = f40 as dynamic;
+ l40 = f40 as dynamic;
+ x40 = confuse(f40);
+ l40 = confuse(f40);
+ }
+
+ Expect.isTrue(m40 is F40);
+ Expect.isTrue(m40 is int Function(int x, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m40) is F40);
+ // In checked mode, verifies the type.
+ x40 = m40;
+ l40 = m40;
+ x40 = confuse(m40);
+ l40 = confuse(m40);
+
+ }
+
+ void testF140() {
+ // List<Function> Function(int x1, [List<Function> x2])
+ Expect.isTrue(f140 is F140);
+ Expect.isTrue(confuse(f140) is F140);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<Function> x2]) l140;
+ // The static function f140 sets `T` to `int`.
+ if (!tIsBool) {
+ x140 = f140 as dynamic;
+ l140 = f140 as dynamic;
+ x140 = confuse(f140);
+ l140 = confuse(f140);
+ }
+
+ Expect.isTrue(m140 is F140);
+ Expect.isTrue(m140 is List<Function> Function(int x1, [List<Function> x2]));
+ Expect.isTrue(confuse(m140) is F140);
+ // In checked mode, verifies the type.
+ x140 = m140;
+ l140 = m140;
+ x140 = confuse(m140);
+ l140 = confuse(m140);
+
+ }
+
+ void testF240() {
+ // List<T> Function([Function x1])
+ Expect.isTrue(f240 is F240);
+ Expect.isTrue(confuse(f240) is F240);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x1]) l240;
+ // The static function f240 sets `T` to `int`.
+ if (!tIsBool) {
+ x240 = f240 as dynamic;
+ l240 = f240 as dynamic;
+ x240 = confuse(f240);
+ l240 = confuse(f240);
+ }
+
+ Expect.isTrue(m240 is F240);
+ Expect.isTrue(m240 is List<T> Function([Function x1]));
+ Expect.isTrue(confuse(m240) is F240);
+ // In checked mode, verifies the type.
+ x240 = m240;
+ l240 = m240;
+ x240 = confuse(m240);
+ l240 = confuse(m240);
+ if (!tIsBool) {
+ Expect.isTrue(f240 is F240<int>);
+ Expect.isFalse(f240 is F240<bool>);
+ Expect.isTrue(confuse(f240) is F240<int>);
+ Expect.isFalse(confuse(f240) is F240<bool>);
+ Expect.equals(tIsDynamic, m240 is F240<bool>);
+ Expect.equals(tIsDynamic, confuse(m240) is F240<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x240 = (f240 as dynamic); });
+ Expect.throws(() { x240 = confuse(f240); });
+ List<T> Function([Function x1]) l240;
+ Expect.throws(() { l240 = (f240 as dynamic); });
+ Expect.throws(() { l240 = confuse(f240); });
+ }
+ List<T> Function([Function x1]) l240 = m240;
+ // In checked mode, verifies the type.
+ x240 = m240;
+ x240 = confuse(m240);
+ }
+ }
+
+ void testF340() {
+ // int Function<A>(List<T> x)
+ Expect.isTrue(f340 is F340);
+ Expect.isTrue(confuse(f340) is F340);
+ // In checked mode, verifies the type.
+ int Function<A>(List<T> x) l340;
+ // The static function f340 sets `T` to `int`.
+ if (!tIsBool) {
+ x340 = f340 as dynamic;
+ l340 = f340 as dynamic;
+ x340 = confuse(f340);
+ l340 = confuse(f340);
+ }
+
+ Expect.isTrue(m340 is F340);
+ Expect.isTrue(m340 is int Function<A>(List<T> x));
+ Expect.isTrue(confuse(m340) is F340);
+ // In checked mode, verifies the type.
+ x340 = m340;
+ l340 = m340;
+ x340 = confuse(m340);
+ l340 = confuse(m340);
+ if (!tIsBool) {
+ Expect.isTrue(f340 is F340<int>);
+ Expect.isFalse(f340 is F340<bool>);
+ Expect.isTrue(confuse(f340) is F340<int>);
+ Expect.isFalse(confuse(f340) is F340<bool>);
+ Expect.equals(tIsDynamic, m340 is F340<bool>);
+ Expect.equals(tIsDynamic, confuse(m340) is F340<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x340 = (f340 as dynamic); });
+ Expect.throws(() { x340 = confuse(f340); });
+ int Function<A>(List<T> x) l340;
+ Expect.throws(() { l340 = (f340 as dynamic); });
+ Expect.throws(() { l340 = confuse(f340); });
+ }
+ int Function<A>(List<T> x) l340 = m340;
+ // In checked mode, verifies the type.
+ x340 = m340;
+ x340 = confuse(m340);
+ }
+ }
+
+ void testF440() {
+ // int Function(int y, {int x}) Function()
+ Expect.isTrue(f440 is F440);
+ Expect.isTrue(confuse(f440) is F440);
+ // In checked mode, verifies the type.
+ int Function(int y, {int x}) Function() l440;
+ // The static function f440 sets `T` to `int`.
+ if (!tIsBool) {
+ x440 = f440 as dynamic;
+ l440 = f440 as dynamic;
+ x440 = confuse(f440);
+ l440 = confuse(f440);
+ }
+
+ Expect.isTrue(m440 is F440);
+ Expect.isTrue(m440 is int Function(int y, {int x}) Function());
+ Expect.isTrue(confuse(m440) is F440);
+ // In checked mode, verifies the type.
+ x440 = m440;
+ l440 = m440;
+ x440 = confuse(m440);
+ l440 = confuse(m440);
+
+ }
+
+ void testF540() {
+ // int Function(int x0, [core.List<core.int> x]) Function()
+ Expect.isTrue(f540 is F540);
+ Expect.isTrue(confuse(f540) is F540);
+ // In checked mode, verifies the type.
+ int Function(int x0, [core.List<core.int> x]) Function() l540;
+ // The static function f540 sets `T` to `int`.
+ if (!tIsBool) {
+ x540 = f540 as dynamic;
+ l540 = f540 as dynamic;
+ x540 = confuse(f540);
+ l540 = confuse(f540);
+ }
+
+ Expect.isTrue(m540 is F540);
+ Expect.isTrue(m540 is int Function(int x0, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m540) is F540);
+ // In checked mode, verifies the type.
+ x540 = m540;
+ l540 = m540;
+ x540 = confuse(m540);
+ l540 = confuse(m540);
+
+ }
+
+ void testF640() {
+ // Function Function(int x0) Function()
+ Expect.isTrue(f640 is F640);
+ Expect.isTrue(confuse(f640) is F640);
+ // In checked mode, verifies the type.
+ Function Function(int x0) Function() l640;
+ // The static function f640 sets `T` to `int`.
+ if (!tIsBool) {
+ x640 = f640 as dynamic;
+ l640 = f640 as dynamic;
+ x640 = confuse(f640);
+ l640 = confuse(f640);
+ }
+
+ Expect.isTrue(m640 is F640);
+ Expect.isTrue(m640 is Function Function(int x0) Function());
+ Expect.isTrue(confuse(m640) is F640);
+ // In checked mode, verifies the type.
+ x640 = m640;
+ l640 = m640;
+ x640 = confuse(m640);
+ l640 = confuse(m640);
+
+ }
+
+ void testF740() {
+ // Function Function(int x, [List<Function> x2]) Function()
+ Expect.isTrue(f740 is F740);
+ Expect.isTrue(confuse(f740) is F740);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<Function> x2]) Function() l740;
+ // The static function f740 sets `T` to `int`.
+ if (!tIsBool) {
+ x740 = f740 as dynamic;
+ l740 = f740 as dynamic;
+ x740 = confuse(f740);
+ l740 = confuse(f740);
+ }
+
+ Expect.isTrue(m740 is F740);
+ Expect.isTrue(m740 is Function Function(int x, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m740) is F740);
+ // In checked mode, verifies the type.
+ x740 = m740;
+ l740 = m740;
+ x740 = confuse(m740);
+ l740 = confuse(m740);
+
+ }
+
+ void testF840() {
+ // Function Function(int y, {List<T> x}) Function()
+ Expect.isTrue(f840 is F840);
+ Expect.isTrue(confuse(f840) is F840);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<T> x}) Function() l840;
+ // The static function f840 sets `T` to `int`.
+ if (!tIsBool) {
+ x840 = f840 as dynamic;
+ l840 = f840 as dynamic;
+ x840 = confuse(f840);
+ l840 = confuse(f840);
+ }
+
+ Expect.isTrue(m840 is F840);
+ Expect.isTrue(m840 is Function Function(int y, {List<T> x}) Function());
+ Expect.isTrue(confuse(m840) is F840);
+ // In checked mode, verifies the type.
+ x840 = m840;
+ l840 = m840;
+ x840 = confuse(m840);
+ l840 = confuse(m840);
+ if (!tIsBool) {
+ Expect.isTrue(f840 is F840<int>);
+ Expect.isFalse(f840 is F840<bool>);
+ Expect.isTrue(confuse(f840) is F840<int>);
+ Expect.isFalse(confuse(f840) is F840<bool>);
+ Expect.equals(tIsDynamic, m840 is F840<bool>);
+ Expect.equals(tIsDynamic, confuse(m840) is F840<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x840 = (f840 as dynamic); });
+ Expect.throws(() { x840 = confuse(f840); });
+ Function Function(int y, {List<T> x}) Function() l840;
+ Expect.throws(() { l840 = (f840 as dynamic); });
+ Expect.throws(() { l840 = confuse(f840); });
+ }
+ Function Function(int y, {List<T> x}) Function() l840 = m840;
+ // In checked mode, verifies the type.
+ x840 = m840;
+ x840 = confuse(m840);
+ }
+ }
+
+ void testF940() {
+ // List<Function> Function([List<Function> x]) Function()
+ Expect.isTrue(f940 is F940);
+ Expect.isTrue(confuse(f940) is F940);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x]) Function() l940;
+ // The static function f940 sets `T` to `int`.
+ if (!tIsBool) {
+ x940 = f940 as dynamic;
+ l940 = f940 as dynamic;
+ x940 = confuse(f940);
+ l940 = confuse(f940);
+ }
+
+ Expect.isTrue(m940 is F940);
+ Expect.isTrue(m940 is List<Function> Function([List<Function> x]) Function());
+ Expect.isTrue(confuse(m940) is F940);
+ // In checked mode, verifies the type.
+ x940 = m940;
+ l940 = m940;
+ x940 = confuse(m940);
+ l940 = confuse(m940);
+
+ }
+
+ void testF1040() {
+ // List<Function> Function(List<T> x0) Function()
+ Expect.isTrue(f1040 is F1040);
+ Expect.isTrue(confuse(f1040) is F1040);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x0) Function() l1040;
+ // The static function f1040 sets `T` to `int`.
+ if (!tIsBool) {
+ x1040 = f1040 as dynamic;
+ l1040 = f1040 as dynamic;
+ x1040 = confuse(f1040);
+ l1040 = confuse(f1040);
+ }
+
+ Expect.isTrue(m1040 is F1040);
+ Expect.isTrue(m1040 is List<Function> Function(List<T> x0) Function());
+ Expect.isTrue(confuse(m1040) is F1040);
+ // In checked mode, verifies the type.
+ x1040 = m1040;
+ l1040 = m1040;
+ x1040 = confuse(m1040);
+ l1040 = confuse(m1040);
+ if (!tIsBool) {
+ Expect.isTrue(f1040 is F1040<int>);
+ Expect.isFalse(f1040 is F1040<bool>);
+ Expect.isTrue(confuse(f1040) is F1040<int>);
+ Expect.isFalse(confuse(f1040) is F1040<bool>);
+ Expect.equals(tIsDynamic, m1040 is F1040<bool>);
+ Expect.equals(tIsDynamic, confuse(m1040) is F1040<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1040 = (f1040 as dynamic); });
+ Expect.throws(() { x1040 = confuse(f1040); });
+ List<Function> Function(List<T> x0) Function() l1040;
+ Expect.throws(() { l1040 = (f1040 as dynamic); });
+ Expect.throws(() { l1040 = confuse(f1040); });
+ }
+ List<Function> Function(List<T> x0) Function() l1040 = m1040;
+ // In checked mode, verifies the type.
+ x1040 = m1040;
+ x1040 = confuse(m1040);
+ }
+ }
+
+ void testF1140() {
+ // core.List<core.int> Function(int x1, [Function x2]) Function()
+ Expect.isTrue(f1140 is F1140);
+ Expect.isTrue(confuse(f1140) is F1140);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [Function x2]) Function() l1140;
+ // The static function f1140 sets `T` to `int`.
+ if (!tIsBool) {
+ x1140 = f1140 as dynamic;
+ l1140 = f1140 as dynamic;
+ x1140 = confuse(f1140);
+ l1140 = confuse(f1140);
+ }
+
+ Expect.isTrue(m1140 is F1140);
+ Expect.isTrue(m1140 is core.List<core.int> Function(int x1, [Function x2]) Function());
+ Expect.isTrue(confuse(m1140) is F1140);
+ // In checked mode, verifies the type.
+ x1140 = m1140;
+ l1140 = m1140;
+ x1140 = confuse(m1140);
+ l1140 = confuse(m1140);
+
+ }
+
+ void testF1240() {
+ // core.List<core.int> Function(int x0, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1240 is F1240);
+ Expect.isTrue(confuse(f1240) is F1240);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) Function() l1240;
+ // The static function f1240 sets `T` to `int`.
+ if (!tIsBool) {
+ x1240 = f1240 as dynamic;
+ l1240 = f1240 as dynamic;
+ x1240 = confuse(f1240);
+ l1240 = confuse(f1240);
+ }
+
+ Expect.isTrue(m1240 is F1240);
+ Expect.isTrue(m1240 is core.List<core.int> Function(int x0, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1240) is F1240);
+ // In checked mode, verifies the type.
+ x1240 = m1240;
+ l1240 = m1240;
+ x1240 = confuse(m1240);
+ l1240 = confuse(m1240);
+
+ }
+
+ void testF1340() {
+ // List<T> Function(Function x) Function()
+ Expect.isTrue(f1340 is F1340);
+ Expect.isTrue(confuse(f1340) is F1340);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x) Function() l1340;
+ // The static function f1340 sets `T` to `int`.
+ if (!tIsBool) {
+ x1340 = f1340 as dynamic;
+ l1340 = f1340 as dynamic;
+ x1340 = confuse(f1340);
+ l1340 = confuse(f1340);
+ }
+
+ Expect.isTrue(m1340 is F1340);
+ Expect.isTrue(m1340 is List<T> Function(Function x) Function());
+ Expect.isTrue(confuse(m1340) is F1340);
+ // In checked mode, verifies the type.
+ x1340 = m1340;
+ l1340 = m1340;
+ x1340 = confuse(m1340);
+ l1340 = confuse(m1340);
+ if (!tIsBool) {
+ Expect.isTrue(f1340 is F1340<int>);
+ Expect.isFalse(f1340 is F1340<bool>);
+ Expect.isTrue(confuse(f1340) is F1340<int>);
+ Expect.isFalse(confuse(f1340) is F1340<bool>);
+ Expect.equals(tIsDynamic, m1340 is F1340<bool>);
+ Expect.equals(tIsDynamic, confuse(m1340) is F1340<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1340 = (f1340 as dynamic); });
+ Expect.throws(() { x1340 = confuse(f1340); });
+ List<T> Function(Function x) Function() l1340;
+ Expect.throws(() { l1340 = (f1340 as dynamic); });
+ Expect.throws(() { l1340 = confuse(f1340); });
+ }
+ List<T> Function(Function x) Function() l1340 = m1340;
+ // In checked mode, verifies the type.
+ x1340 = m1340;
+ x1340 = confuse(m1340);
+ }
+ }
+
+ void testF1440() {
+ // List<T> Function(int y, [core.List<core.int> x]) Function()
+ Expect.isTrue(f1440 is F1440);
+ Expect.isTrue(confuse(f1440) is F1440);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [core.List<core.int> x]) Function() l1440;
+ // The static function f1440 sets `T` to `int`.
+ if (!tIsBool) {
+ x1440 = f1440 as dynamic;
+ l1440 = f1440 as dynamic;
+ x1440 = confuse(f1440);
+ l1440 = confuse(f1440);
+ }
+
+ Expect.isTrue(m1440 is F1440);
+ Expect.isTrue(m1440 is List<T> Function(int y, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1440) is F1440);
+ // In checked mode, verifies the type.
+ x1440 = m1440;
+ l1440 = m1440;
+ x1440 = confuse(m1440);
+ l1440 = confuse(m1440);
+ if (!tIsBool) {
+ Expect.isTrue(f1440 is F1440<int>);
+ Expect.isFalse(f1440 is F1440<bool>);
+ Expect.isTrue(confuse(f1440) is F1440<int>);
+ Expect.isFalse(confuse(f1440) is F1440<bool>);
+ Expect.equals(tIsDynamic, m1440 is F1440<bool>);
+ Expect.equals(tIsDynamic, confuse(m1440) is F1440<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1440 = (f1440 as dynamic); });
+ Expect.throws(() { x1440 = confuse(f1440); });
+ List<T> Function(int y, [core.List<core.int> x]) Function() l1440;
+ Expect.throws(() { l1440 = (f1440 as dynamic); });
+ Expect.throws(() { l1440 = confuse(f1440); });
+ }
+ List<T> Function(int y, [core.List<core.int> x]) Function() l1440 = m1440;
+ // In checked mode, verifies the type.
+ x1440 = m1440;
+ x1440 = confuse(m1440);
+ }
+ }
+
+ void testF1540() {
+ // Function([int x1]) Function()
+ Expect.isTrue(f1540 is F1540);
+ Expect.isTrue(confuse(f1540) is F1540);
+ // In checked mode, verifies the type.
+ Function([int x1]) Function() l1540;
+ // The static function f1540 sets `T` to `int`.
+ if (!tIsBool) {
+ x1540 = f1540 as dynamic;
+ l1540 = f1540 as dynamic;
+ x1540 = confuse(f1540);
+ l1540 = confuse(f1540);
+ }
+
+ Expect.isTrue(m1540 is F1540);
+ Expect.isTrue(m1540 is Function([int x1]) Function());
+ Expect.isTrue(confuse(m1540) is F1540);
+ // In checked mode, verifies the type.
+ x1540 = m1540;
+ l1540 = m1540;
+ x1540 = confuse(m1540);
+ l1540 = confuse(m1540);
+
+ }
+
+ void testF1640() {
+ // Function({List<Function> x}) Function()
+ Expect.isTrue(f1640 is F1640);
+ Expect.isTrue(confuse(f1640) is F1640);
+ // In checked mode, verifies the type.
+ Function({List<Function> x}) Function() l1640;
+ // The static function f1640 sets `T` to `int`.
+ if (!tIsBool) {
+ x1640 = f1640 as dynamic;
+ l1640 = f1640 as dynamic;
+ x1640 = confuse(f1640);
+ l1640 = confuse(f1640);
+ }
+
+ Expect.isTrue(m1640 is F1640);
+ Expect.isTrue(m1640 is Function({List<Function> x}) Function());
+ Expect.isTrue(confuse(m1640) is F1640);
+ // In checked mode, verifies the type.
+ x1640 = m1640;
+ l1640 = m1640;
+ x1640 = confuse(m1640);
+ l1640 = confuse(m1640);
+
+ }
+
+ void testF1740() {
+ // Function() Function()
+ Expect.isTrue(f1740 is F1740);
+ Expect.isTrue(confuse(f1740) is F1740);
+ // In checked mode, verifies the type.
+ Function() Function() l1740;
+ // The static function f1740 sets `T` to `int`.
+ if (!tIsBool) {
+ x1740 = f1740 as dynamic;
+ l1740 = f1740 as dynamic;
+ x1740 = confuse(f1740);
+ l1740 = confuse(f1740);
+ }
+
+ Expect.isTrue(m1740 is F1740);
+ Expect.isTrue(m1740 is Function() Function());
+ Expect.isTrue(confuse(m1740) is F1740);
+ // In checked mode, verifies the type.
+ x1740 = m1740;
+ l1740 = m1740;
+ x1740 = confuse(m1740);
+ l1740 = confuse(m1740);
+
+ }
+
+ void testF1840() {
+ // core.List<core.int> Function<A>(int x) Function()
+ Expect.isTrue(f1840 is F1840);
+ Expect.isTrue(confuse(f1840) is F1840);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(int x) Function() l1840;
+ // The static function f1840 sets `T` to `int`.
+ if (!tIsBool) {
+ x1840 = f1840 as dynamic;
+ l1840 = f1840 as dynamic;
+ x1840 = confuse(f1840);
+ l1840 = confuse(f1840);
+ }
+
+ Expect.isTrue(m1840 is F1840);
+ Expect.isTrue(m1840 is core.List<core.int> Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1840) is F1840);
+ // In checked mode, verifies the type.
+ x1840 = m1840;
+ l1840 = m1840;
+ x1840 = confuse(m1840);
+ l1840 = confuse(m1840);
+
+ }
+
+ void testF1940() {
+ // A Function<A>(Function x) Function()
+ Expect.isTrue(f1940 is F1940);
+ Expect.isTrue(confuse(f1940) is F1940);
+ // In checked mode, verifies the type.
+ A Function<A>(Function x) Function() l1940;
+ // The static function f1940 sets `T` to `int`.
+ if (!tIsBool) {
+ x1940 = f1940 as dynamic;
+ l1940 = f1940 as dynamic;
+ x1940 = confuse(f1940);
+ l1940 = confuse(f1940);
+ }
+
+ Expect.isTrue(m1940 is F1940);
+ Expect.isTrue(m1940 is A Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1940) is F1940);
+ // In checked mode, verifies the type.
+ x1940 = m1940;
+ l1940 = m1940;
+ x1940 = confuse(m1940);
+ l1940 = confuse(m1940);
+
+ }
+
+
+}
+
+class C41<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function({core.List<core.int> x}) x41;
+ List<Function> Function(int x, [List<Function> x2]) x141;
+ List<T> Function(int x1, [Function x2]) x241;
+ int Function<A>() x341;
+ int Function(int y, {int x}) Function(int x) x441;
+ int Function(int x1, [core.List<core.int> x]) Function(int x) x541;
+ Function Function(int x1) Function(int x) x641;
+ Function Function(int x, [List<Function> x1]) Function(int x) x741;
+ Function Function(int y, {List<T> x}) Function(int x) x841;
+ List<Function> Function([List<Function> x]) Function(int x) x941;
+ List<Function> Function(List<T> x1) Function(int x) x1041;
+ core.List<core.int> Function(int x2, [Function x3]) Function(int x) x1141;
+ core.List<core.int> Function(int x1, {core.List<core.int> x}) Function(int x) x1241;
+ List<T> Function(Function x) Function(int x) x1341;
+ List<T> Function(int y, [core.List<core.int> x]) Function(int x) x1441;
+ Function([int x1]) Function(int x) x1541;
+ Function({List<Function> x}) Function(int x) x1641;
+ Function() Function(int x) x1741;
+ core.List<core.int> Function<A>(int x) Function(int x) x1841;
+ A Function<A>(Function x) Function(int x) x1941;
+
+
+ C41({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m41({core.List<core.int> x}) => null;
+ List<Function> m141(int x, [List<Function> x0]) => null;
+ List<T> m241(int x0, [Function x1]) => null;
+ int m341<A>() => null;
+ int Function(int y, {int x}) m441(int x) => null;
+ int Function(int x0, [core.List<core.int> x]) m541(int x) => null;
+ Function Function(int x0) m641(int x) => null;
+ Function Function(int x, [List<Function> x0]) m741(int x) => null;
+ Function Function(int y, {List<T> x}) m841(int x) => null;
+ List<Function> Function([List<Function> x]) m941(int x) => null;
+ List<Function> Function(List<T> x0) m1041(int x) => null;
+ core.List<core.int> Function(int x0, [Function x1]) m1141(int x) => null;
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) m1241(int x) => null;
+ List<T> Function(Function x) m1341(int x) => null;
+ List<T> Function(int y, [core.List<core.int> x]) m1441(int x) => null;
+ Function([int x0]) m1541(int x) => null;
+ Function({List<Function> x}) m1641(int x) => null;
+ Function() m1741(int x) => null;
+ core.List<core.int> Function<A>(int x) m1841(int x) => null;
+ A Function<A>(Function x) m1941(int x) => null;
+
+
+ runTests() {
+ testF41();
+ testF141();
+ testF241();
+ testF341();
+ testF441();
+ testF541();
+ testF641();
+ testF741();
+ testF841();
+ testF941();
+ testF1041();
+ testF1141();
+ testF1241();
+ testF1341();
+ testF1441();
+ testF1541();
+ testF1641();
+ testF1741();
+ testF1841();
+ testF1941();
+ }
+
+ void testF41() {
+ // int Function({core.List<core.int> x})
+ Expect.isTrue(f41 is F41);
+ Expect.isTrue(confuse(f41) is F41);
+ // In checked mode, verifies the type.
+ int Function({core.List<core.int> x}) l41;
+ // The static function f41 sets `T` to `int`.
+ if (!tIsBool) {
+ x41 = f41 as dynamic;
+ l41 = f41 as dynamic;
+ x41 = confuse(f41);
+ l41 = confuse(f41);
+ }
+
+ Expect.isTrue(m41 is F41);
+ Expect.isTrue(m41 is int Function({core.List<core.int> x}));
+ Expect.isTrue(confuse(m41) is F41);
+ // In checked mode, verifies the type.
+ x41 = m41;
+ l41 = m41;
+ x41 = confuse(m41);
+ l41 = confuse(m41);
+
+ }
+
+ void testF141() {
+ // List<Function> Function(int x, [List<Function> x2])
+ Expect.isTrue(f141 is F141);
+ Expect.isTrue(confuse(f141) is F141);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<Function> x2]) l141;
+ // The static function f141 sets `T` to `int`.
+ if (!tIsBool) {
+ x141 = f141 as dynamic;
+ l141 = f141 as dynamic;
+ x141 = confuse(f141);
+ l141 = confuse(f141);
+ }
+
+ Expect.isTrue(m141 is F141);
+ Expect.isTrue(m141 is List<Function> Function(int x, [List<Function> x2]));
+ Expect.isTrue(confuse(m141) is F141);
+ // In checked mode, verifies the type.
+ x141 = m141;
+ l141 = m141;
+ x141 = confuse(m141);
+ l141 = confuse(m141);
+
+ }
+
+ void testF241() {
+ // List<T> Function(int x1, [Function x2])
+ Expect.isTrue(f241 is F241);
+ Expect.isTrue(confuse(f241) is F241);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [Function x2]) l241;
+ // The static function f241 sets `T` to `int`.
+ if (!tIsBool) {
+ x241 = f241 as dynamic;
+ l241 = f241 as dynamic;
+ x241 = confuse(f241);
+ l241 = confuse(f241);
+ }
+
+ Expect.isTrue(m241 is F241);
+ Expect.isTrue(m241 is List<T> Function(int x1, [Function x2]));
+ Expect.isTrue(confuse(m241) is F241);
+ // In checked mode, verifies the type.
+ x241 = m241;
+ l241 = m241;
+ x241 = confuse(m241);
+ l241 = confuse(m241);
+ if (!tIsBool) {
+ Expect.isTrue(f241 is F241<int>);
+ Expect.isFalse(f241 is F241<bool>);
+ Expect.isTrue(confuse(f241) is F241<int>);
+ Expect.isFalse(confuse(f241) is F241<bool>);
+ Expect.equals(tIsDynamic, m241 is F241<bool>);
+ Expect.equals(tIsDynamic, confuse(m241) is F241<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x241 = (f241 as dynamic); });
+ Expect.throws(() { x241 = confuse(f241); });
+ List<T> Function(int x1, [Function x2]) l241;
+ Expect.throws(() { l241 = (f241 as dynamic); });
+ Expect.throws(() { l241 = confuse(f241); });
+ }
+ List<T> Function(int x1, [Function x2]) l241 = m241;
+ // In checked mode, verifies the type.
+ x241 = m241;
+ x241 = confuse(m241);
+ }
+ }
+
+ void testF341() {
+ // int Function<A>()
+ Expect.isTrue(f341 is F341);
+ Expect.isTrue(confuse(f341) is F341);
+ // In checked mode, verifies the type.
+ int Function<A>() l341;
+ // The static function f341 sets `T` to `int`.
+ if (!tIsBool) {
+ x341 = f341 as dynamic;
+ l341 = f341 as dynamic;
+ x341 = confuse(f341);
+ l341 = confuse(f341);
+ }
+
+ Expect.isTrue(m341 is F341);
+ Expect.isTrue(m341 is int Function<A>());
+ Expect.isTrue(confuse(m341) is F341);
+ // In checked mode, verifies the type.
+ x341 = m341;
+ l341 = m341;
+ x341 = confuse(m341);
+ l341 = confuse(m341);
+
+ }
+
+ void testF441() {
+ // int Function(int y, {int x}) Function(int x)
+ Expect.isTrue(f441 is F441);
+ Expect.isTrue(confuse(f441) is F441);
+ // In checked mode, verifies the type.
+ int Function(int y, {int x}) Function(int x) l441;
+ // The static function f441 sets `T` to `int`.
+ if (!tIsBool) {
+ x441 = f441 as dynamic;
+ l441 = f441 as dynamic;
+ x441 = confuse(f441);
+ l441 = confuse(f441);
+ }
+
+ Expect.isTrue(m441 is F441);
+ Expect.isTrue(m441 is int Function(int y, {int x}) Function(int x));
+ Expect.isTrue(confuse(m441) is F441);
+ // In checked mode, verifies the type.
+ x441 = m441;
+ l441 = m441;
+ x441 = confuse(m441);
+ l441 = confuse(m441);
+
+ }
+
+ void testF541() {
+ // int Function(int x1, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f541 is F541);
+ Expect.isTrue(confuse(f541) is F541);
+ // In checked mode, verifies the type.
+ int Function(int x1, [core.List<core.int> x]) Function(int x) l541;
+ // The static function f541 sets `T` to `int`.
+ if (!tIsBool) {
+ x541 = f541 as dynamic;
+ l541 = f541 as dynamic;
+ x541 = confuse(f541);
+ l541 = confuse(f541);
+ }
+
+ Expect.isTrue(m541 is F541);
+ Expect.isTrue(m541 is int Function(int x1, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m541) is F541);
+ // In checked mode, verifies the type.
+ x541 = m541;
+ l541 = m541;
+ x541 = confuse(m541);
+ l541 = confuse(m541);
+
+ }
+
+ void testF641() {
+ // Function Function(int x1) Function(int x)
+ Expect.isTrue(f641 is F641);
+ Expect.isTrue(confuse(f641) is F641);
+ // In checked mode, verifies the type.
+ Function Function(int x1) Function(int x) l641;
+ // The static function f641 sets `T` to `int`.
+ if (!tIsBool) {
+ x641 = f641 as dynamic;
+ l641 = f641 as dynamic;
+ x641 = confuse(f641);
+ l641 = confuse(f641);
+ }
+
+ Expect.isTrue(m641 is F641);
+ Expect.isTrue(m641 is Function Function(int x1) Function(int x));
+ Expect.isTrue(confuse(m641) is F641);
+ // In checked mode, verifies the type.
+ x641 = m641;
+ l641 = m641;
+ x641 = confuse(m641);
+ l641 = confuse(m641);
+
+ }
+
+ void testF741() {
+ // Function Function(int x, [List<Function> x1]) Function(int x)
+ Expect.isTrue(f741 is F741);
+ Expect.isTrue(confuse(f741) is F741);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<Function> x1]) Function(int x) l741;
+ // The static function f741 sets `T` to `int`.
+ if (!tIsBool) {
+ x741 = f741 as dynamic;
+ l741 = f741 as dynamic;
+ x741 = confuse(f741);
+ l741 = confuse(f741);
+ }
+
+ Expect.isTrue(m741 is F741);
+ Expect.isTrue(m741 is Function Function(int x, [List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m741) is F741);
+ // In checked mode, verifies the type.
+ x741 = m741;
+ l741 = m741;
+ x741 = confuse(m741);
+ l741 = confuse(m741);
+
+ }
+
+ void testF841() {
+ // Function Function(int y, {List<T> x}) Function(int x)
+ Expect.isTrue(f841 is F841);
+ Expect.isTrue(confuse(f841) is F841);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<T> x}) Function(int x) l841;
+ // The static function f841 sets `T` to `int`.
+ if (!tIsBool) {
+ x841 = f841 as dynamic;
+ l841 = f841 as dynamic;
+ x841 = confuse(f841);
+ l841 = confuse(f841);
+ }
+
+ Expect.isTrue(m841 is F841);
+ Expect.isTrue(m841 is Function Function(int y, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m841) is F841);
+ // In checked mode, verifies the type.
+ x841 = m841;
+ l841 = m841;
+ x841 = confuse(m841);
+ l841 = confuse(m841);
+ if (!tIsBool) {
+ Expect.isTrue(f841 is F841<int>);
+ Expect.isFalse(f841 is F841<bool>);
+ Expect.isTrue(confuse(f841) is F841<int>);
+ Expect.isFalse(confuse(f841) is F841<bool>);
+ Expect.equals(tIsDynamic, m841 is F841<bool>);
+ Expect.equals(tIsDynamic, confuse(m841) is F841<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x841 = (f841 as dynamic); });
+ Expect.throws(() { x841 = confuse(f841); });
+ Function Function(int y, {List<T> x}) Function(int x) l841;
+ Expect.throws(() { l841 = (f841 as dynamic); });
+ Expect.throws(() { l841 = confuse(f841); });
+ }
+ Function Function(int y, {List<T> x}) Function(int x) l841 = m841;
+ // In checked mode, verifies the type.
+ x841 = m841;
+ x841 = confuse(m841);
+ }
+ }
+
+ void testF941() {
+ // List<Function> Function([List<Function> x]) Function(int x)
+ Expect.isTrue(f941 is F941);
+ Expect.isTrue(confuse(f941) is F941);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x]) Function(int x) l941;
+ // The static function f941 sets `T` to `int`.
+ if (!tIsBool) {
+ x941 = f941 as dynamic;
+ l941 = f941 as dynamic;
+ x941 = confuse(f941);
+ l941 = confuse(f941);
+ }
+
+ Expect.isTrue(m941 is F941);
+ Expect.isTrue(m941 is List<Function> Function([List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m941) is F941);
+ // In checked mode, verifies the type.
+ x941 = m941;
+ l941 = m941;
+ x941 = confuse(m941);
+ l941 = confuse(m941);
+
+ }
+
+ void testF1041() {
+ // List<Function> Function(List<T> x1) Function(int x)
+ Expect.isTrue(f1041 is F1041);
+ Expect.isTrue(confuse(f1041) is F1041);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x1) Function(int x) l1041;
+ // The static function f1041 sets `T` to `int`.
+ if (!tIsBool) {
+ x1041 = f1041 as dynamic;
+ l1041 = f1041 as dynamic;
+ x1041 = confuse(f1041);
+ l1041 = confuse(f1041);
+ }
+
+ Expect.isTrue(m1041 is F1041);
+ Expect.isTrue(m1041 is List<Function> Function(List<T> x1) Function(int x));
+ Expect.isTrue(confuse(m1041) is F1041);
+ // In checked mode, verifies the type.
+ x1041 = m1041;
+ l1041 = m1041;
+ x1041 = confuse(m1041);
+ l1041 = confuse(m1041);
+ if (!tIsBool) {
+ Expect.isTrue(f1041 is F1041<int>);
+ Expect.isFalse(f1041 is F1041<bool>);
+ Expect.isTrue(confuse(f1041) is F1041<int>);
+ Expect.isFalse(confuse(f1041) is F1041<bool>);
+ Expect.equals(tIsDynamic, m1041 is F1041<bool>);
+ Expect.equals(tIsDynamic, confuse(m1041) is F1041<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1041 = (f1041 as dynamic); });
+ Expect.throws(() { x1041 = confuse(f1041); });
+ List<Function> Function(List<T> x1) Function(int x) l1041;
+ Expect.throws(() { l1041 = (f1041 as dynamic); });
+ Expect.throws(() { l1041 = confuse(f1041); });
+ }
+ List<Function> Function(List<T> x1) Function(int x) l1041 = m1041;
+ // In checked mode, verifies the type.
+ x1041 = m1041;
+ x1041 = confuse(m1041);
+ }
+ }
+
+ void testF1141() {
+ // core.List<core.int> Function(int x2, [Function x3]) Function(int x)
+ Expect.isTrue(f1141 is F1141);
+ Expect.isTrue(confuse(f1141) is F1141);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [Function x3]) Function(int x) l1141;
+ // The static function f1141 sets `T` to `int`.
+ if (!tIsBool) {
+ x1141 = f1141 as dynamic;
+ l1141 = f1141 as dynamic;
+ x1141 = confuse(f1141);
+ l1141 = confuse(f1141);
+ }
+
+ Expect.isTrue(m1141 is F1141);
+ Expect.isTrue(m1141 is core.List<core.int> Function(int x2, [Function x3]) Function(int x));
+ Expect.isTrue(confuse(m1141) is F1141);
+ // In checked mode, verifies the type.
+ x1141 = m1141;
+ l1141 = m1141;
+ x1141 = confuse(m1141);
+ l1141 = confuse(m1141);
+
+ }
+
+ void testF1241() {
+ // core.List<core.int> Function(int x1, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1241 is F1241);
+ Expect.isTrue(confuse(f1241) is F1241);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {core.List<core.int> x}) Function(int x) l1241;
+ // The static function f1241 sets `T` to `int`.
+ if (!tIsBool) {
+ x1241 = f1241 as dynamic;
+ l1241 = f1241 as dynamic;
+ x1241 = confuse(f1241);
+ l1241 = confuse(f1241);
+ }
+
+ Expect.isTrue(m1241 is F1241);
+ Expect.isTrue(m1241 is core.List<core.int> Function(int x1, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1241) is F1241);
+ // In checked mode, verifies the type.
+ x1241 = m1241;
+ l1241 = m1241;
+ x1241 = confuse(m1241);
+ l1241 = confuse(m1241);
+
+ }
+
+ void testF1341() {
+ // List<T> Function(Function x) Function(int x)
+ Expect.isTrue(f1341 is F1341);
+ Expect.isTrue(confuse(f1341) is F1341);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x) Function(int x) l1341;
+ // The static function f1341 sets `T` to `int`.
+ if (!tIsBool) {
+ x1341 = f1341 as dynamic;
+ l1341 = f1341 as dynamic;
+ x1341 = confuse(f1341);
+ l1341 = confuse(f1341);
+ }
+
+ Expect.isTrue(m1341 is F1341);
+ Expect.isTrue(m1341 is List<T> Function(Function x) Function(int x));
+ Expect.isTrue(confuse(m1341) is F1341);
+ // In checked mode, verifies the type.
+ x1341 = m1341;
+ l1341 = m1341;
+ x1341 = confuse(m1341);
+ l1341 = confuse(m1341);
+ if (!tIsBool) {
+ Expect.isTrue(f1341 is F1341<int>);
+ Expect.isFalse(f1341 is F1341<bool>);
+ Expect.isTrue(confuse(f1341) is F1341<int>);
+ Expect.isFalse(confuse(f1341) is F1341<bool>);
+ Expect.equals(tIsDynamic, m1341 is F1341<bool>);
+ Expect.equals(tIsDynamic, confuse(m1341) is F1341<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1341 = (f1341 as dynamic); });
+ Expect.throws(() { x1341 = confuse(f1341); });
+ List<T> Function(Function x) Function(int x) l1341;
+ Expect.throws(() { l1341 = (f1341 as dynamic); });
+ Expect.throws(() { l1341 = confuse(f1341); });
+ }
+ List<T> Function(Function x) Function(int x) l1341 = m1341;
+ // In checked mode, verifies the type.
+ x1341 = m1341;
+ x1341 = confuse(m1341);
+ }
+ }
+
+ void testF1441() {
+ // List<T> Function(int y, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1441 is F1441);
+ Expect.isTrue(confuse(f1441) is F1441);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [core.List<core.int> x]) Function(int x) l1441;
+ // The static function f1441 sets `T` to `int`.
+ if (!tIsBool) {
+ x1441 = f1441 as dynamic;
+ l1441 = f1441 as dynamic;
+ x1441 = confuse(f1441);
+ l1441 = confuse(f1441);
+ }
+
+ Expect.isTrue(m1441 is F1441);
+ Expect.isTrue(m1441 is List<T> Function(int y, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1441) is F1441);
+ // In checked mode, verifies the type.
+ x1441 = m1441;
+ l1441 = m1441;
+ x1441 = confuse(m1441);
+ l1441 = confuse(m1441);
+ if (!tIsBool) {
+ Expect.isTrue(f1441 is F1441<int>);
+ Expect.isFalse(f1441 is F1441<bool>);
+ Expect.isTrue(confuse(f1441) is F1441<int>);
+ Expect.isFalse(confuse(f1441) is F1441<bool>);
+ Expect.equals(tIsDynamic, m1441 is F1441<bool>);
+ Expect.equals(tIsDynamic, confuse(m1441) is F1441<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1441 = (f1441 as dynamic); });
+ Expect.throws(() { x1441 = confuse(f1441); });
+ List<T> Function(int y, [core.List<core.int> x]) Function(int x) l1441;
+ Expect.throws(() { l1441 = (f1441 as dynamic); });
+ Expect.throws(() { l1441 = confuse(f1441); });
+ }
+ List<T> Function(int y, [core.List<core.int> x]) Function(int x) l1441 = m1441;
+ // In checked mode, verifies the type.
+ x1441 = m1441;
+ x1441 = confuse(m1441);
+ }
+ }
+
+ void testF1541() {
+ // Function([int x1]) Function(int x)
+ Expect.isTrue(f1541 is F1541);
+ Expect.isTrue(confuse(f1541) is F1541);
+ // In checked mode, verifies the type.
+ Function([int x1]) Function(int x) l1541;
+ // The static function f1541 sets `T` to `int`.
+ if (!tIsBool) {
+ x1541 = f1541 as dynamic;
+ l1541 = f1541 as dynamic;
+ x1541 = confuse(f1541);
+ l1541 = confuse(f1541);
+ }
+
+ Expect.isTrue(m1541 is F1541);
+ Expect.isTrue(m1541 is Function([int x1]) Function(int x));
+ Expect.isTrue(confuse(m1541) is F1541);
+ // In checked mode, verifies the type.
+ x1541 = m1541;
+ l1541 = m1541;
+ x1541 = confuse(m1541);
+ l1541 = confuse(m1541);
+
+ }
+
+ void testF1641() {
+ // Function({List<Function> x}) Function(int x)
+ Expect.isTrue(f1641 is F1641);
+ Expect.isTrue(confuse(f1641) is F1641);
+ // In checked mode, verifies the type.
+ Function({List<Function> x}) Function(int x) l1641;
+ // The static function f1641 sets `T` to `int`.
+ if (!tIsBool) {
+ x1641 = f1641 as dynamic;
+ l1641 = f1641 as dynamic;
+ x1641 = confuse(f1641);
+ l1641 = confuse(f1641);
+ }
+
+ Expect.isTrue(m1641 is F1641);
+ Expect.isTrue(m1641 is Function({List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1641) is F1641);
+ // In checked mode, verifies the type.
+ x1641 = m1641;
+ l1641 = m1641;
+ x1641 = confuse(m1641);
+ l1641 = confuse(m1641);
+
+ }
+
+ void testF1741() {
+ // Function() Function(int x)
+ Expect.isTrue(f1741 is F1741);
+ Expect.isTrue(confuse(f1741) is F1741);
+ // In checked mode, verifies the type.
+ Function() Function(int x) l1741;
+ // The static function f1741 sets `T` to `int`.
+ if (!tIsBool) {
+ x1741 = f1741 as dynamic;
+ l1741 = f1741 as dynamic;
+ x1741 = confuse(f1741);
+ l1741 = confuse(f1741);
+ }
+
+ Expect.isTrue(m1741 is F1741);
+ Expect.isTrue(m1741 is Function() Function(int x));
+ Expect.isTrue(confuse(m1741) is F1741);
+ // In checked mode, verifies the type.
+ x1741 = m1741;
+ l1741 = m1741;
+ x1741 = confuse(m1741);
+ l1741 = confuse(m1741);
+
+ }
+
+ void testF1841() {
+ // core.List<core.int> Function<A>(int x) Function(int x)
+ Expect.isTrue(f1841 is F1841);
+ Expect.isTrue(confuse(f1841) is F1841);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(int x) Function(int x) l1841;
+ // The static function f1841 sets `T` to `int`.
+ if (!tIsBool) {
+ x1841 = f1841 as dynamic;
+ l1841 = f1841 as dynamic;
+ x1841 = confuse(f1841);
+ l1841 = confuse(f1841);
+ }
+
+ Expect.isTrue(m1841 is F1841);
+ Expect.isTrue(m1841 is core.List<core.int> Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1841) is F1841);
+ // In checked mode, verifies the type.
+ x1841 = m1841;
+ l1841 = m1841;
+ x1841 = confuse(m1841);
+ l1841 = confuse(m1841);
+
+ }
+
+ void testF1941() {
+ // A Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1941 is F1941);
+ Expect.isTrue(confuse(f1941) is F1941);
+ // In checked mode, verifies the type.
+ A Function<A>(Function x) Function(int x) l1941;
+ // The static function f1941 sets `T` to `int`.
+ if (!tIsBool) {
+ x1941 = f1941 as dynamic;
+ l1941 = f1941 as dynamic;
+ x1941 = confuse(f1941);
+ l1941 = confuse(f1941);
+ }
+
+ Expect.isTrue(m1941 is F1941);
+ Expect.isTrue(m1941 is A Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1941) is F1941);
+ // In checked mode, verifies the type.
+ x1941 = m1941;
+ l1941 = m1941;
+ x1941 = confuse(m1941);
+ l1941 = confuse(m1941);
+
+ }
+
+
+}
+
+class C42<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, {core.List<core.int> x}) x42;
+ List<Function> Function({List<Function> x}) x142;
+ List<T> Function(int x, [Function x2]) x242;
+ int Function<A>(A x) x342;
+ int Function(int y, {int x}) Function<B extends core.int>() x442;
+ int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() x542;
+ Function Function(int x1) Function<B extends core.int>() x642;
+ Function Function(int x, [List<Function> x1]) Function<B extends core.int>() x742;
+ Function Function(int y, {List<T> x}) Function<B extends core.int>() x842;
+ List<Function> Function([List<Function> x]) Function<B extends core.int>() x942;
+ List<Function> Function(List<T> x1) Function<B extends core.int>() x1042;
+ core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>() x1142;
+ core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() x1242;
+ List<T> Function(Function x) Function<B extends core.int>() x1342;
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() x1442;
+ Function([int x1]) Function<B extends core.int>() x1542;
+ Function({List<Function> x}) Function<B extends core.int>() x1642;
+ Function() Function<B extends core.int>() x1742;
+ core.List<core.int> Function<A>(int x) Function<B extends core.int>() x1842;
+ A Function<A>(Function x) Function<B extends core.int>() x1942;
+
+
+ C42({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m42(int x0, {core.List<core.int> x}) => null;
+ List<Function> m142({List<Function> x}) => null;
+ List<T> m242(int x, [Function x0]) => null;
+ int m342<A>(A x) => null;
+ int Function(int y, {int x}) m442<B extends core.int>() => null;
+ int Function(int x0, [core.List<core.int> x]) m542<B extends core.int>() => null;
+ Function Function(int x0) m642<B extends core.int>() => null;
+ Function Function(int x, [List<Function> x0]) m742<B extends core.int>() => null;
+ Function Function(int y, {List<T> x}) m842<B extends core.int>() => null;
+ List<Function> Function([List<Function> x]) m942<B extends core.int>() => null;
+ List<Function> Function(List<T> x0) m1042<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [Function x1]) m1142<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) m1242<B extends core.int>() => null;
+ List<T> Function(Function x) m1342<B extends core.int>() => null;
+ List<T> Function(int y, [core.List<core.int> x]) m1442<B extends core.int>() => null;
+ Function([int x0]) m1542<B extends core.int>() => null;
+ Function({List<Function> x}) m1642<B extends core.int>() => null;
+ Function() m1742<B extends core.int>() => null;
+ core.List<core.int> Function<A>(int x) m1842<B extends core.int>() => null;
+ A Function<A>(Function x) m1942<B extends core.int>() => null;
+
+
+ runTests() {
+ testF42();
+ testF142();
+ testF242();
+ testF342();
+ testF442();
+ testF542();
+ testF642();
+ testF742();
+ testF842();
+ testF942();
+ testF1042();
+ testF1142();
+ testF1242();
+ testF1342();
+ testF1442();
+ testF1542();
+ testF1642();
+ testF1742();
+ testF1842();
+ testF1942();
+ }
+
+ void testF42() {
+ // int Function(int x0, {core.List<core.int> x})
+ Expect.isTrue(f42 is F42);
+ Expect.isTrue(confuse(f42) is F42);
+ // In checked mode, verifies the type.
+ int Function(int x0, {core.List<core.int> x}) l42;
+ // The static function f42 sets `T` to `int`.
+ if (!tIsBool) {
+ x42 = f42 as dynamic;
+ l42 = f42 as dynamic;
+ x42 = confuse(f42);
+ l42 = confuse(f42);
+ }
+
+ Expect.isTrue(m42 is F42);
+ Expect.isTrue(m42 is int Function(int x0, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m42) is F42);
+ // In checked mode, verifies the type.
+ x42 = m42;
+ l42 = m42;
+ x42 = confuse(m42);
+ l42 = confuse(m42);
+
+ }
+
+ void testF142() {
+ // List<Function> Function({List<Function> x})
+ Expect.isTrue(f142 is F142);
+ Expect.isTrue(confuse(f142) is F142);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<Function> x}) l142;
+ // The static function f142 sets `T` to `int`.
+ if (!tIsBool) {
+ x142 = f142 as dynamic;
+ l142 = f142 as dynamic;
+ x142 = confuse(f142);
+ l142 = confuse(f142);
+ }
+
+ Expect.isTrue(m142 is F142);
+ Expect.isTrue(m142 is List<Function> Function({List<Function> x}));
+ Expect.isTrue(confuse(m142) is F142);
+ // In checked mode, verifies the type.
+ x142 = m142;
+ l142 = m142;
+ x142 = confuse(m142);
+ l142 = confuse(m142);
+
+ }
+
+ void testF242() {
+ // List<T> Function(int x, [Function x2])
+ Expect.isTrue(f242 is F242);
+ Expect.isTrue(confuse(f242) is F242);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [Function x2]) l242;
+ // The static function f242 sets `T` to `int`.
+ if (!tIsBool) {
+ x242 = f242 as dynamic;
+ l242 = f242 as dynamic;
+ x242 = confuse(f242);
+ l242 = confuse(f242);
+ }
+
+ Expect.isTrue(m242 is F242);
+ Expect.isTrue(m242 is List<T> Function(int x, [Function x2]));
+ Expect.isTrue(confuse(m242) is F242);
+ // In checked mode, verifies the type.
+ x242 = m242;
+ l242 = m242;
+ x242 = confuse(m242);
+ l242 = confuse(m242);
+ if (!tIsBool) {
+ Expect.isTrue(f242 is F242<int>);
+ Expect.isFalse(f242 is F242<bool>);
+ Expect.isTrue(confuse(f242) is F242<int>);
+ Expect.isFalse(confuse(f242) is F242<bool>);
+ Expect.equals(tIsDynamic, m242 is F242<bool>);
+ Expect.equals(tIsDynamic, confuse(m242) is F242<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x242 = (f242 as dynamic); });
+ Expect.throws(() { x242 = confuse(f242); });
+ List<T> Function(int x, [Function x2]) l242;
+ Expect.throws(() { l242 = (f242 as dynamic); });
+ Expect.throws(() { l242 = confuse(f242); });
+ }
+ List<T> Function(int x, [Function x2]) l242 = m242;
+ // In checked mode, verifies the type.
+ x242 = m242;
+ x242 = confuse(m242);
+ }
+ }
+
+ void testF342() {
+ // int Function<A>(A x)
+ Expect.isTrue(f342 is F342);
+ Expect.isTrue(confuse(f342) is F342);
+ // In checked mode, verifies the type.
+ int Function<A>(A x) l342;
+ // The static function f342 sets `T` to `int`.
+ if (!tIsBool) {
+ x342 = f342 as dynamic;
+ l342 = f342 as dynamic;
+ x342 = confuse(f342);
+ l342 = confuse(f342);
+ }
+
+ Expect.isTrue(m342 is F342);
+ Expect.isTrue(m342 is int Function<A>(A x));
+ Expect.isTrue(confuse(m342) is F342);
+ // In checked mode, verifies the type.
+ x342 = m342;
+ l342 = m342;
+ x342 = confuse(m342);
+ l342 = confuse(m342);
+
+ }
+
+ void testF442() {
+ // int Function(int y, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f442 is F442);
+ Expect.isTrue(confuse(f442) is F442);
+ // In checked mode, verifies the type.
+ int Function(int y, {int x}) Function<B extends core.int>() l442;
+ // The static function f442 sets `T` to `int`.
+ if (!tIsBool) {
+ x442 = f442 as dynamic;
+ l442 = f442 as dynamic;
+ x442 = confuse(f442);
+ l442 = confuse(f442);
+ }
+
+ Expect.isTrue(m442 is F442);
+ Expect.isTrue(m442 is int Function(int y, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m442) is F442);
+ // In checked mode, verifies the type.
+ x442 = m442;
+ l442 = m442;
+ x442 = confuse(m442);
+ l442 = confuse(m442);
+
+ }
+
+ void testF542() {
+ // int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f542 is F542);
+ Expect.isTrue(confuse(f542) is F542);
+ // In checked mode, verifies the type.
+ int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l542;
+ // The static function f542 sets `T` to `int`.
+ if (!tIsBool) {
+ x542 = f542 as dynamic;
+ l542 = f542 as dynamic;
+ x542 = confuse(f542);
+ l542 = confuse(f542);
+ }
+
+ Expect.isTrue(m542 is F542);
+ Expect.isTrue(m542 is int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m542) is F542);
+ // In checked mode, verifies the type.
+ x542 = m542;
+ l542 = m542;
+ x542 = confuse(m542);
+ l542 = confuse(m542);
+
+ }
+
+ void testF642() {
+ // Function Function(int x1) Function<B extends core.int>()
+ Expect.isTrue(f642 is F642);
+ Expect.isTrue(confuse(f642) is F642);
+ // In checked mode, verifies the type.
+ Function Function(int x1) Function<B extends core.int>() l642;
+ // The static function f642 sets `T` to `int`.
+ if (!tIsBool) {
+ x642 = f642 as dynamic;
+ l642 = f642 as dynamic;
+ x642 = confuse(f642);
+ l642 = confuse(f642);
+ }
+
+ Expect.isTrue(m642 is F642);
+ Expect.isTrue(m642 is Function Function(int x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m642) is F642);
+ // In checked mode, verifies the type.
+ x642 = m642;
+ l642 = m642;
+ x642 = confuse(m642);
+ l642 = confuse(m642);
+
+ }
+
+ void testF742() {
+ // Function Function(int x, [List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f742 is F742);
+ Expect.isTrue(confuse(f742) is F742);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<Function> x1]) Function<B extends core.int>() l742;
+ // The static function f742 sets `T` to `int`.
+ if (!tIsBool) {
+ x742 = f742 as dynamic;
+ l742 = f742 as dynamic;
+ x742 = confuse(f742);
+ l742 = confuse(f742);
+ }
+
+ Expect.isTrue(m742 is F742);
+ Expect.isTrue(m742 is Function Function(int x, [List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m742) is F742);
+ // In checked mode, verifies the type.
+ x742 = m742;
+ l742 = m742;
+ x742 = confuse(m742);
+ l742 = confuse(m742);
+
+ }
+
+ void testF842() {
+ // Function Function(int y, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f842 is F842);
+ Expect.isTrue(confuse(f842) is F842);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<T> x}) Function<B extends core.int>() l842;
+ // The static function f842 sets `T` to `int`.
+ if (!tIsBool) {
+ x842 = f842 as dynamic;
+ l842 = f842 as dynamic;
+ x842 = confuse(f842);
+ l842 = confuse(f842);
+ }
+
+ Expect.isTrue(m842 is F842);
+ Expect.isTrue(m842 is Function Function(int y, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m842) is F842);
+ // In checked mode, verifies the type.
+ x842 = m842;
+ l842 = m842;
+ x842 = confuse(m842);
+ l842 = confuse(m842);
+ if (!tIsBool) {
+ Expect.isTrue(f842 is F842<int>);
+ Expect.isFalse(f842 is F842<bool>);
+ Expect.isTrue(confuse(f842) is F842<int>);
+ Expect.isFalse(confuse(f842) is F842<bool>);
+ Expect.equals(tIsDynamic, m842 is F842<bool>);
+ Expect.equals(tIsDynamic, confuse(m842) is F842<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x842 = (f842 as dynamic); });
+ Expect.throws(() { x842 = confuse(f842); });
+ Function Function(int y, {List<T> x}) Function<B extends core.int>() l842;
+ Expect.throws(() { l842 = (f842 as dynamic); });
+ Expect.throws(() { l842 = confuse(f842); });
+ }
+ Function Function(int y, {List<T> x}) Function<B extends core.int>() l842 = m842;
+ // In checked mode, verifies the type.
+ x842 = m842;
+ x842 = confuse(m842);
+ }
+ }
+
+ void testF942() {
+ // List<Function> Function([List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f942 is F942);
+ Expect.isTrue(confuse(f942) is F942);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x]) Function<B extends core.int>() l942;
+ // The static function f942 sets `T` to `int`.
+ if (!tIsBool) {
+ x942 = f942 as dynamic;
+ l942 = f942 as dynamic;
+ x942 = confuse(f942);
+ l942 = confuse(f942);
+ }
+
+ Expect.isTrue(m942 is F942);
+ Expect.isTrue(m942 is List<Function> Function([List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m942) is F942);
+ // In checked mode, verifies the type.
+ x942 = m942;
+ l942 = m942;
+ x942 = confuse(m942);
+ l942 = confuse(m942);
+
+ }
+
+ void testF1042() {
+ // List<Function> Function(List<T> x1) Function<B extends core.int>()
+ Expect.isTrue(f1042 is F1042);
+ Expect.isTrue(confuse(f1042) is F1042);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x1) Function<B extends core.int>() l1042;
+ // The static function f1042 sets `T` to `int`.
+ if (!tIsBool) {
+ x1042 = f1042 as dynamic;
+ l1042 = f1042 as dynamic;
+ x1042 = confuse(f1042);
+ l1042 = confuse(f1042);
+ }
+
+ Expect.isTrue(m1042 is F1042);
+ Expect.isTrue(m1042 is List<Function> Function(List<T> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1042) is F1042);
+ // In checked mode, verifies the type.
+ x1042 = m1042;
+ l1042 = m1042;
+ x1042 = confuse(m1042);
+ l1042 = confuse(m1042);
+ if (!tIsBool) {
+ Expect.isTrue(f1042 is F1042<int>);
+ Expect.isFalse(f1042 is F1042<bool>);
+ Expect.isTrue(confuse(f1042) is F1042<int>);
+ Expect.isFalse(confuse(f1042) is F1042<bool>);
+ Expect.equals(tIsDynamic, m1042 is F1042<bool>);
+ Expect.equals(tIsDynamic, confuse(m1042) is F1042<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1042 = (f1042 as dynamic); });
+ Expect.throws(() { x1042 = confuse(f1042); });
+ List<Function> Function(List<T> x1) Function<B extends core.int>() l1042;
+ Expect.throws(() { l1042 = (f1042 as dynamic); });
+ Expect.throws(() { l1042 = confuse(f1042); });
+ }
+ List<Function> Function(List<T> x1) Function<B extends core.int>() l1042 = m1042;
+ // In checked mode, verifies the type.
+ x1042 = m1042;
+ x1042 = confuse(m1042);
+ }
+ }
+
+ void testF1142() {
+ // core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>()
+ Expect.isTrue(f1142 is F1142);
+ Expect.isTrue(confuse(f1142) is F1142);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>() l1142;
+ // The static function f1142 sets `T` to `int`.
+ if (!tIsBool) {
+ x1142 = f1142 as dynamic;
+ l1142 = f1142 as dynamic;
+ x1142 = confuse(f1142);
+ l1142 = confuse(f1142);
+ }
+
+ Expect.isTrue(m1142 is F1142);
+ Expect.isTrue(m1142 is core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1142) is F1142);
+ // In checked mode, verifies the type.
+ x1142 = m1142;
+ l1142 = m1142;
+ x1142 = confuse(m1142);
+ l1142 = confuse(m1142);
+
+ }
+
+ void testF1242() {
+ // core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1242 is F1242);
+ Expect.isTrue(confuse(f1242) is F1242);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l1242;
+ // The static function f1242 sets `T` to `int`.
+ if (!tIsBool) {
+ x1242 = f1242 as dynamic;
+ l1242 = f1242 as dynamic;
+ x1242 = confuse(f1242);
+ l1242 = confuse(f1242);
+ }
+
+ Expect.isTrue(m1242 is F1242);
+ Expect.isTrue(m1242 is core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1242) is F1242);
+ // In checked mode, verifies the type.
+ x1242 = m1242;
+ l1242 = m1242;
+ x1242 = confuse(m1242);
+ l1242 = confuse(m1242);
+
+ }
+
+ void testF1342() {
+ // List<T> Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1342 is F1342);
+ Expect.isTrue(confuse(f1342) is F1342);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x) Function<B extends core.int>() l1342;
+ // The static function f1342 sets `T` to `int`.
+ if (!tIsBool) {
+ x1342 = f1342 as dynamic;
+ l1342 = f1342 as dynamic;
+ x1342 = confuse(f1342);
+ l1342 = confuse(f1342);
+ }
+
+ Expect.isTrue(m1342 is F1342);
+ Expect.isTrue(m1342 is List<T> Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1342) is F1342);
+ // In checked mode, verifies the type.
+ x1342 = m1342;
+ l1342 = m1342;
+ x1342 = confuse(m1342);
+ l1342 = confuse(m1342);
+ if (!tIsBool) {
+ Expect.isTrue(f1342 is F1342<int>);
+ Expect.isFalse(f1342 is F1342<bool>);
+ Expect.isTrue(confuse(f1342) is F1342<int>);
+ Expect.isFalse(confuse(f1342) is F1342<bool>);
+ Expect.equals(tIsDynamic, m1342 is F1342<bool>);
+ Expect.equals(tIsDynamic, confuse(m1342) is F1342<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1342 = (f1342 as dynamic); });
+ Expect.throws(() { x1342 = confuse(f1342); });
+ List<T> Function(Function x) Function<B extends core.int>() l1342;
+ Expect.throws(() { l1342 = (f1342 as dynamic); });
+ Expect.throws(() { l1342 = confuse(f1342); });
+ }
+ List<T> Function(Function x) Function<B extends core.int>() l1342 = m1342;
+ // In checked mode, verifies the type.
+ x1342 = m1342;
+ x1342 = confuse(m1342);
+ }
+ }
+
+ void testF1442() {
+ // List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1442 is F1442);
+ Expect.isTrue(confuse(f1442) is F1442);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l1442;
+ // The static function f1442 sets `T` to `int`.
+ if (!tIsBool) {
+ x1442 = f1442 as dynamic;
+ l1442 = f1442 as dynamic;
+ x1442 = confuse(f1442);
+ l1442 = confuse(f1442);
+ }
+
+ Expect.isTrue(m1442 is F1442);
+ Expect.isTrue(m1442 is List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1442) is F1442);
+ // In checked mode, verifies the type.
+ x1442 = m1442;
+ l1442 = m1442;
+ x1442 = confuse(m1442);
+ l1442 = confuse(m1442);
+ if (!tIsBool) {
+ Expect.isTrue(f1442 is F1442<int>);
+ Expect.isFalse(f1442 is F1442<bool>);
+ Expect.isTrue(confuse(f1442) is F1442<int>);
+ Expect.isFalse(confuse(f1442) is F1442<bool>);
+ Expect.equals(tIsDynamic, m1442 is F1442<bool>);
+ Expect.equals(tIsDynamic, confuse(m1442) is F1442<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1442 = (f1442 as dynamic); });
+ Expect.throws(() { x1442 = confuse(f1442); });
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l1442;
+ Expect.throws(() { l1442 = (f1442 as dynamic); });
+ Expect.throws(() { l1442 = confuse(f1442); });
+ }
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l1442 = m1442;
+ // In checked mode, verifies the type.
+ x1442 = m1442;
+ x1442 = confuse(m1442);
+ }
+ }
+
+ void testF1542() {
+ // Function([int x1]) Function<B extends core.int>()
+ Expect.isTrue(f1542 is F1542);
+ Expect.isTrue(confuse(f1542) is F1542);
+ // In checked mode, verifies the type.
+ Function([int x1]) Function<B extends core.int>() l1542;
+ // The static function f1542 sets `T` to `int`.
+ if (!tIsBool) {
+ x1542 = f1542 as dynamic;
+ l1542 = f1542 as dynamic;
+ x1542 = confuse(f1542);
+ l1542 = confuse(f1542);
+ }
+
+ Expect.isTrue(m1542 is F1542);
+ Expect.isTrue(m1542 is Function([int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1542) is F1542);
+ // In checked mode, verifies the type.
+ x1542 = m1542;
+ l1542 = m1542;
+ x1542 = confuse(m1542);
+ l1542 = confuse(m1542);
+
+ }
+
+ void testF1642() {
+ // Function({List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1642 is F1642);
+ Expect.isTrue(confuse(f1642) is F1642);
+ // In checked mode, verifies the type.
+ Function({List<Function> x}) Function<B extends core.int>() l1642;
+ // The static function f1642 sets `T` to `int`.
+ if (!tIsBool) {
+ x1642 = f1642 as dynamic;
+ l1642 = f1642 as dynamic;
+ x1642 = confuse(f1642);
+ l1642 = confuse(f1642);
+ }
+
+ Expect.isTrue(m1642 is F1642);
+ Expect.isTrue(m1642 is Function({List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1642) is F1642);
+ // In checked mode, verifies the type.
+ x1642 = m1642;
+ l1642 = m1642;
+ x1642 = confuse(m1642);
+ l1642 = confuse(m1642);
+
+ }
+
+ void testF1742() {
+ // Function() Function<B extends core.int>()
+ Expect.isTrue(f1742 is F1742);
+ Expect.isTrue(confuse(f1742) is F1742);
+ // In checked mode, verifies the type.
+ Function() Function<B extends core.int>() l1742;
+ // The static function f1742 sets `T` to `int`.
+ if (!tIsBool) {
+ x1742 = f1742 as dynamic;
+ l1742 = f1742 as dynamic;
+ x1742 = confuse(f1742);
+ l1742 = confuse(f1742);
+ }
+
+ Expect.isTrue(m1742 is F1742);
+ Expect.isTrue(m1742 is Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1742) is F1742);
+ // In checked mode, verifies the type.
+ x1742 = m1742;
+ l1742 = m1742;
+ x1742 = confuse(m1742);
+ l1742 = confuse(m1742);
+
+ }
+
+ void testF1842() {
+ // core.List<core.int> Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1842 is F1842);
+ Expect.isTrue(confuse(f1842) is F1842);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(int x) Function<B extends core.int>() l1842;
+ // The static function f1842 sets `T` to `int`.
+ if (!tIsBool) {
+ x1842 = f1842 as dynamic;
+ l1842 = f1842 as dynamic;
+ x1842 = confuse(f1842);
+ l1842 = confuse(f1842);
+ }
+
+ Expect.isTrue(m1842 is F1842);
+ Expect.isTrue(m1842 is core.List<core.int> Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1842) is F1842);
+ // In checked mode, verifies the type.
+ x1842 = m1842;
+ l1842 = m1842;
+ x1842 = confuse(m1842);
+ l1842 = confuse(m1842);
+
+ }
+
+ void testF1942() {
+ // A Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1942 is F1942);
+ Expect.isTrue(confuse(f1942) is F1942);
+ // In checked mode, verifies the type.
+ A Function<A>(Function x) Function<B extends core.int>() l1942;
+ // The static function f1942 sets `T` to `int`.
+ if (!tIsBool) {
+ x1942 = f1942 as dynamic;
+ l1942 = f1942 as dynamic;
+ x1942 = confuse(f1942);
+ l1942 = confuse(f1942);
+ }
+
+ Expect.isTrue(m1942 is F1942);
+ Expect.isTrue(m1942 is A Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1942) is F1942);
+ // In checked mode, verifies the type.
+ x1942 = m1942;
+ l1942 = m1942;
+ x1942 = confuse(m1942);
+ l1942 = confuse(m1942);
+
+ }
+
+
+}
+
+class C43<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, {core.List<core.int> x}) x43;
+ List<Function> Function(int x0, {List<Function> x}) x143;
+ List<T> Function({Function x}) x243;
+ int Function<A>(List<A> x) x343;
+ int Function(int y, {int x}) Function<B extends core.int>(int x) x443;
+ int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) x543;
+ Function Function(int x1) Function<B extends core.int>(int x) x643;
+ Function Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) x743;
+ Function Function(int y, {List<T> x}) Function<B extends core.int>(int x) x843;
+ List<Function> Function([List<Function> x]) Function<B extends core.int>(int x) x943;
+ List<Function> Function(List<T> x1) Function<B extends core.int>(int x) x1043;
+ core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>(int x) x1143;
+ core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) x1243;
+ List<T> Function(Function x) Function<B extends core.int>(int x) x1343;
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) x1443;
+ Function([int x1]) Function<B extends core.int>(int x) x1543;
+ Function({List<Function> x}) Function<B extends core.int>(int x) x1643;
+ Function() Function<B extends core.int>(int x) x1743;
+ core.List<core.int> Function<A>(int x) Function<B extends core.int>(int x) x1843;
+ A Function<A>(Function x) Function<B extends core.int>(int x) x1943;
+
+
+ C43({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m43(int y, {core.List<core.int> x}) => null;
+ List<Function> m143(int x0, {List<Function> x}) => null;
+ List<T> m243({Function x}) => null;
+ int m343<A>(List<A> x) => null;
+ int Function(int y, {int x}) m443<B extends core.int>(int x) => null;
+ int Function(int x0, [core.List<core.int> x]) m543<B extends core.int>(int x) => null;
+ Function Function(int x0) m643<B extends core.int>(int x) => null;
+ Function Function(int x, [List<Function> x0]) m743<B extends core.int>(int x) => null;
+ Function Function(int y, {List<T> x}) m843<B extends core.int>(int x) => null;
+ List<Function> Function([List<Function> x]) m943<B extends core.int>(int x) => null;
+ List<Function> Function(List<T> x0) m1043<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [Function x1]) m1143<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, {core.List<core.int> x}) m1243<B extends core.int>(int x) => null;
+ List<T> Function(Function x) m1343<B extends core.int>(int x) => null;
+ List<T> Function(int y, [core.List<core.int> x]) m1443<B extends core.int>(int x) => null;
+ Function([int x0]) m1543<B extends core.int>(int x) => null;
+ Function({List<Function> x}) m1643<B extends core.int>(int x) => null;
+ Function() m1743<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(int x) m1843<B extends core.int>(int x) => null;
+ A Function<A>(Function x) m1943<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF43();
+ testF143();
+ testF243();
+ testF343();
+ testF443();
+ testF543();
+ testF643();
+ testF743();
+ testF843();
+ testF943();
+ testF1043();
+ testF1143();
+ testF1243();
+ testF1343();
+ testF1443();
+ testF1543();
+ testF1643();
+ testF1743();
+ testF1843();
+ testF1943();
+ }
+
+ void testF43() {
+ // int Function(int y, {core.List<core.int> x})
+ Expect.isTrue(f43 is F43);
+ Expect.isTrue(confuse(f43) is F43);
+ // In checked mode, verifies the type.
+ int Function(int y, {core.List<core.int> x}) l43;
+ // The static function f43 sets `T` to `int`.
+ if (!tIsBool) {
+ x43 = f43 as dynamic;
+ l43 = f43 as dynamic;
+ x43 = confuse(f43);
+ l43 = confuse(f43);
+ }
+
+ Expect.isTrue(m43 is F43);
+ Expect.isTrue(m43 is int Function(int y, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m43) is F43);
+ // In checked mode, verifies the type.
+ x43 = m43;
+ l43 = m43;
+ x43 = confuse(m43);
+ l43 = confuse(m43);
+
+ }
+
+ void testF143() {
+ // List<Function> Function(int x0, {List<Function> x})
+ Expect.isTrue(f143 is F143);
+ Expect.isTrue(confuse(f143) is F143);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {List<Function> x}) l143;
+ // The static function f143 sets `T` to `int`.
+ if (!tIsBool) {
+ x143 = f143 as dynamic;
+ l143 = f143 as dynamic;
+ x143 = confuse(f143);
+ l143 = confuse(f143);
+ }
+
+ Expect.isTrue(m143 is F143);
+ Expect.isTrue(m143 is List<Function> Function(int x0, {List<Function> x}));
+ Expect.isTrue(confuse(m143) is F143);
+ // In checked mode, verifies the type.
+ x143 = m143;
+ l143 = m143;
+ x143 = confuse(m143);
+ l143 = confuse(m143);
+
+ }
+
+ void testF243() {
+ // List<T> Function({Function x})
+ Expect.isTrue(f243 is F243);
+ Expect.isTrue(confuse(f243) is F243);
+ // In checked mode, verifies the type.
+ List<T> Function({Function x}) l243;
+ // The static function f243 sets `T` to `int`.
+ if (!tIsBool) {
+ x243 = f243 as dynamic;
+ l243 = f243 as dynamic;
+ x243 = confuse(f243);
+ l243 = confuse(f243);
+ }
+
+ Expect.isTrue(m243 is F243);
+ Expect.isTrue(m243 is List<T> Function({Function x}));
+ Expect.isTrue(confuse(m243) is F243);
+ // In checked mode, verifies the type.
+ x243 = m243;
+ l243 = m243;
+ x243 = confuse(m243);
+ l243 = confuse(m243);
+ if (!tIsBool) {
+ Expect.isTrue(f243 is F243<int>);
+ Expect.isFalse(f243 is F243<bool>);
+ Expect.isTrue(confuse(f243) is F243<int>);
+ Expect.isFalse(confuse(f243) is F243<bool>);
+ Expect.equals(tIsDynamic, m243 is F243<bool>);
+ Expect.equals(tIsDynamic, confuse(m243) is F243<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x243 = (f243 as dynamic); });
+ Expect.throws(() { x243 = confuse(f243); });
+ List<T> Function({Function x}) l243;
+ Expect.throws(() { l243 = (f243 as dynamic); });
+ Expect.throws(() { l243 = confuse(f243); });
+ }
+ List<T> Function({Function x}) l243 = m243;
+ // In checked mode, verifies the type.
+ x243 = m243;
+ x243 = confuse(m243);
+ }
+ }
+
+ void testF343() {
+ // int Function<A>(List<A> x)
+ Expect.isTrue(f343 is F343);
+ Expect.isTrue(confuse(f343) is F343);
+ // In checked mode, verifies the type.
+ int Function<A>(List<A> x) l343;
+ // The static function f343 sets `T` to `int`.
+ if (!tIsBool) {
+ x343 = f343 as dynamic;
+ l343 = f343 as dynamic;
+ x343 = confuse(f343);
+ l343 = confuse(f343);
+ }
+
+ Expect.isTrue(m343 is F343);
+ Expect.isTrue(m343 is int Function<A>(List<A> x));
+ Expect.isTrue(confuse(m343) is F343);
+ // In checked mode, verifies the type.
+ x343 = m343;
+ l343 = m343;
+ x343 = confuse(m343);
+ l343 = confuse(m343);
+
+ }
+
+ void testF443() {
+ // int Function(int y, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f443 is F443);
+ Expect.isTrue(confuse(f443) is F443);
+ // In checked mode, verifies the type.
+ int Function(int y, {int x}) Function<B extends core.int>(int x) l443;
+ // The static function f443 sets `T` to `int`.
+ if (!tIsBool) {
+ x443 = f443 as dynamic;
+ l443 = f443 as dynamic;
+ x443 = confuse(f443);
+ l443 = confuse(f443);
+ }
+
+ Expect.isTrue(m443 is F443);
+ Expect.isTrue(m443 is int Function(int y, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m443) is F443);
+ // In checked mode, verifies the type.
+ x443 = m443;
+ l443 = m443;
+ x443 = confuse(m443);
+ l443 = confuse(m443);
+
+ }
+
+ void testF543() {
+ // int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f543 is F543);
+ Expect.isTrue(confuse(f543) is F543);
+ // In checked mode, verifies the type.
+ int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l543;
+ // The static function f543 sets `T` to `int`.
+ if (!tIsBool) {
+ x543 = f543 as dynamic;
+ l543 = f543 as dynamic;
+ x543 = confuse(f543);
+ l543 = confuse(f543);
+ }
+
+ Expect.isTrue(m543 is F543);
+ Expect.isTrue(m543 is int Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m543) is F543);
+ // In checked mode, verifies the type.
+ x543 = m543;
+ l543 = m543;
+ x543 = confuse(m543);
+ l543 = confuse(m543);
+
+ }
+
+ void testF643() {
+ // Function Function(int x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f643 is F643);
+ Expect.isTrue(confuse(f643) is F643);
+ // In checked mode, verifies the type.
+ Function Function(int x1) Function<B extends core.int>(int x) l643;
+ // The static function f643 sets `T` to `int`.
+ if (!tIsBool) {
+ x643 = f643 as dynamic;
+ l643 = f643 as dynamic;
+ x643 = confuse(f643);
+ l643 = confuse(f643);
+ }
+
+ Expect.isTrue(m643 is F643);
+ Expect.isTrue(m643 is Function Function(int x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m643) is F643);
+ // In checked mode, verifies the type.
+ x643 = m643;
+ l643 = m643;
+ x643 = confuse(m643);
+ l643 = confuse(m643);
+
+ }
+
+ void testF743() {
+ // Function Function(int x, [List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f743 is F743);
+ Expect.isTrue(confuse(f743) is F743);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l743;
+ // The static function f743 sets `T` to `int`.
+ if (!tIsBool) {
+ x743 = f743 as dynamic;
+ l743 = f743 as dynamic;
+ x743 = confuse(f743);
+ l743 = confuse(f743);
+ }
+
+ Expect.isTrue(m743 is F743);
+ Expect.isTrue(m743 is Function Function(int x, [List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m743) is F743);
+ // In checked mode, verifies the type.
+ x743 = m743;
+ l743 = m743;
+ x743 = confuse(m743);
+ l743 = confuse(m743);
+
+ }
+
+ void testF843() {
+ // Function Function(int y, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f843 is F843);
+ Expect.isTrue(confuse(f843) is F843);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<T> x}) Function<B extends core.int>(int x) l843;
+ // The static function f843 sets `T` to `int`.
+ if (!tIsBool) {
+ x843 = f843 as dynamic;
+ l843 = f843 as dynamic;
+ x843 = confuse(f843);
+ l843 = confuse(f843);
+ }
+
+ Expect.isTrue(m843 is F843);
+ Expect.isTrue(m843 is Function Function(int y, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m843) is F843);
+ // In checked mode, verifies the type.
+ x843 = m843;
+ l843 = m843;
+ x843 = confuse(m843);
+ l843 = confuse(m843);
+ if (!tIsBool) {
+ Expect.isTrue(f843 is F843<int>);
+ Expect.isFalse(f843 is F843<bool>);
+ Expect.isTrue(confuse(f843) is F843<int>);
+ Expect.isFalse(confuse(f843) is F843<bool>);
+ Expect.equals(tIsDynamic, m843 is F843<bool>);
+ Expect.equals(tIsDynamic, confuse(m843) is F843<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x843 = (f843 as dynamic); });
+ Expect.throws(() { x843 = confuse(f843); });
+ Function Function(int y, {List<T> x}) Function<B extends core.int>(int x) l843;
+ Expect.throws(() { l843 = (f843 as dynamic); });
+ Expect.throws(() { l843 = confuse(f843); });
+ }
+ Function Function(int y, {List<T> x}) Function<B extends core.int>(int x) l843 = m843;
+ // In checked mode, verifies the type.
+ x843 = m843;
+ x843 = confuse(m843);
+ }
+ }
+
+ void testF943() {
+ // List<Function> Function([List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f943 is F943);
+ Expect.isTrue(confuse(f943) is F943);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x]) Function<B extends core.int>(int x) l943;
+ // The static function f943 sets `T` to `int`.
+ if (!tIsBool) {
+ x943 = f943 as dynamic;
+ l943 = f943 as dynamic;
+ x943 = confuse(f943);
+ l943 = confuse(f943);
+ }
+
+ Expect.isTrue(m943 is F943);
+ Expect.isTrue(m943 is List<Function> Function([List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m943) is F943);
+ // In checked mode, verifies the type.
+ x943 = m943;
+ l943 = m943;
+ x943 = confuse(m943);
+ l943 = confuse(m943);
+
+ }
+
+ void testF1043() {
+ // List<Function> Function(List<T> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1043 is F1043);
+ Expect.isTrue(confuse(f1043) is F1043);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x1) Function<B extends core.int>(int x) l1043;
+ // The static function f1043 sets `T` to `int`.
+ if (!tIsBool) {
+ x1043 = f1043 as dynamic;
+ l1043 = f1043 as dynamic;
+ x1043 = confuse(f1043);
+ l1043 = confuse(f1043);
+ }
+
+ Expect.isTrue(m1043 is F1043);
+ Expect.isTrue(m1043 is List<Function> Function(List<T> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1043) is F1043);
+ // In checked mode, verifies the type.
+ x1043 = m1043;
+ l1043 = m1043;
+ x1043 = confuse(m1043);
+ l1043 = confuse(m1043);
+ if (!tIsBool) {
+ Expect.isTrue(f1043 is F1043<int>);
+ Expect.isFalse(f1043 is F1043<bool>);
+ Expect.isTrue(confuse(f1043) is F1043<int>);
+ Expect.isFalse(confuse(f1043) is F1043<bool>);
+ Expect.equals(tIsDynamic, m1043 is F1043<bool>);
+ Expect.equals(tIsDynamic, confuse(m1043) is F1043<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1043 = (f1043 as dynamic); });
+ Expect.throws(() { x1043 = confuse(f1043); });
+ List<Function> Function(List<T> x1) Function<B extends core.int>(int x) l1043;
+ Expect.throws(() { l1043 = (f1043 as dynamic); });
+ Expect.throws(() { l1043 = confuse(f1043); });
+ }
+ List<Function> Function(List<T> x1) Function<B extends core.int>(int x) l1043 = m1043;
+ // In checked mode, verifies the type.
+ x1043 = m1043;
+ x1043 = confuse(m1043);
+ }
+ }
+
+ void testF1143() {
+ // core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1143 is F1143);
+ Expect.isTrue(confuse(f1143) is F1143);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>(int x) l1143;
+ // The static function f1143 sets `T` to `int`.
+ if (!tIsBool) {
+ x1143 = f1143 as dynamic;
+ l1143 = f1143 as dynamic;
+ x1143 = confuse(f1143);
+ l1143 = confuse(f1143);
+ }
+
+ Expect.isTrue(m1143 is F1143);
+ Expect.isTrue(m1143 is core.List<core.int> Function(int x2, [Function x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1143) is F1143);
+ // In checked mode, verifies the type.
+ x1143 = m1143;
+ l1143 = m1143;
+ x1143 = confuse(m1143);
+ l1143 = confuse(m1143);
+
+ }
+
+ void testF1243() {
+ // core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1243 is F1243);
+ Expect.isTrue(confuse(f1243) is F1243);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l1243;
+ // The static function f1243 sets `T` to `int`.
+ if (!tIsBool) {
+ x1243 = f1243 as dynamic;
+ l1243 = f1243 as dynamic;
+ x1243 = confuse(f1243);
+ l1243 = confuse(f1243);
+ }
+
+ Expect.isTrue(m1243 is F1243);
+ Expect.isTrue(m1243 is core.List<core.int> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1243) is F1243);
+ // In checked mode, verifies the type.
+ x1243 = m1243;
+ l1243 = m1243;
+ x1243 = confuse(m1243);
+ l1243 = confuse(m1243);
+
+ }
+
+ void testF1343() {
+ // List<T> Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1343 is F1343);
+ Expect.isTrue(confuse(f1343) is F1343);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x) Function<B extends core.int>(int x) l1343;
+ // The static function f1343 sets `T` to `int`.
+ if (!tIsBool) {
+ x1343 = f1343 as dynamic;
+ l1343 = f1343 as dynamic;
+ x1343 = confuse(f1343);
+ l1343 = confuse(f1343);
+ }
+
+ Expect.isTrue(m1343 is F1343);
+ Expect.isTrue(m1343 is List<T> Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1343) is F1343);
+ // In checked mode, verifies the type.
+ x1343 = m1343;
+ l1343 = m1343;
+ x1343 = confuse(m1343);
+ l1343 = confuse(m1343);
+ if (!tIsBool) {
+ Expect.isTrue(f1343 is F1343<int>);
+ Expect.isFalse(f1343 is F1343<bool>);
+ Expect.isTrue(confuse(f1343) is F1343<int>);
+ Expect.isFalse(confuse(f1343) is F1343<bool>);
+ Expect.equals(tIsDynamic, m1343 is F1343<bool>);
+ Expect.equals(tIsDynamic, confuse(m1343) is F1343<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1343 = (f1343 as dynamic); });
+ Expect.throws(() { x1343 = confuse(f1343); });
+ List<T> Function(Function x) Function<B extends core.int>(int x) l1343;
+ Expect.throws(() { l1343 = (f1343 as dynamic); });
+ Expect.throws(() { l1343 = confuse(f1343); });
+ }
+ List<T> Function(Function x) Function<B extends core.int>(int x) l1343 = m1343;
+ // In checked mode, verifies the type.
+ x1343 = m1343;
+ x1343 = confuse(m1343);
+ }
+ }
+
+ void testF1443() {
+ // List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1443 is F1443);
+ Expect.isTrue(confuse(f1443) is F1443);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l1443;
+ // The static function f1443 sets `T` to `int`.
+ if (!tIsBool) {
+ x1443 = f1443 as dynamic;
+ l1443 = f1443 as dynamic;
+ x1443 = confuse(f1443);
+ l1443 = confuse(f1443);
+ }
+
+ Expect.isTrue(m1443 is F1443);
+ Expect.isTrue(m1443 is List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1443) is F1443);
+ // In checked mode, verifies the type.
+ x1443 = m1443;
+ l1443 = m1443;
+ x1443 = confuse(m1443);
+ l1443 = confuse(m1443);
+ if (!tIsBool) {
+ Expect.isTrue(f1443 is F1443<int>);
+ Expect.isFalse(f1443 is F1443<bool>);
+ Expect.isTrue(confuse(f1443) is F1443<int>);
+ Expect.isFalse(confuse(f1443) is F1443<bool>);
+ Expect.equals(tIsDynamic, m1443 is F1443<bool>);
+ Expect.equals(tIsDynamic, confuse(m1443) is F1443<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1443 = (f1443 as dynamic); });
+ Expect.throws(() { x1443 = confuse(f1443); });
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l1443;
+ Expect.throws(() { l1443 = (f1443 as dynamic); });
+ Expect.throws(() { l1443 = confuse(f1443); });
+ }
+ List<T> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l1443 = m1443;
+ // In checked mode, verifies the type.
+ x1443 = m1443;
+ x1443 = confuse(m1443);
+ }
+ }
+
+ void testF1543() {
+ // Function([int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1543 is F1543);
+ Expect.isTrue(confuse(f1543) is F1543);
+ // In checked mode, verifies the type.
+ Function([int x1]) Function<B extends core.int>(int x) l1543;
+ // The static function f1543 sets `T` to `int`.
+ if (!tIsBool) {
+ x1543 = f1543 as dynamic;
+ l1543 = f1543 as dynamic;
+ x1543 = confuse(f1543);
+ l1543 = confuse(f1543);
+ }
+
+ Expect.isTrue(m1543 is F1543);
+ Expect.isTrue(m1543 is Function([int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1543) is F1543);
+ // In checked mode, verifies the type.
+ x1543 = m1543;
+ l1543 = m1543;
+ x1543 = confuse(m1543);
+ l1543 = confuse(m1543);
+
+ }
+
+ void testF1643() {
+ // Function({List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1643 is F1643);
+ Expect.isTrue(confuse(f1643) is F1643);
+ // In checked mode, verifies the type.
+ Function({List<Function> x}) Function<B extends core.int>(int x) l1643;
+ // The static function f1643 sets `T` to `int`.
+ if (!tIsBool) {
+ x1643 = f1643 as dynamic;
+ l1643 = f1643 as dynamic;
+ x1643 = confuse(f1643);
+ l1643 = confuse(f1643);
+ }
+
+ Expect.isTrue(m1643 is F1643);
+ Expect.isTrue(m1643 is Function({List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1643) is F1643);
+ // In checked mode, verifies the type.
+ x1643 = m1643;
+ l1643 = m1643;
+ x1643 = confuse(m1643);
+ l1643 = confuse(m1643);
+
+ }
+
+ void testF1743() {
+ // Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f1743 is F1743);
+ Expect.isTrue(confuse(f1743) is F1743);
+ // In checked mode, verifies the type.
+ Function() Function<B extends core.int>(int x) l1743;
+ // The static function f1743 sets `T` to `int`.
+ if (!tIsBool) {
+ x1743 = f1743 as dynamic;
+ l1743 = f1743 as dynamic;
+ x1743 = confuse(f1743);
+ l1743 = confuse(f1743);
+ }
+
+ Expect.isTrue(m1743 is F1743);
+ Expect.isTrue(m1743 is Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1743) is F1743);
+ // In checked mode, verifies the type.
+ x1743 = m1743;
+ l1743 = m1743;
+ x1743 = confuse(m1743);
+ l1743 = confuse(m1743);
+
+ }
+
+ void testF1843() {
+ // core.List<core.int> Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1843 is F1843);
+ Expect.isTrue(confuse(f1843) is F1843);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(int x) Function<B extends core.int>(int x) l1843;
+ // The static function f1843 sets `T` to `int`.
+ if (!tIsBool) {
+ x1843 = f1843 as dynamic;
+ l1843 = f1843 as dynamic;
+ x1843 = confuse(f1843);
+ l1843 = confuse(f1843);
+ }
+
+ Expect.isTrue(m1843 is F1843);
+ Expect.isTrue(m1843 is core.List<core.int> Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1843) is F1843);
+ // In checked mode, verifies the type.
+ x1843 = m1843;
+ l1843 = m1843;
+ x1843 = confuse(m1843);
+ l1843 = confuse(m1843);
+
+ }
+
+ void testF1943() {
+ // A Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1943 is F1943);
+ Expect.isTrue(confuse(f1943) is F1943);
+ // In checked mode, verifies the type.
+ A Function<A>(Function x) Function<B extends core.int>(int x) l1943;
+ // The static function f1943 sets `T` to `int`.
+ if (!tIsBool) {
+ x1943 = f1943 as dynamic;
+ l1943 = f1943 as dynamic;
+ x1943 = confuse(f1943);
+ l1943 = confuse(f1943);
+ }
+
+ Expect.isTrue(m1943 is F1943);
+ Expect.isTrue(m1943 is A Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1943) is F1943);
+ // In checked mode, verifies the type.
+ x1943 = m1943;
+ l1943 = m1943;
+ x1943 = confuse(m1943);
+ l1943 = confuse(m1943);
+
+ }
+
+
+}
+
+class C44<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(List<T> x) x44;
+ List<Function> Function(int y, {List<Function> x}) x144;
+ List<T> Function(int x0, {Function x}) x244;
+ Function Function<A>(int x) x344;
+ int Function(Function x) Function() x444;
+ int Function(int y, [core.List<core.int> x]) Function() x544;
+ Function Function([int x1]) Function() x644;
+ Function Function({List<Function> x}) Function() x744;
+ Function Function() Function() x844;
+ List<Function> Function(int x0, [List<Function> x]) Function() x944;
+ List<Function> Function([List<T> x1]) Function() x1044;
+ core.List<core.int> Function(int x, [Function x2]) Function() x1144;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function() x1244;
+ List<T> Function([Function x]) Function() x1344;
+ List<T> Function(core.List<core.int> x0) Function() x1444;
+ Function(int x1, [int x2]) Function() x1544;
+ Function(int x0, {List<Function> x}) Function() x1644;
+ int Function<A>(int x) Function() x1744;
+ core.List<core.int> Function<A>(Function x) Function() x1844;
+ A Function<A>(List<Function> x) Function() x1944;
+
+
+ C44({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m44(List<T> x) => null;
+ List<Function> m144(int y, {List<Function> x}) => null;
+ List<T> m244(int x0, {Function x}) => null;
+ Function m344<A>(int x) => null;
+ int Function(Function x) m444() => null;
+ int Function(int y, [core.List<core.int> x]) m544() => null;
+ Function Function([int x0]) m644() => null;
+ Function Function({List<Function> x}) m744() => null;
+ Function Function() m844() => null;
+ List<Function> Function(int x0, [List<Function> x]) m944() => null;
+ List<Function> Function([List<T> x0]) m1044() => null;
+ core.List<core.int> Function(int x, [Function x0]) m1144() => null;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) m1244() => null;
+ List<T> Function([Function x]) m1344() => null;
+ List<T> Function(core.List<core.int> x0) m1444() => null;
+ Function(int x0, [int x1]) m1544() => null;
+ Function(int x0, {List<Function> x}) m1644() => null;
+ int Function<A>(int x) m1744() => null;
+ core.List<core.int> Function<A>(Function x) m1844() => null;
+ A Function<A>(List<Function> x) m1944() => null;
+
+
+ runTests() {
+ testF44();
+ testF144();
+ testF244();
+ testF344();
+ testF444();
+ testF544();
+ testF644();
+ testF744();
+ testF844();
+ testF944();
+ testF1044();
+ testF1144();
+ testF1244();
+ testF1344();
+ testF1444();
+ testF1544();
+ testF1644();
+ testF1744();
+ testF1844();
+ testF1944();
+ }
+
+ void testF44() {
+ // int Function(List<T> x)
+ Expect.isTrue(f44 is F44);
+ Expect.isTrue(confuse(f44) is F44);
+ // In checked mode, verifies the type.
+ int Function(List<T> x) l44;
+ // The static function f44 sets `T` to `int`.
+ if (!tIsBool) {
+ x44 = f44 as dynamic;
+ l44 = f44 as dynamic;
+ x44 = confuse(f44);
+ l44 = confuse(f44);
+ }
+
+ Expect.isTrue(m44 is F44);
+ Expect.isTrue(m44 is int Function(List<T> x));
+ Expect.isTrue(confuse(m44) is F44);
+ // In checked mode, verifies the type.
+ x44 = m44;
+ l44 = m44;
+ x44 = confuse(m44);
+ l44 = confuse(m44);
+ if (!tIsBool) {
+ Expect.isTrue(f44 is F44<int>);
+ Expect.isFalse(f44 is F44<bool>);
+ Expect.isTrue(confuse(f44) is F44<int>);
+ Expect.isFalse(confuse(f44) is F44<bool>);
+ Expect.equals(tIsDynamic, m44 is F44<bool>);
+ Expect.equals(tIsDynamic, confuse(m44) is F44<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x44 = (f44 as dynamic); });
+ Expect.throws(() { x44 = confuse(f44); });
+ int Function(List<T> x) l44;
+ Expect.throws(() { l44 = (f44 as dynamic); });
+ Expect.throws(() { l44 = confuse(f44); });
+ }
+ int Function(List<T> x) l44 = m44;
+ // In checked mode, verifies the type.
+ x44 = m44;
+ x44 = confuse(m44);
+ }
+ }
+
+ void testF144() {
+ // List<Function> Function(int y, {List<Function> x})
+ Expect.isTrue(f144 is F144);
+ Expect.isTrue(confuse(f144) is F144);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<Function> x}) l144;
+ // The static function f144 sets `T` to `int`.
+ if (!tIsBool) {
+ x144 = f144 as dynamic;
+ l144 = f144 as dynamic;
+ x144 = confuse(f144);
+ l144 = confuse(f144);
+ }
+
+ Expect.isTrue(m144 is F144);
+ Expect.isTrue(m144 is List<Function> Function(int y, {List<Function> x}));
+ Expect.isTrue(confuse(m144) is F144);
+ // In checked mode, verifies the type.
+ x144 = m144;
+ l144 = m144;
+ x144 = confuse(m144);
+ l144 = confuse(m144);
+
+ }
+
+ void testF244() {
+ // List<T> Function(int x0, {Function x})
+ Expect.isTrue(f244 is F244);
+ Expect.isTrue(confuse(f244) is F244);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {Function x}) l244;
+ // The static function f244 sets `T` to `int`.
+ if (!tIsBool) {
+ x244 = f244 as dynamic;
+ l244 = f244 as dynamic;
+ x244 = confuse(f244);
+ l244 = confuse(f244);
+ }
+
+ Expect.isTrue(m244 is F244);
+ Expect.isTrue(m244 is List<T> Function(int x0, {Function x}));
+ Expect.isTrue(confuse(m244) is F244);
+ // In checked mode, verifies the type.
+ x244 = m244;
+ l244 = m244;
+ x244 = confuse(m244);
+ l244 = confuse(m244);
+ if (!tIsBool) {
+ Expect.isTrue(f244 is F244<int>);
+ Expect.isFalse(f244 is F244<bool>);
+ Expect.isTrue(confuse(f244) is F244<int>);
+ Expect.isFalse(confuse(f244) is F244<bool>);
+ Expect.equals(tIsDynamic, m244 is F244<bool>);
+ Expect.equals(tIsDynamic, confuse(m244) is F244<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x244 = (f244 as dynamic); });
+ Expect.throws(() { x244 = confuse(f244); });
+ List<T> Function(int x0, {Function x}) l244;
+ Expect.throws(() { l244 = (f244 as dynamic); });
+ Expect.throws(() { l244 = confuse(f244); });
+ }
+ List<T> Function(int x0, {Function x}) l244 = m244;
+ // In checked mode, verifies the type.
+ x244 = m244;
+ x244 = confuse(m244);
+ }
+ }
+
+ void testF344() {
+ // Function Function<A>(int x)
+ Expect.isTrue(f344 is F344);
+ Expect.isTrue(confuse(f344) is F344);
+ // In checked mode, verifies the type.
+ Function Function<A>(int x) l344;
+ // The static function f344 sets `T` to `int`.
+ if (!tIsBool) {
+ x344 = f344 as dynamic;
+ l344 = f344 as dynamic;
+ x344 = confuse(f344);
+ l344 = confuse(f344);
+ }
+
+ Expect.isTrue(m344 is F344);
+ Expect.isTrue(m344 is Function Function<A>(int x));
+ Expect.isTrue(confuse(m344) is F344);
+ // In checked mode, verifies the type.
+ x344 = m344;
+ l344 = m344;
+ x344 = confuse(m344);
+ l344 = confuse(m344);
+
+ }
+
+ void testF444() {
+ // int Function(Function x) Function()
+ Expect.isTrue(f444 is F444);
+ Expect.isTrue(confuse(f444) is F444);
+ // In checked mode, verifies the type.
+ int Function(Function x) Function() l444;
+ // The static function f444 sets `T` to `int`.
+ if (!tIsBool) {
+ x444 = f444 as dynamic;
+ l444 = f444 as dynamic;
+ x444 = confuse(f444);
+ l444 = confuse(f444);
+ }
+
+ Expect.isTrue(m444 is F444);
+ Expect.isTrue(m444 is int Function(Function x) Function());
+ Expect.isTrue(confuse(m444) is F444);
+ // In checked mode, verifies the type.
+ x444 = m444;
+ l444 = m444;
+ x444 = confuse(m444);
+ l444 = confuse(m444);
+
+ }
+
+ void testF544() {
+ // int Function(int y, [core.List<core.int> x]) Function()
+ Expect.isTrue(f544 is F544);
+ Expect.isTrue(confuse(f544) is F544);
+ // In checked mode, verifies the type.
+ int Function(int y, [core.List<core.int> x]) Function() l544;
+ // The static function f544 sets `T` to `int`.
+ if (!tIsBool) {
+ x544 = f544 as dynamic;
+ l544 = f544 as dynamic;
+ x544 = confuse(f544);
+ l544 = confuse(f544);
+ }
+
+ Expect.isTrue(m544 is F544);
+ Expect.isTrue(m544 is int Function(int y, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m544) is F544);
+ // In checked mode, verifies the type.
+ x544 = m544;
+ l544 = m544;
+ x544 = confuse(m544);
+ l544 = confuse(m544);
+
+ }
+
+ void testF644() {
+ // Function Function([int x1]) Function()
+ Expect.isTrue(f644 is F644);
+ Expect.isTrue(confuse(f644) is F644);
+ // In checked mode, verifies the type.
+ Function Function([int x1]) Function() l644;
+ // The static function f644 sets `T` to `int`.
+ if (!tIsBool) {
+ x644 = f644 as dynamic;
+ l644 = f644 as dynamic;
+ x644 = confuse(f644);
+ l644 = confuse(f644);
+ }
+
+ Expect.isTrue(m644 is F644);
+ Expect.isTrue(m644 is Function Function([int x1]) Function());
+ Expect.isTrue(confuse(m644) is F644);
+ // In checked mode, verifies the type.
+ x644 = m644;
+ l644 = m644;
+ x644 = confuse(m644);
+ l644 = confuse(m644);
+
+ }
+
+ void testF744() {
+ // Function Function({List<Function> x}) Function()
+ Expect.isTrue(f744 is F744);
+ Expect.isTrue(confuse(f744) is F744);
+ // In checked mode, verifies the type.
+ Function Function({List<Function> x}) Function() l744;
+ // The static function f744 sets `T` to `int`.
+ if (!tIsBool) {
+ x744 = f744 as dynamic;
+ l744 = f744 as dynamic;
+ x744 = confuse(f744);
+ l744 = confuse(f744);
+ }
+
+ Expect.isTrue(m744 is F744);
+ Expect.isTrue(m744 is Function Function({List<Function> x}) Function());
+ Expect.isTrue(confuse(m744) is F744);
+ // In checked mode, verifies the type.
+ x744 = m744;
+ l744 = m744;
+ x744 = confuse(m744);
+ l744 = confuse(m744);
+
+ }
+
+ void testF844() {
+ // Function Function() Function()
+ Expect.isTrue(f844 is F844);
+ Expect.isTrue(confuse(f844) is F844);
+ // In checked mode, verifies the type.
+ Function Function() Function() l844;
+ // The static function f844 sets `T` to `int`.
+ if (!tIsBool) {
+ x844 = f844 as dynamic;
+ l844 = f844 as dynamic;
+ x844 = confuse(f844);
+ l844 = confuse(f844);
+ }
+
+ Expect.isTrue(m844 is F844);
+ Expect.isTrue(m844 is Function Function() Function());
+ Expect.isTrue(confuse(m844) is F844);
+ // In checked mode, verifies the type.
+ x844 = m844;
+ l844 = m844;
+ x844 = confuse(m844);
+ l844 = confuse(m844);
+
+ }
+
+ void testF944() {
+ // List<Function> Function(int x0, [List<Function> x]) Function()
+ Expect.isTrue(f944 is F944);
+ Expect.isTrue(confuse(f944) is F944);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [List<Function> x]) Function() l944;
+ // The static function f944 sets `T` to `int`.
+ if (!tIsBool) {
+ x944 = f944 as dynamic;
+ l944 = f944 as dynamic;
+ x944 = confuse(f944);
+ l944 = confuse(f944);
+ }
+
+ Expect.isTrue(m944 is F944);
+ Expect.isTrue(m944 is List<Function> Function(int x0, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m944) is F944);
+ // In checked mode, verifies the type.
+ x944 = m944;
+ l944 = m944;
+ x944 = confuse(m944);
+ l944 = confuse(m944);
+
+ }
+
+ void testF1044() {
+ // List<Function> Function([List<T> x1]) Function()
+ Expect.isTrue(f1044 is F1044);
+ Expect.isTrue(confuse(f1044) is F1044);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x1]) Function() l1044;
+ // The static function f1044 sets `T` to `int`.
+ if (!tIsBool) {
+ x1044 = f1044 as dynamic;
+ l1044 = f1044 as dynamic;
+ x1044 = confuse(f1044);
+ l1044 = confuse(f1044);
+ }
+
+ Expect.isTrue(m1044 is F1044);
+ Expect.isTrue(m1044 is List<Function> Function([List<T> x1]) Function());
+ Expect.isTrue(confuse(m1044) is F1044);
+ // In checked mode, verifies the type.
+ x1044 = m1044;
+ l1044 = m1044;
+ x1044 = confuse(m1044);
+ l1044 = confuse(m1044);
+ if (!tIsBool) {
+ Expect.isTrue(f1044 is F1044<int>);
+ Expect.isFalse(f1044 is F1044<bool>);
+ Expect.isTrue(confuse(f1044) is F1044<int>);
+ Expect.isFalse(confuse(f1044) is F1044<bool>);
+ Expect.equals(tIsDynamic, m1044 is F1044<bool>);
+ Expect.equals(tIsDynamic, confuse(m1044) is F1044<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1044 = (f1044 as dynamic); });
+ Expect.throws(() { x1044 = confuse(f1044); });
+ List<Function> Function([List<T> x1]) Function() l1044;
+ Expect.throws(() { l1044 = (f1044 as dynamic); });
+ Expect.throws(() { l1044 = confuse(f1044); });
+ }
+ List<Function> Function([List<T> x1]) Function() l1044 = m1044;
+ // In checked mode, verifies the type.
+ x1044 = m1044;
+ x1044 = confuse(m1044);
+ }
+ }
+
+ void testF1144() {
+ // core.List<core.int> Function(int x, [Function x2]) Function()
+ Expect.isTrue(f1144 is F1144);
+ Expect.isTrue(confuse(f1144) is F1144);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [Function x2]) Function() l1144;
+ // The static function f1144 sets `T` to `int`.
+ if (!tIsBool) {
+ x1144 = f1144 as dynamic;
+ l1144 = f1144 as dynamic;
+ x1144 = confuse(f1144);
+ l1144 = confuse(f1144);
+ }
+
+ Expect.isTrue(m1144 is F1144);
+ Expect.isTrue(m1144 is core.List<core.int> Function(int x, [Function x2]) Function());
+ Expect.isTrue(confuse(m1144) is F1144);
+ // In checked mode, verifies the type.
+ x1144 = m1144;
+ l1144 = m1144;
+ x1144 = confuse(m1144);
+ l1144 = confuse(m1144);
+
+ }
+
+ void testF1244() {
+ // core.List<core.int> Function(int y, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1244 is F1244);
+ Expect.isTrue(confuse(f1244) is F1244);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function() l1244;
+ // The static function f1244 sets `T` to `int`.
+ if (!tIsBool) {
+ x1244 = f1244 as dynamic;
+ l1244 = f1244 as dynamic;
+ x1244 = confuse(f1244);
+ l1244 = confuse(f1244);
+ }
+
+ Expect.isTrue(m1244 is F1244);
+ Expect.isTrue(m1244 is core.List<core.int> Function(int y, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1244) is F1244);
+ // In checked mode, verifies the type.
+ x1244 = m1244;
+ l1244 = m1244;
+ x1244 = confuse(m1244);
+ l1244 = confuse(m1244);
+
+ }
+
+ void testF1344() {
+ // List<T> Function([Function x]) Function()
+ Expect.isTrue(f1344 is F1344);
+ Expect.isTrue(confuse(f1344) is F1344);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x]) Function() l1344;
+ // The static function f1344 sets `T` to `int`.
+ if (!tIsBool) {
+ x1344 = f1344 as dynamic;
+ l1344 = f1344 as dynamic;
+ x1344 = confuse(f1344);
+ l1344 = confuse(f1344);
+ }
+
+ Expect.isTrue(m1344 is F1344);
+ Expect.isTrue(m1344 is List<T> Function([Function x]) Function());
+ Expect.isTrue(confuse(m1344) is F1344);
+ // In checked mode, verifies the type.
+ x1344 = m1344;
+ l1344 = m1344;
+ x1344 = confuse(m1344);
+ l1344 = confuse(m1344);
+ if (!tIsBool) {
+ Expect.isTrue(f1344 is F1344<int>);
+ Expect.isFalse(f1344 is F1344<bool>);
+ Expect.isTrue(confuse(f1344) is F1344<int>);
+ Expect.isFalse(confuse(f1344) is F1344<bool>);
+ Expect.equals(tIsDynamic, m1344 is F1344<bool>);
+ Expect.equals(tIsDynamic, confuse(m1344) is F1344<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1344 = (f1344 as dynamic); });
+ Expect.throws(() { x1344 = confuse(f1344); });
+ List<T> Function([Function x]) Function() l1344;
+ Expect.throws(() { l1344 = (f1344 as dynamic); });
+ Expect.throws(() { l1344 = confuse(f1344); });
+ }
+ List<T> Function([Function x]) Function() l1344 = m1344;
+ // In checked mode, verifies the type.
+ x1344 = m1344;
+ x1344 = confuse(m1344);
+ }
+ }
+
+ void testF1444() {
+ // List<T> Function(core.List<core.int> x0) Function()
+ Expect.isTrue(f1444 is F1444);
+ Expect.isTrue(confuse(f1444) is F1444);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x0) Function() l1444;
+ // The static function f1444 sets `T` to `int`.
+ if (!tIsBool) {
+ x1444 = f1444 as dynamic;
+ l1444 = f1444 as dynamic;
+ x1444 = confuse(f1444);
+ l1444 = confuse(f1444);
+ }
+
+ Expect.isTrue(m1444 is F1444);
+ Expect.isTrue(m1444 is List<T> Function(core.List<core.int> x0) Function());
+ Expect.isTrue(confuse(m1444) is F1444);
+ // In checked mode, verifies the type.
+ x1444 = m1444;
+ l1444 = m1444;
+ x1444 = confuse(m1444);
+ l1444 = confuse(m1444);
+ if (!tIsBool) {
+ Expect.isTrue(f1444 is F1444<int>);
+ Expect.isFalse(f1444 is F1444<bool>);
+ Expect.isTrue(confuse(f1444) is F1444<int>);
+ Expect.isFalse(confuse(f1444) is F1444<bool>);
+ Expect.equals(tIsDynamic, m1444 is F1444<bool>);
+ Expect.equals(tIsDynamic, confuse(m1444) is F1444<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1444 = (f1444 as dynamic); });
+ Expect.throws(() { x1444 = confuse(f1444); });
+ List<T> Function(core.List<core.int> x0) Function() l1444;
+ Expect.throws(() { l1444 = (f1444 as dynamic); });
+ Expect.throws(() { l1444 = confuse(f1444); });
+ }
+ List<T> Function(core.List<core.int> x0) Function() l1444 = m1444;
+ // In checked mode, verifies the type.
+ x1444 = m1444;
+ x1444 = confuse(m1444);
+ }
+ }
+
+ void testF1544() {
+ // Function(int x1, [int x2]) Function()
+ Expect.isTrue(f1544 is F1544);
+ Expect.isTrue(confuse(f1544) is F1544);
+ // In checked mode, verifies the type.
+ Function(int x1, [int x2]) Function() l1544;
+ // The static function f1544 sets `T` to `int`.
+ if (!tIsBool) {
+ x1544 = f1544 as dynamic;
+ l1544 = f1544 as dynamic;
+ x1544 = confuse(f1544);
+ l1544 = confuse(f1544);
+ }
+
+ Expect.isTrue(m1544 is F1544);
+ Expect.isTrue(m1544 is Function(int x1, [int x2]) Function());
+ Expect.isTrue(confuse(m1544) is F1544);
+ // In checked mode, verifies the type.
+ x1544 = m1544;
+ l1544 = m1544;
+ x1544 = confuse(m1544);
+ l1544 = confuse(m1544);
+
+ }
+
+ void testF1644() {
+ // Function(int x0, {List<Function> x}) Function()
+ Expect.isTrue(f1644 is F1644);
+ Expect.isTrue(confuse(f1644) is F1644);
+ // In checked mode, verifies the type.
+ Function(int x0, {List<Function> x}) Function() l1644;
+ // The static function f1644 sets `T` to `int`.
+ if (!tIsBool) {
+ x1644 = f1644 as dynamic;
+ l1644 = f1644 as dynamic;
+ x1644 = confuse(f1644);
+ l1644 = confuse(f1644);
+ }
+
+ Expect.isTrue(m1644 is F1644);
+ Expect.isTrue(m1644 is Function(int x0, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m1644) is F1644);
+ // In checked mode, verifies the type.
+ x1644 = m1644;
+ l1644 = m1644;
+ x1644 = confuse(m1644);
+ l1644 = confuse(m1644);
+
+ }
+
+ void testF1744() {
+ // int Function<A>(int x) Function()
+ Expect.isTrue(f1744 is F1744);
+ Expect.isTrue(confuse(f1744) is F1744);
+ // In checked mode, verifies the type.
+ int Function<A>(int x) Function() l1744;
+ // The static function f1744 sets `T` to `int`.
+ if (!tIsBool) {
+ x1744 = f1744 as dynamic;
+ l1744 = f1744 as dynamic;
+ x1744 = confuse(f1744);
+ l1744 = confuse(f1744);
+ }
+
+ Expect.isTrue(m1744 is F1744);
+ Expect.isTrue(m1744 is int Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1744) is F1744);
+ // In checked mode, verifies the type.
+ x1744 = m1744;
+ l1744 = m1744;
+ x1744 = confuse(m1744);
+ l1744 = confuse(m1744);
+
+ }
+
+ void testF1844() {
+ // core.List<core.int> Function<A>(Function x) Function()
+ Expect.isTrue(f1844 is F1844);
+ Expect.isTrue(confuse(f1844) is F1844);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(Function x) Function() l1844;
+ // The static function f1844 sets `T` to `int`.
+ if (!tIsBool) {
+ x1844 = f1844 as dynamic;
+ l1844 = f1844 as dynamic;
+ x1844 = confuse(f1844);
+ l1844 = confuse(f1844);
+ }
+
+ Expect.isTrue(m1844 is F1844);
+ Expect.isTrue(m1844 is core.List<core.int> Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1844) is F1844);
+ // In checked mode, verifies the type.
+ x1844 = m1844;
+ l1844 = m1844;
+ x1844 = confuse(m1844);
+ l1844 = confuse(m1844);
+
+ }
+
+ void testF1944() {
+ // A Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1944 is F1944);
+ Expect.isTrue(confuse(f1944) is F1944);
+ // In checked mode, verifies the type.
+ A Function<A>(List<Function> x) Function() l1944;
+ // The static function f1944 sets `T` to `int`.
+ if (!tIsBool) {
+ x1944 = f1944 as dynamic;
+ l1944 = f1944 as dynamic;
+ x1944 = confuse(f1944);
+ l1944 = confuse(f1944);
+ }
+
+ Expect.isTrue(m1944 is F1944);
+ Expect.isTrue(m1944 is A Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1944) is F1944);
+ // In checked mode, verifies the type.
+ x1944 = m1944;
+ l1944 = m1944;
+ x1944 = confuse(m1944);
+ l1944 = confuse(m1944);
+
+ }
+
+
+}
+
+class C45<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([List<T> x]) x45;
+ List<Function> Function(core.List<core.int> x) x145;
+ List<T> Function(int y, {Function x}) x245;
+ Function Function<A>(Function x) x345;
+ int Function(Function x) Function(int x) x445;
+ int Function(int y, [core.List<core.int> x]) Function(int x) x545;
+ Function Function([int x1]) Function(int x) x645;
+ Function Function({List<Function> x}) Function(int x) x745;
+ Function Function() Function(int x) x845;
+ List<Function> Function(int x1, [List<Function> x]) Function(int x) x945;
+ List<Function> Function([List<T> x1]) Function(int x) x1045;
+ core.List<core.int> Function(int x, [Function x1]) Function(int x) x1145;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function(int x) x1245;
+ List<T> Function([Function x]) Function(int x) x1345;
+ List<T> Function(core.List<core.int> x1) Function(int x) x1445;
+ Function(int x2, [int x3]) Function(int x) x1545;
+ Function(int x1, {List<Function> x}) Function(int x) x1645;
+ int Function<A>(int x) Function(int x) x1745;
+ core.List<core.int> Function<A>(Function x) Function(int x) x1845;
+ A Function<A>(List<Function> x) Function(int x) x1945;
+
+
+ C45({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m45([List<T> x]) => null;
+ List<Function> m145(core.List<core.int> x) => null;
+ List<T> m245(int y, {Function x}) => null;
+ Function m345<A>(Function x) => null;
+ int Function(Function x) m445(int x) => null;
+ int Function(int y, [core.List<core.int> x]) m545(int x) => null;
+ Function Function([int x0]) m645(int x) => null;
+ Function Function({List<Function> x}) m745(int x) => null;
+ Function Function() m845(int x) => null;
+ List<Function> Function(int x0, [List<Function> x]) m945(int x) => null;
+ List<Function> Function([List<T> x0]) m1045(int x) => null;
+ core.List<core.int> Function(int x, [Function x0]) m1145(int x) => null;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) m1245(int x) => null;
+ List<T> Function([Function x]) m1345(int x) => null;
+ List<T> Function(core.List<core.int> x0) m1445(int x) => null;
+ Function(int x0, [int x1]) m1545(int x) => null;
+ Function(int x0, {List<Function> x}) m1645(int x) => null;
+ int Function<A>(int x) m1745(int x) => null;
+ core.List<core.int> Function<A>(Function x) m1845(int x) => null;
+ A Function<A>(List<Function> x) m1945(int x) => null;
+
+
+ runTests() {
+ testF45();
+ testF145();
+ testF245();
+ testF345();
+ testF445();
+ testF545();
+ testF645();
+ testF745();
+ testF845();
+ testF945();
+ testF1045();
+ testF1145();
+ testF1245();
+ testF1345();
+ testF1445();
+ testF1545();
+ testF1645();
+ testF1745();
+ testF1845();
+ testF1945();
+ }
+
+ void testF45() {
+ // int Function([List<T> x])
+ Expect.isTrue(f45 is F45);
+ Expect.isTrue(confuse(f45) is F45);
+ // In checked mode, verifies the type.
+ int Function([List<T> x]) l45;
+ // The static function f45 sets `T` to `int`.
+ if (!tIsBool) {
+ x45 = f45 as dynamic;
+ l45 = f45 as dynamic;
+ x45 = confuse(f45);
+ l45 = confuse(f45);
+ }
+
+ Expect.isTrue(m45 is F45);
+ Expect.isTrue(m45 is int Function([List<T> x]));
+ Expect.isTrue(confuse(m45) is F45);
+ // In checked mode, verifies the type.
+ x45 = m45;
+ l45 = m45;
+ x45 = confuse(m45);
+ l45 = confuse(m45);
+ if (!tIsBool) {
+ Expect.isTrue(f45 is F45<int>);
+ Expect.isFalse(f45 is F45<bool>);
+ Expect.isTrue(confuse(f45) is F45<int>);
+ Expect.isFalse(confuse(f45) is F45<bool>);
+ Expect.equals(tIsDynamic, m45 is F45<bool>);
+ Expect.equals(tIsDynamic, confuse(m45) is F45<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x45 = (f45 as dynamic); });
+ Expect.throws(() { x45 = confuse(f45); });
+ int Function([List<T> x]) l45;
+ Expect.throws(() { l45 = (f45 as dynamic); });
+ Expect.throws(() { l45 = confuse(f45); });
+ }
+ int Function([List<T> x]) l45 = m45;
+ // In checked mode, verifies the type.
+ x45 = m45;
+ x45 = confuse(m45);
+ }
+ }
+
+ void testF145() {
+ // List<Function> Function(core.List<core.int> x)
+ Expect.isTrue(f145 is F145);
+ Expect.isTrue(confuse(f145) is F145);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x) l145;
+ // The static function f145 sets `T` to `int`.
+ if (!tIsBool) {
+ x145 = f145 as dynamic;
+ l145 = f145 as dynamic;
+ x145 = confuse(f145);
+ l145 = confuse(f145);
+ }
+
+ Expect.isTrue(m145 is F145);
+ Expect.isTrue(m145 is List<Function> Function(core.List<core.int> x));
+ Expect.isTrue(confuse(m145) is F145);
+ // In checked mode, verifies the type.
+ x145 = m145;
+ l145 = m145;
+ x145 = confuse(m145);
+ l145 = confuse(m145);
+
+ }
+
+ void testF245() {
+ // List<T> Function(int y, {Function x})
+ Expect.isTrue(f245 is F245);
+ Expect.isTrue(confuse(f245) is F245);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {Function x}) l245;
+ // The static function f245 sets `T` to `int`.
+ if (!tIsBool) {
+ x245 = f245 as dynamic;
+ l245 = f245 as dynamic;
+ x245 = confuse(f245);
+ l245 = confuse(f245);
+ }
+
+ Expect.isTrue(m245 is F245);
+ Expect.isTrue(m245 is List<T> Function(int y, {Function x}));
+ Expect.isTrue(confuse(m245) is F245);
+ // In checked mode, verifies the type.
+ x245 = m245;
+ l245 = m245;
+ x245 = confuse(m245);
+ l245 = confuse(m245);
+ if (!tIsBool) {
+ Expect.isTrue(f245 is F245<int>);
+ Expect.isFalse(f245 is F245<bool>);
+ Expect.isTrue(confuse(f245) is F245<int>);
+ Expect.isFalse(confuse(f245) is F245<bool>);
+ Expect.equals(tIsDynamic, m245 is F245<bool>);
+ Expect.equals(tIsDynamic, confuse(m245) is F245<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x245 = (f245 as dynamic); });
+ Expect.throws(() { x245 = confuse(f245); });
+ List<T> Function(int y, {Function x}) l245;
+ Expect.throws(() { l245 = (f245 as dynamic); });
+ Expect.throws(() { l245 = confuse(f245); });
+ }
+ List<T> Function(int y, {Function x}) l245 = m245;
+ // In checked mode, verifies the type.
+ x245 = m245;
+ x245 = confuse(m245);
+ }
+ }
+
+ void testF345() {
+ // Function Function<A>(Function x)
+ Expect.isTrue(f345 is F345);
+ Expect.isTrue(confuse(f345) is F345);
+ // In checked mode, verifies the type.
+ Function Function<A>(Function x) l345;
+ // The static function f345 sets `T` to `int`.
+ if (!tIsBool) {
+ x345 = f345 as dynamic;
+ l345 = f345 as dynamic;
+ x345 = confuse(f345);
+ l345 = confuse(f345);
+ }
+
+ Expect.isTrue(m345 is F345);
+ Expect.isTrue(m345 is Function Function<A>(Function x));
+ Expect.isTrue(confuse(m345) is F345);
+ // In checked mode, verifies the type.
+ x345 = m345;
+ l345 = m345;
+ x345 = confuse(m345);
+ l345 = confuse(m345);
+
+ }
+
+ void testF445() {
+ // int Function(Function x) Function(int x)
+ Expect.isTrue(f445 is F445);
+ Expect.isTrue(confuse(f445) is F445);
+ // In checked mode, verifies the type.
+ int Function(Function x) Function(int x) l445;
+ // The static function f445 sets `T` to `int`.
+ if (!tIsBool) {
+ x445 = f445 as dynamic;
+ l445 = f445 as dynamic;
+ x445 = confuse(f445);
+ l445 = confuse(f445);
+ }
+
+ Expect.isTrue(m445 is F445);
+ Expect.isTrue(m445 is int Function(Function x) Function(int x));
+ Expect.isTrue(confuse(m445) is F445);
+ // In checked mode, verifies the type.
+ x445 = m445;
+ l445 = m445;
+ x445 = confuse(m445);
+ l445 = confuse(m445);
+
+ }
+
+ void testF545() {
+ // int Function(int y, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f545 is F545);
+ Expect.isTrue(confuse(f545) is F545);
+ // In checked mode, verifies the type.
+ int Function(int y, [core.List<core.int> x]) Function(int x) l545;
+ // The static function f545 sets `T` to `int`.
+ if (!tIsBool) {
+ x545 = f545 as dynamic;
+ l545 = f545 as dynamic;
+ x545 = confuse(f545);
+ l545 = confuse(f545);
+ }
+
+ Expect.isTrue(m545 is F545);
+ Expect.isTrue(m545 is int Function(int y, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m545) is F545);
+ // In checked mode, verifies the type.
+ x545 = m545;
+ l545 = m545;
+ x545 = confuse(m545);
+ l545 = confuse(m545);
+
+ }
+
+ void testF645() {
+ // Function Function([int x1]) Function(int x)
+ Expect.isTrue(f645 is F645);
+ Expect.isTrue(confuse(f645) is F645);
+ // In checked mode, verifies the type.
+ Function Function([int x1]) Function(int x) l645;
+ // The static function f645 sets `T` to `int`.
+ if (!tIsBool) {
+ x645 = f645 as dynamic;
+ l645 = f645 as dynamic;
+ x645 = confuse(f645);
+ l645 = confuse(f645);
+ }
+
+ Expect.isTrue(m645 is F645);
+ Expect.isTrue(m645 is Function Function([int x1]) Function(int x));
+ Expect.isTrue(confuse(m645) is F645);
+ // In checked mode, verifies the type.
+ x645 = m645;
+ l645 = m645;
+ x645 = confuse(m645);
+ l645 = confuse(m645);
+
+ }
+
+ void testF745() {
+ // Function Function({List<Function> x}) Function(int x)
+ Expect.isTrue(f745 is F745);
+ Expect.isTrue(confuse(f745) is F745);
+ // In checked mode, verifies the type.
+ Function Function({List<Function> x}) Function(int x) l745;
+ // The static function f745 sets `T` to `int`.
+ if (!tIsBool) {
+ x745 = f745 as dynamic;
+ l745 = f745 as dynamic;
+ x745 = confuse(f745);
+ l745 = confuse(f745);
+ }
+
+ Expect.isTrue(m745 is F745);
+ Expect.isTrue(m745 is Function Function({List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m745) is F745);
+ // In checked mode, verifies the type.
+ x745 = m745;
+ l745 = m745;
+ x745 = confuse(m745);
+ l745 = confuse(m745);
+
+ }
+
+ void testF845() {
+ // Function Function() Function(int x)
+ Expect.isTrue(f845 is F845);
+ Expect.isTrue(confuse(f845) is F845);
+ // In checked mode, verifies the type.
+ Function Function() Function(int x) l845;
+ // The static function f845 sets `T` to `int`.
+ if (!tIsBool) {
+ x845 = f845 as dynamic;
+ l845 = f845 as dynamic;
+ x845 = confuse(f845);
+ l845 = confuse(f845);
+ }
+
+ Expect.isTrue(m845 is F845);
+ Expect.isTrue(m845 is Function Function() Function(int x));
+ Expect.isTrue(confuse(m845) is F845);
+ // In checked mode, verifies the type.
+ x845 = m845;
+ l845 = m845;
+ x845 = confuse(m845);
+ l845 = confuse(m845);
+
+ }
+
+ void testF945() {
+ // List<Function> Function(int x1, [List<Function> x]) Function(int x)
+ Expect.isTrue(f945 is F945);
+ Expect.isTrue(confuse(f945) is F945);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<Function> x]) Function(int x) l945;
+ // The static function f945 sets `T` to `int`.
+ if (!tIsBool) {
+ x945 = f945 as dynamic;
+ l945 = f945 as dynamic;
+ x945 = confuse(f945);
+ l945 = confuse(f945);
+ }
+
+ Expect.isTrue(m945 is F945);
+ Expect.isTrue(m945 is List<Function> Function(int x1, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m945) is F945);
+ // In checked mode, verifies the type.
+ x945 = m945;
+ l945 = m945;
+ x945 = confuse(m945);
+ l945 = confuse(m945);
+
+ }
+
+ void testF1045() {
+ // List<Function> Function([List<T> x1]) Function(int x)
+ Expect.isTrue(f1045 is F1045);
+ Expect.isTrue(confuse(f1045) is F1045);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x1]) Function(int x) l1045;
+ // The static function f1045 sets `T` to `int`.
+ if (!tIsBool) {
+ x1045 = f1045 as dynamic;
+ l1045 = f1045 as dynamic;
+ x1045 = confuse(f1045);
+ l1045 = confuse(f1045);
+ }
+
+ Expect.isTrue(m1045 is F1045);
+ Expect.isTrue(m1045 is List<Function> Function([List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1045) is F1045);
+ // In checked mode, verifies the type.
+ x1045 = m1045;
+ l1045 = m1045;
+ x1045 = confuse(m1045);
+ l1045 = confuse(m1045);
+ if (!tIsBool) {
+ Expect.isTrue(f1045 is F1045<int>);
+ Expect.isFalse(f1045 is F1045<bool>);
+ Expect.isTrue(confuse(f1045) is F1045<int>);
+ Expect.isFalse(confuse(f1045) is F1045<bool>);
+ Expect.equals(tIsDynamic, m1045 is F1045<bool>);
+ Expect.equals(tIsDynamic, confuse(m1045) is F1045<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1045 = (f1045 as dynamic); });
+ Expect.throws(() { x1045 = confuse(f1045); });
+ List<Function> Function([List<T> x1]) Function(int x) l1045;
+ Expect.throws(() { l1045 = (f1045 as dynamic); });
+ Expect.throws(() { l1045 = confuse(f1045); });
+ }
+ List<Function> Function([List<T> x1]) Function(int x) l1045 = m1045;
+ // In checked mode, verifies the type.
+ x1045 = m1045;
+ x1045 = confuse(m1045);
+ }
+ }
+
+ void testF1145() {
+ // core.List<core.int> Function(int x, [Function x1]) Function(int x)
+ Expect.isTrue(f1145 is F1145);
+ Expect.isTrue(confuse(f1145) is F1145);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [Function x1]) Function(int x) l1145;
+ // The static function f1145 sets `T` to `int`.
+ if (!tIsBool) {
+ x1145 = f1145 as dynamic;
+ l1145 = f1145 as dynamic;
+ x1145 = confuse(f1145);
+ l1145 = confuse(f1145);
+ }
+
+ Expect.isTrue(m1145 is F1145);
+ Expect.isTrue(m1145 is core.List<core.int> Function(int x, [Function x1]) Function(int x));
+ Expect.isTrue(confuse(m1145) is F1145);
+ // In checked mode, verifies the type.
+ x1145 = m1145;
+ l1145 = m1145;
+ x1145 = confuse(m1145);
+ l1145 = confuse(m1145);
+
+ }
+
+ void testF1245() {
+ // core.List<core.int> Function(int y, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1245 is F1245);
+ Expect.isTrue(confuse(f1245) is F1245);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function(int x) l1245;
+ // The static function f1245 sets `T` to `int`.
+ if (!tIsBool) {
+ x1245 = f1245 as dynamic;
+ l1245 = f1245 as dynamic;
+ x1245 = confuse(f1245);
+ l1245 = confuse(f1245);
+ }
+
+ Expect.isTrue(m1245 is F1245);
+ Expect.isTrue(m1245 is core.List<core.int> Function(int y, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1245) is F1245);
+ // In checked mode, verifies the type.
+ x1245 = m1245;
+ l1245 = m1245;
+ x1245 = confuse(m1245);
+ l1245 = confuse(m1245);
+
+ }
+
+ void testF1345() {
+ // List<T> Function([Function x]) Function(int x)
+ Expect.isTrue(f1345 is F1345);
+ Expect.isTrue(confuse(f1345) is F1345);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x]) Function(int x) l1345;
+ // The static function f1345 sets `T` to `int`.
+ if (!tIsBool) {
+ x1345 = f1345 as dynamic;
+ l1345 = f1345 as dynamic;
+ x1345 = confuse(f1345);
+ l1345 = confuse(f1345);
+ }
+
+ Expect.isTrue(m1345 is F1345);
+ Expect.isTrue(m1345 is List<T> Function([Function x]) Function(int x));
+ Expect.isTrue(confuse(m1345) is F1345);
+ // In checked mode, verifies the type.
+ x1345 = m1345;
+ l1345 = m1345;
+ x1345 = confuse(m1345);
+ l1345 = confuse(m1345);
+ if (!tIsBool) {
+ Expect.isTrue(f1345 is F1345<int>);
+ Expect.isFalse(f1345 is F1345<bool>);
+ Expect.isTrue(confuse(f1345) is F1345<int>);
+ Expect.isFalse(confuse(f1345) is F1345<bool>);
+ Expect.equals(tIsDynamic, m1345 is F1345<bool>);
+ Expect.equals(tIsDynamic, confuse(m1345) is F1345<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1345 = (f1345 as dynamic); });
+ Expect.throws(() { x1345 = confuse(f1345); });
+ List<T> Function([Function x]) Function(int x) l1345;
+ Expect.throws(() { l1345 = (f1345 as dynamic); });
+ Expect.throws(() { l1345 = confuse(f1345); });
+ }
+ List<T> Function([Function x]) Function(int x) l1345 = m1345;
+ // In checked mode, verifies the type.
+ x1345 = m1345;
+ x1345 = confuse(m1345);
+ }
+ }
+
+ void testF1445() {
+ // List<T> Function(core.List<core.int> x1) Function(int x)
+ Expect.isTrue(f1445 is F1445);
+ Expect.isTrue(confuse(f1445) is F1445);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x1) Function(int x) l1445;
+ // The static function f1445 sets `T` to `int`.
+ if (!tIsBool) {
+ x1445 = f1445 as dynamic;
+ l1445 = f1445 as dynamic;
+ x1445 = confuse(f1445);
+ l1445 = confuse(f1445);
+ }
+
+ Expect.isTrue(m1445 is F1445);
+ Expect.isTrue(m1445 is List<T> Function(core.List<core.int> x1) Function(int x));
+ Expect.isTrue(confuse(m1445) is F1445);
+ // In checked mode, verifies the type.
+ x1445 = m1445;
+ l1445 = m1445;
+ x1445 = confuse(m1445);
+ l1445 = confuse(m1445);
+ if (!tIsBool) {
+ Expect.isTrue(f1445 is F1445<int>);
+ Expect.isFalse(f1445 is F1445<bool>);
+ Expect.isTrue(confuse(f1445) is F1445<int>);
+ Expect.isFalse(confuse(f1445) is F1445<bool>);
+ Expect.equals(tIsDynamic, m1445 is F1445<bool>);
+ Expect.equals(tIsDynamic, confuse(m1445) is F1445<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1445 = (f1445 as dynamic); });
+ Expect.throws(() { x1445 = confuse(f1445); });
+ List<T> Function(core.List<core.int> x1) Function(int x) l1445;
+ Expect.throws(() { l1445 = (f1445 as dynamic); });
+ Expect.throws(() { l1445 = confuse(f1445); });
+ }
+ List<T> Function(core.List<core.int> x1) Function(int x) l1445 = m1445;
+ // In checked mode, verifies the type.
+ x1445 = m1445;
+ x1445 = confuse(m1445);
+ }
+ }
+
+ void testF1545() {
+ // Function(int x2, [int x3]) Function(int x)
+ Expect.isTrue(f1545 is F1545);
+ Expect.isTrue(confuse(f1545) is F1545);
+ // In checked mode, verifies the type.
+ Function(int x2, [int x3]) Function(int x) l1545;
+ // The static function f1545 sets `T` to `int`.
+ if (!tIsBool) {
+ x1545 = f1545 as dynamic;
+ l1545 = f1545 as dynamic;
+ x1545 = confuse(f1545);
+ l1545 = confuse(f1545);
+ }
+
+ Expect.isTrue(m1545 is F1545);
+ Expect.isTrue(m1545 is Function(int x2, [int x3]) Function(int x));
+ Expect.isTrue(confuse(m1545) is F1545);
+ // In checked mode, verifies the type.
+ x1545 = m1545;
+ l1545 = m1545;
+ x1545 = confuse(m1545);
+ l1545 = confuse(m1545);
+
+ }
+
+ void testF1645() {
+ // Function(int x1, {List<Function> x}) Function(int x)
+ Expect.isTrue(f1645 is F1645);
+ Expect.isTrue(confuse(f1645) is F1645);
+ // In checked mode, verifies the type.
+ Function(int x1, {List<Function> x}) Function(int x) l1645;
+ // The static function f1645 sets `T` to `int`.
+ if (!tIsBool) {
+ x1645 = f1645 as dynamic;
+ l1645 = f1645 as dynamic;
+ x1645 = confuse(f1645);
+ l1645 = confuse(f1645);
+ }
+
+ Expect.isTrue(m1645 is F1645);
+ Expect.isTrue(m1645 is Function(int x1, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1645) is F1645);
+ // In checked mode, verifies the type.
+ x1645 = m1645;
+ l1645 = m1645;
+ x1645 = confuse(m1645);
+ l1645 = confuse(m1645);
+
+ }
+
+ void testF1745() {
+ // int Function<A>(int x) Function(int x)
+ Expect.isTrue(f1745 is F1745);
+ Expect.isTrue(confuse(f1745) is F1745);
+ // In checked mode, verifies the type.
+ int Function<A>(int x) Function(int x) l1745;
+ // The static function f1745 sets `T` to `int`.
+ if (!tIsBool) {
+ x1745 = f1745 as dynamic;
+ l1745 = f1745 as dynamic;
+ x1745 = confuse(f1745);
+ l1745 = confuse(f1745);
+ }
+
+ Expect.isTrue(m1745 is F1745);
+ Expect.isTrue(m1745 is int Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1745) is F1745);
+ // In checked mode, verifies the type.
+ x1745 = m1745;
+ l1745 = m1745;
+ x1745 = confuse(m1745);
+ l1745 = confuse(m1745);
+
+ }
+
+ void testF1845() {
+ // core.List<core.int> Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1845 is F1845);
+ Expect.isTrue(confuse(f1845) is F1845);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(Function x) Function(int x) l1845;
+ // The static function f1845 sets `T` to `int`.
+ if (!tIsBool) {
+ x1845 = f1845 as dynamic;
+ l1845 = f1845 as dynamic;
+ x1845 = confuse(f1845);
+ l1845 = confuse(f1845);
+ }
+
+ Expect.isTrue(m1845 is F1845);
+ Expect.isTrue(m1845 is core.List<core.int> Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1845) is F1845);
+ // In checked mode, verifies the type.
+ x1845 = m1845;
+ l1845 = m1845;
+ x1845 = confuse(m1845);
+ l1845 = confuse(m1845);
+
+ }
+
+ void testF1945() {
+ // A Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1945 is F1945);
+ Expect.isTrue(confuse(f1945) is F1945);
+ // In checked mode, verifies the type.
+ A Function<A>(List<Function> x) Function(int x) l1945;
+ // The static function f1945 sets `T` to `int`.
+ if (!tIsBool) {
+ x1945 = f1945 as dynamic;
+ l1945 = f1945 as dynamic;
+ x1945 = confuse(f1945);
+ l1945 = confuse(f1945);
+ }
+
+ Expect.isTrue(m1945 is F1945);
+ Expect.isTrue(m1945 is A Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1945) is F1945);
+ // In checked mode, verifies the type.
+ x1945 = m1945;
+ l1945 = m1945;
+ x1945 = confuse(m1945);
+ l1945 = confuse(m1945);
+
+ }
+
+
+}
+
+class C46<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, [List<T> x]) x46;
+ List<Function> Function([core.List<core.int> x]) x146;
+ List<T> Function(List<Function> x) x246;
+ Function Function<A>(List<Function> x) x346;
+ int Function(Function x) Function<B extends core.int>() x446;
+ int Function(int y, [core.List<core.int> x]) Function<B extends core.int>() x546;
+ Function Function([int x1]) Function<B extends core.int>() x646;
+ Function Function({List<Function> x}) Function<B extends core.int>() x746;
+ Function Function() Function<B extends core.int>() x846;
+ List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>() x946;
+ List<Function> Function([List<T> x1]) Function<B extends core.int>() x1046;
+ core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>() x1146;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() x1246;
+ List<T> Function([Function x]) Function<B extends core.int>() x1346;
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>() x1446;
+ Function(int x2, [int x3]) Function<B extends core.int>() x1546;
+ Function(int x1, {List<Function> x}) Function<B extends core.int>() x1646;
+ int Function<A>(int x) Function<B extends core.int>() x1746;
+ core.List<core.int> Function<A>(Function x) Function<B extends core.int>() x1846;
+ A Function<A>(List<Function> x) Function<B extends core.int>() x1946;
+
+
+ C46({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m46(int x0, [List<T> x]) => null;
+ List<Function> m146([core.List<core.int> x]) => null;
+ List<T> m246(List<Function> x) => null;
+ Function m346<A>(List<Function> x) => null;
+ int Function(Function x) m446<B extends core.int>() => null;
+ int Function(int y, [core.List<core.int> x]) m546<B extends core.int>() => null;
+ Function Function([int x0]) m646<B extends core.int>() => null;
+ Function Function({List<Function> x}) m746<B extends core.int>() => null;
+ Function Function() m846<B extends core.int>() => null;
+ List<Function> Function(int x0, [List<Function> x]) m946<B extends core.int>() => null;
+ List<Function> Function([List<T> x0]) m1046<B extends core.int>() => null;
+ core.List<core.int> Function(int x, [Function x0]) m1146<B extends core.int>() => null;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) m1246<B extends core.int>() => null;
+ List<T> Function([Function x]) m1346<B extends core.int>() => null;
+ List<T> Function(core.List<core.int> x0) m1446<B extends core.int>() => null;
+ Function(int x0, [int x1]) m1546<B extends core.int>() => null;
+ Function(int x0, {List<Function> x}) m1646<B extends core.int>() => null;
+ int Function<A>(int x) m1746<B extends core.int>() => null;
+ core.List<core.int> Function<A>(Function x) m1846<B extends core.int>() => null;
+ A Function<A>(List<Function> x) m1946<B extends core.int>() => null;
+
+
+ runTests() {
+ testF46();
+ testF146();
+ testF246();
+ testF346();
+ testF446();
+ testF546();
+ testF646();
+ testF746();
+ testF846();
+ testF946();
+ testF1046();
+ testF1146();
+ testF1246();
+ testF1346();
+ testF1446();
+ testF1546();
+ testF1646();
+ testF1746();
+ testF1846();
+ testF1946();
+ }
+
+ void testF46() {
+ // int Function(int x0, [List<T> x])
+ Expect.isTrue(f46 is F46);
+ Expect.isTrue(confuse(f46) is F46);
+ // In checked mode, verifies the type.
+ int Function(int x0, [List<T> x]) l46;
+ // The static function f46 sets `T` to `int`.
+ if (!tIsBool) {
+ x46 = f46 as dynamic;
+ l46 = f46 as dynamic;
+ x46 = confuse(f46);
+ l46 = confuse(f46);
+ }
+
+ Expect.isTrue(m46 is F46);
+ Expect.isTrue(m46 is int Function(int x0, [List<T> x]));
+ Expect.isTrue(confuse(m46) is F46);
+ // In checked mode, verifies the type.
+ x46 = m46;
+ l46 = m46;
+ x46 = confuse(m46);
+ l46 = confuse(m46);
+ if (!tIsBool) {
+ Expect.isTrue(f46 is F46<int>);
+ Expect.isFalse(f46 is F46<bool>);
+ Expect.isTrue(confuse(f46) is F46<int>);
+ Expect.isFalse(confuse(f46) is F46<bool>);
+ Expect.equals(tIsDynamic, m46 is F46<bool>);
+ Expect.equals(tIsDynamic, confuse(m46) is F46<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x46 = (f46 as dynamic); });
+ Expect.throws(() { x46 = confuse(f46); });
+ int Function(int x0, [List<T> x]) l46;
+ Expect.throws(() { l46 = (f46 as dynamic); });
+ Expect.throws(() { l46 = confuse(f46); });
+ }
+ int Function(int x0, [List<T> x]) l46 = m46;
+ // In checked mode, verifies the type.
+ x46 = m46;
+ x46 = confuse(m46);
+ }
+ }
+
+ void testF146() {
+ // List<Function> Function([core.List<core.int> x])
+ Expect.isTrue(f146 is F146);
+ Expect.isTrue(confuse(f146) is F146);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x]) l146;
+ // The static function f146 sets `T` to `int`.
+ if (!tIsBool) {
+ x146 = f146 as dynamic;
+ l146 = f146 as dynamic;
+ x146 = confuse(f146);
+ l146 = confuse(f146);
+ }
+
+ Expect.isTrue(m146 is F146);
+ Expect.isTrue(m146 is List<Function> Function([core.List<core.int> x]));
+ Expect.isTrue(confuse(m146) is F146);
+ // In checked mode, verifies the type.
+ x146 = m146;
+ l146 = m146;
+ x146 = confuse(m146);
+ l146 = confuse(m146);
+
+ }
+
+ void testF246() {
+ // List<T> Function(List<Function> x)
+ Expect.isTrue(f246 is F246);
+ Expect.isTrue(confuse(f246) is F246);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x) l246;
+ // The static function f246 sets `T` to `int`.
+ if (!tIsBool) {
+ x246 = f246 as dynamic;
+ l246 = f246 as dynamic;
+ x246 = confuse(f246);
+ l246 = confuse(f246);
+ }
+
+ Expect.isTrue(m246 is F246);
+ Expect.isTrue(m246 is List<T> Function(List<Function> x));
+ Expect.isTrue(confuse(m246) is F246);
+ // In checked mode, verifies the type.
+ x246 = m246;
+ l246 = m246;
+ x246 = confuse(m246);
+ l246 = confuse(m246);
+ if (!tIsBool) {
+ Expect.isTrue(f246 is F246<int>);
+ Expect.isFalse(f246 is F246<bool>);
+ Expect.isTrue(confuse(f246) is F246<int>);
+ Expect.isFalse(confuse(f246) is F246<bool>);
+ Expect.equals(tIsDynamic, m246 is F246<bool>);
+ Expect.equals(tIsDynamic, confuse(m246) is F246<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x246 = (f246 as dynamic); });
+ Expect.throws(() { x246 = confuse(f246); });
+ List<T> Function(List<Function> x) l246;
+ Expect.throws(() { l246 = (f246 as dynamic); });
+ Expect.throws(() { l246 = confuse(f246); });
+ }
+ List<T> Function(List<Function> x) l246 = m246;
+ // In checked mode, verifies the type.
+ x246 = m246;
+ x246 = confuse(m246);
+ }
+ }
+
+ void testF346() {
+ // Function Function<A>(List<Function> x)
+ Expect.isTrue(f346 is F346);
+ Expect.isTrue(confuse(f346) is F346);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<Function> x) l346;
+ // The static function f346 sets `T` to `int`.
+ if (!tIsBool) {
+ x346 = f346 as dynamic;
+ l346 = f346 as dynamic;
+ x346 = confuse(f346);
+ l346 = confuse(f346);
+ }
+
+ Expect.isTrue(m346 is F346);
+ Expect.isTrue(m346 is Function Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m346) is F346);
+ // In checked mode, verifies the type.
+ x346 = m346;
+ l346 = m346;
+ x346 = confuse(m346);
+ l346 = confuse(m346);
+
+ }
+
+ void testF446() {
+ // int Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f446 is F446);
+ Expect.isTrue(confuse(f446) is F446);
+ // In checked mode, verifies the type.
+ int Function(Function x) Function<B extends core.int>() l446;
+ // The static function f446 sets `T` to `int`.
+ if (!tIsBool) {
+ x446 = f446 as dynamic;
+ l446 = f446 as dynamic;
+ x446 = confuse(f446);
+ l446 = confuse(f446);
+ }
+
+ Expect.isTrue(m446 is F446);
+ Expect.isTrue(m446 is int Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m446) is F446);
+ // In checked mode, verifies the type.
+ x446 = m446;
+ l446 = m446;
+ x446 = confuse(m446);
+ l446 = confuse(m446);
+
+ }
+
+ void testF546() {
+ // int Function(int y, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f546 is F546);
+ Expect.isTrue(confuse(f546) is F546);
+ // In checked mode, verifies the type.
+ int Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l546;
+ // The static function f546 sets `T` to `int`.
+ if (!tIsBool) {
+ x546 = f546 as dynamic;
+ l546 = f546 as dynamic;
+ x546 = confuse(f546);
+ l546 = confuse(f546);
+ }
+
+ Expect.isTrue(m546 is F546);
+ Expect.isTrue(m546 is int Function(int y, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m546) is F546);
+ // In checked mode, verifies the type.
+ x546 = m546;
+ l546 = m546;
+ x546 = confuse(m546);
+ l546 = confuse(m546);
+
+ }
+
+ void testF646() {
+ // Function Function([int x1]) Function<B extends core.int>()
+ Expect.isTrue(f646 is F646);
+ Expect.isTrue(confuse(f646) is F646);
+ // In checked mode, verifies the type.
+ Function Function([int x1]) Function<B extends core.int>() l646;
+ // The static function f646 sets `T` to `int`.
+ if (!tIsBool) {
+ x646 = f646 as dynamic;
+ l646 = f646 as dynamic;
+ x646 = confuse(f646);
+ l646 = confuse(f646);
+ }
+
+ Expect.isTrue(m646 is F646);
+ Expect.isTrue(m646 is Function Function([int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m646) is F646);
+ // In checked mode, verifies the type.
+ x646 = m646;
+ l646 = m646;
+ x646 = confuse(m646);
+ l646 = confuse(m646);
+
+ }
+
+ void testF746() {
+ // Function Function({List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f746 is F746);
+ Expect.isTrue(confuse(f746) is F746);
+ // In checked mode, verifies the type.
+ Function Function({List<Function> x}) Function<B extends core.int>() l746;
+ // The static function f746 sets `T` to `int`.
+ if (!tIsBool) {
+ x746 = f746 as dynamic;
+ l746 = f746 as dynamic;
+ x746 = confuse(f746);
+ l746 = confuse(f746);
+ }
+
+ Expect.isTrue(m746 is F746);
+ Expect.isTrue(m746 is Function Function({List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m746) is F746);
+ // In checked mode, verifies the type.
+ x746 = m746;
+ l746 = m746;
+ x746 = confuse(m746);
+ l746 = confuse(m746);
+
+ }
+
+ void testF846() {
+ // Function Function() Function<B extends core.int>()
+ Expect.isTrue(f846 is F846);
+ Expect.isTrue(confuse(f846) is F846);
+ // In checked mode, verifies the type.
+ Function Function() Function<B extends core.int>() l846;
+ // The static function f846 sets `T` to `int`.
+ if (!tIsBool) {
+ x846 = f846 as dynamic;
+ l846 = f846 as dynamic;
+ x846 = confuse(f846);
+ l846 = confuse(f846);
+ }
+
+ Expect.isTrue(m846 is F846);
+ Expect.isTrue(m846 is Function Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m846) is F846);
+ // In checked mode, verifies the type.
+ x846 = m846;
+ l846 = m846;
+ x846 = confuse(m846);
+ l846 = confuse(m846);
+
+ }
+
+ void testF946() {
+ // List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f946 is F946);
+ Expect.isTrue(confuse(f946) is F946);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>() l946;
+ // The static function f946 sets `T` to `int`.
+ if (!tIsBool) {
+ x946 = f946 as dynamic;
+ l946 = f946 as dynamic;
+ x946 = confuse(f946);
+ l946 = confuse(f946);
+ }
+
+ Expect.isTrue(m946 is F946);
+ Expect.isTrue(m946 is List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m946) is F946);
+ // In checked mode, verifies the type.
+ x946 = m946;
+ l946 = m946;
+ x946 = confuse(m946);
+ l946 = confuse(m946);
+
+ }
+
+ void testF1046() {
+ // List<Function> Function([List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1046 is F1046);
+ Expect.isTrue(confuse(f1046) is F1046);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x1]) Function<B extends core.int>() l1046;
+ // The static function f1046 sets `T` to `int`.
+ if (!tIsBool) {
+ x1046 = f1046 as dynamic;
+ l1046 = f1046 as dynamic;
+ x1046 = confuse(f1046);
+ l1046 = confuse(f1046);
+ }
+
+ Expect.isTrue(m1046 is F1046);
+ Expect.isTrue(m1046 is List<Function> Function([List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1046) is F1046);
+ // In checked mode, verifies the type.
+ x1046 = m1046;
+ l1046 = m1046;
+ x1046 = confuse(m1046);
+ l1046 = confuse(m1046);
+ if (!tIsBool) {
+ Expect.isTrue(f1046 is F1046<int>);
+ Expect.isFalse(f1046 is F1046<bool>);
+ Expect.isTrue(confuse(f1046) is F1046<int>);
+ Expect.isFalse(confuse(f1046) is F1046<bool>);
+ Expect.equals(tIsDynamic, m1046 is F1046<bool>);
+ Expect.equals(tIsDynamic, confuse(m1046) is F1046<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1046 = (f1046 as dynamic); });
+ Expect.throws(() { x1046 = confuse(f1046); });
+ List<Function> Function([List<T> x1]) Function<B extends core.int>() l1046;
+ Expect.throws(() { l1046 = (f1046 as dynamic); });
+ Expect.throws(() { l1046 = confuse(f1046); });
+ }
+ List<Function> Function([List<T> x1]) Function<B extends core.int>() l1046 = m1046;
+ // In checked mode, verifies the type.
+ x1046 = m1046;
+ x1046 = confuse(m1046);
+ }
+ }
+
+ void testF1146() {
+ // core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f1146 is F1146);
+ Expect.isTrue(confuse(f1146) is F1146);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>() l1146;
+ // The static function f1146 sets `T` to `int`.
+ if (!tIsBool) {
+ x1146 = f1146 as dynamic;
+ l1146 = f1146 as dynamic;
+ x1146 = confuse(f1146);
+ l1146 = confuse(f1146);
+ }
+
+ Expect.isTrue(m1146 is F1146);
+ Expect.isTrue(m1146 is core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1146) is F1146);
+ // In checked mode, verifies the type.
+ x1146 = m1146;
+ l1146 = m1146;
+ x1146 = confuse(m1146);
+ l1146 = confuse(m1146);
+
+ }
+
+ void testF1246() {
+ // core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1246 is F1246);
+ Expect.isTrue(confuse(f1246) is F1246);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l1246;
+ // The static function f1246 sets `T` to `int`.
+ if (!tIsBool) {
+ x1246 = f1246 as dynamic;
+ l1246 = f1246 as dynamic;
+ x1246 = confuse(f1246);
+ l1246 = confuse(f1246);
+ }
+
+ Expect.isTrue(m1246 is F1246);
+ Expect.isTrue(m1246 is core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1246) is F1246);
+ // In checked mode, verifies the type.
+ x1246 = m1246;
+ l1246 = m1246;
+ x1246 = confuse(m1246);
+ l1246 = confuse(m1246);
+
+ }
+
+ void testF1346() {
+ // List<T> Function([Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1346 is F1346);
+ Expect.isTrue(confuse(f1346) is F1346);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x]) Function<B extends core.int>() l1346;
+ // The static function f1346 sets `T` to `int`.
+ if (!tIsBool) {
+ x1346 = f1346 as dynamic;
+ l1346 = f1346 as dynamic;
+ x1346 = confuse(f1346);
+ l1346 = confuse(f1346);
+ }
+
+ Expect.isTrue(m1346 is F1346);
+ Expect.isTrue(m1346 is List<T> Function([Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1346) is F1346);
+ // In checked mode, verifies the type.
+ x1346 = m1346;
+ l1346 = m1346;
+ x1346 = confuse(m1346);
+ l1346 = confuse(m1346);
+ if (!tIsBool) {
+ Expect.isTrue(f1346 is F1346<int>);
+ Expect.isFalse(f1346 is F1346<bool>);
+ Expect.isTrue(confuse(f1346) is F1346<int>);
+ Expect.isFalse(confuse(f1346) is F1346<bool>);
+ Expect.equals(tIsDynamic, m1346 is F1346<bool>);
+ Expect.equals(tIsDynamic, confuse(m1346) is F1346<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1346 = (f1346 as dynamic); });
+ Expect.throws(() { x1346 = confuse(f1346); });
+ List<T> Function([Function x]) Function<B extends core.int>() l1346;
+ Expect.throws(() { l1346 = (f1346 as dynamic); });
+ Expect.throws(() { l1346 = confuse(f1346); });
+ }
+ List<T> Function([Function x]) Function<B extends core.int>() l1346 = m1346;
+ // In checked mode, verifies the type.
+ x1346 = m1346;
+ x1346 = confuse(m1346);
+ }
+ }
+
+ void testF1446() {
+ // List<T> Function(core.List<core.int> x1) Function<B extends core.int>()
+ Expect.isTrue(f1446 is F1446);
+ Expect.isTrue(confuse(f1446) is F1446);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>() l1446;
+ // The static function f1446 sets `T` to `int`.
+ if (!tIsBool) {
+ x1446 = f1446 as dynamic;
+ l1446 = f1446 as dynamic;
+ x1446 = confuse(f1446);
+ l1446 = confuse(f1446);
+ }
+
+ Expect.isTrue(m1446 is F1446);
+ Expect.isTrue(m1446 is List<T> Function(core.List<core.int> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1446) is F1446);
+ // In checked mode, verifies the type.
+ x1446 = m1446;
+ l1446 = m1446;
+ x1446 = confuse(m1446);
+ l1446 = confuse(m1446);
+ if (!tIsBool) {
+ Expect.isTrue(f1446 is F1446<int>);
+ Expect.isFalse(f1446 is F1446<bool>);
+ Expect.isTrue(confuse(f1446) is F1446<int>);
+ Expect.isFalse(confuse(f1446) is F1446<bool>);
+ Expect.equals(tIsDynamic, m1446 is F1446<bool>);
+ Expect.equals(tIsDynamic, confuse(m1446) is F1446<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1446 = (f1446 as dynamic); });
+ Expect.throws(() { x1446 = confuse(f1446); });
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>() l1446;
+ Expect.throws(() { l1446 = (f1446 as dynamic); });
+ Expect.throws(() { l1446 = confuse(f1446); });
+ }
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>() l1446 = m1446;
+ // In checked mode, verifies the type.
+ x1446 = m1446;
+ x1446 = confuse(m1446);
+ }
+ }
+
+ void testF1546() {
+ // Function(int x2, [int x3]) Function<B extends core.int>()
+ Expect.isTrue(f1546 is F1546);
+ Expect.isTrue(confuse(f1546) is F1546);
+ // In checked mode, verifies the type.
+ Function(int x2, [int x3]) Function<B extends core.int>() l1546;
+ // The static function f1546 sets `T` to `int`.
+ if (!tIsBool) {
+ x1546 = f1546 as dynamic;
+ l1546 = f1546 as dynamic;
+ x1546 = confuse(f1546);
+ l1546 = confuse(f1546);
+ }
+
+ Expect.isTrue(m1546 is F1546);
+ Expect.isTrue(m1546 is Function(int x2, [int x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1546) is F1546);
+ // In checked mode, verifies the type.
+ x1546 = m1546;
+ l1546 = m1546;
+ x1546 = confuse(m1546);
+ l1546 = confuse(m1546);
+
+ }
+
+ void testF1646() {
+ // Function(int x1, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1646 is F1646);
+ Expect.isTrue(confuse(f1646) is F1646);
+ // In checked mode, verifies the type.
+ Function(int x1, {List<Function> x}) Function<B extends core.int>() l1646;
+ // The static function f1646 sets `T` to `int`.
+ if (!tIsBool) {
+ x1646 = f1646 as dynamic;
+ l1646 = f1646 as dynamic;
+ x1646 = confuse(f1646);
+ l1646 = confuse(f1646);
+ }
+
+ Expect.isTrue(m1646 is F1646);
+ Expect.isTrue(m1646 is Function(int x1, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1646) is F1646);
+ // In checked mode, verifies the type.
+ x1646 = m1646;
+ l1646 = m1646;
+ x1646 = confuse(m1646);
+ l1646 = confuse(m1646);
+
+ }
+
+ void testF1746() {
+ // int Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1746 is F1746);
+ Expect.isTrue(confuse(f1746) is F1746);
+ // In checked mode, verifies the type.
+ int Function<A>(int x) Function<B extends core.int>() l1746;
+ // The static function f1746 sets `T` to `int`.
+ if (!tIsBool) {
+ x1746 = f1746 as dynamic;
+ l1746 = f1746 as dynamic;
+ x1746 = confuse(f1746);
+ l1746 = confuse(f1746);
+ }
+
+ Expect.isTrue(m1746 is F1746);
+ Expect.isTrue(m1746 is int Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1746) is F1746);
+ // In checked mode, verifies the type.
+ x1746 = m1746;
+ l1746 = m1746;
+ x1746 = confuse(m1746);
+ l1746 = confuse(m1746);
+
+ }
+
+ void testF1846() {
+ // core.List<core.int> Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1846 is F1846);
+ Expect.isTrue(confuse(f1846) is F1846);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(Function x) Function<B extends core.int>() l1846;
+ // The static function f1846 sets `T` to `int`.
+ if (!tIsBool) {
+ x1846 = f1846 as dynamic;
+ l1846 = f1846 as dynamic;
+ x1846 = confuse(f1846);
+ l1846 = confuse(f1846);
+ }
+
+ Expect.isTrue(m1846 is F1846);
+ Expect.isTrue(m1846 is core.List<core.int> Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1846) is F1846);
+ // In checked mode, verifies the type.
+ x1846 = m1846;
+ l1846 = m1846;
+ x1846 = confuse(m1846);
+ l1846 = confuse(m1846);
+
+ }
+
+ void testF1946() {
+ // A Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1946 is F1946);
+ Expect.isTrue(confuse(f1946) is F1946);
+ // In checked mode, verifies the type.
+ A Function<A>(List<Function> x) Function<B extends core.int>() l1946;
+ // The static function f1946 sets `T` to `int`.
+ if (!tIsBool) {
+ x1946 = f1946 as dynamic;
+ l1946 = f1946 as dynamic;
+ x1946 = confuse(f1946);
+ l1946 = confuse(f1946);
+ }
+
+ Expect.isTrue(m1946 is F1946);
+ Expect.isTrue(m1946 is A Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1946) is F1946);
+ // In checked mode, verifies the type.
+ x1946 = m1946;
+ l1946 = m1946;
+ x1946 = confuse(m1946);
+ l1946 = confuse(m1946);
+
+ }
+
+
+}
+
+class C47<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, [List<T> x]) x47;
+ List<Function> Function(int x0, [core.List<core.int> x]) x147;
+ List<T> Function([List<Function> x]) x247;
+ Function Function<A>(core.List<core.int> x) x347;
+ int Function(Function x) Function<B extends core.int>(int x) x447;
+ int Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) x547;
+ Function Function([int x1]) Function<B extends core.int>(int x) x647;
+ Function Function({List<Function> x}) Function<B extends core.int>(int x) x747;
+ Function Function() Function<B extends core.int>(int x) x847;
+ List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) x947;
+ List<Function> Function([List<T> x1]) Function<B extends core.int>(int x) x1047;
+ core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>(int x) x1147;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) x1247;
+ List<T> Function([Function x]) Function<B extends core.int>(int x) x1347;
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x) x1447;
+ Function(int x2, [int x3]) Function<B extends core.int>(int x) x1547;
+ Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) x1647;
+ int Function<A>(int x) Function<B extends core.int>(int x) x1747;
+ core.List<core.int> Function<A>(Function x) Function<B extends core.int>(int x) x1847;
+ A Function<A>(List<Function> x) Function<B extends core.int>(int x) x1947;
+
+
+ C47({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m47(int y, [List<T> x]) => null;
+ List<Function> m147(int x0, [core.List<core.int> x]) => null;
+ List<T> m247([List<Function> x]) => null;
+ Function m347<A>(core.List<core.int> x) => null;
+ int Function(Function x) m447<B extends core.int>(int x) => null;
+ int Function(int y, [core.List<core.int> x]) m547<B extends core.int>(int x) => null;
+ Function Function([int x0]) m647<B extends core.int>(int x) => null;
+ Function Function({List<Function> x}) m747<B extends core.int>(int x) => null;
+ Function Function() m847<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [List<Function> x]) m947<B extends core.int>(int x) => null;
+ List<Function> Function([List<T> x0]) m1047<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x, [Function x0]) m1147<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, {core.List<core.int> x}) m1247<B extends core.int>(int x) => null;
+ List<T> Function([Function x]) m1347<B extends core.int>(int x) => null;
+ List<T> Function(core.List<core.int> x0) m1447<B extends core.int>(int x) => null;
+ Function(int x0, [int x1]) m1547<B extends core.int>(int x) => null;
+ Function(int x0, {List<Function> x}) m1647<B extends core.int>(int x) => null;
+ int Function<A>(int x) m1747<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(Function x) m1847<B extends core.int>(int x) => null;
+ A Function<A>(List<Function> x) m1947<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF47();
+ testF147();
+ testF247();
+ testF347();
+ testF447();
+ testF547();
+ testF647();
+ testF747();
+ testF847();
+ testF947();
+ testF1047();
+ testF1147();
+ testF1247();
+ testF1347();
+ testF1447();
+ testF1547();
+ testF1647();
+ testF1747();
+ testF1847();
+ testF1947();
+ }
+
+ void testF47() {
+ // int Function(int y, [List<T> x])
+ Expect.isTrue(f47 is F47);
+ Expect.isTrue(confuse(f47) is F47);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<T> x]) l47;
+ // The static function f47 sets `T` to `int`.
+ if (!tIsBool) {
+ x47 = f47 as dynamic;
+ l47 = f47 as dynamic;
+ x47 = confuse(f47);
+ l47 = confuse(f47);
+ }
+
+ Expect.isTrue(m47 is F47);
+ Expect.isTrue(m47 is int Function(int y, [List<T> x]));
+ Expect.isTrue(confuse(m47) is F47);
+ // In checked mode, verifies the type.
+ x47 = m47;
+ l47 = m47;
+ x47 = confuse(m47);
+ l47 = confuse(m47);
+ if (!tIsBool) {
+ Expect.isTrue(f47 is F47<int>);
+ Expect.isFalse(f47 is F47<bool>);
+ Expect.isTrue(confuse(f47) is F47<int>);
+ Expect.isFalse(confuse(f47) is F47<bool>);
+ Expect.equals(tIsDynamic, m47 is F47<bool>);
+ Expect.equals(tIsDynamic, confuse(m47) is F47<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x47 = (f47 as dynamic); });
+ Expect.throws(() { x47 = confuse(f47); });
+ int Function(int y, [List<T> x]) l47;
+ Expect.throws(() { l47 = (f47 as dynamic); });
+ Expect.throws(() { l47 = confuse(f47); });
+ }
+ int Function(int y, [List<T> x]) l47 = m47;
+ // In checked mode, verifies the type.
+ x47 = m47;
+ x47 = confuse(m47);
+ }
+ }
+
+ void testF147() {
+ // List<Function> Function(int x0, [core.List<core.int> x])
+ Expect.isTrue(f147 is F147);
+ Expect.isTrue(confuse(f147) is F147);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [core.List<core.int> x]) l147;
+ // The static function f147 sets `T` to `int`.
+ if (!tIsBool) {
+ x147 = f147 as dynamic;
+ l147 = f147 as dynamic;
+ x147 = confuse(f147);
+ l147 = confuse(f147);
+ }
+
+ Expect.isTrue(m147 is F147);
+ Expect.isTrue(m147 is List<Function> Function(int x0, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m147) is F147);
+ // In checked mode, verifies the type.
+ x147 = m147;
+ l147 = m147;
+ x147 = confuse(m147);
+ l147 = confuse(m147);
+
+ }
+
+ void testF247() {
+ // List<T> Function([List<Function> x])
+ Expect.isTrue(f247 is F247);
+ Expect.isTrue(confuse(f247) is F247);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x]) l247;
+ // The static function f247 sets `T` to `int`.
+ if (!tIsBool) {
+ x247 = f247 as dynamic;
+ l247 = f247 as dynamic;
+ x247 = confuse(f247);
+ l247 = confuse(f247);
+ }
+
+ Expect.isTrue(m247 is F247);
+ Expect.isTrue(m247 is List<T> Function([List<Function> x]));
+ Expect.isTrue(confuse(m247) is F247);
+ // In checked mode, verifies the type.
+ x247 = m247;
+ l247 = m247;
+ x247 = confuse(m247);
+ l247 = confuse(m247);
+ if (!tIsBool) {
+ Expect.isTrue(f247 is F247<int>);
+ Expect.isFalse(f247 is F247<bool>);
+ Expect.isTrue(confuse(f247) is F247<int>);
+ Expect.isFalse(confuse(f247) is F247<bool>);
+ Expect.equals(tIsDynamic, m247 is F247<bool>);
+ Expect.equals(tIsDynamic, confuse(m247) is F247<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x247 = (f247 as dynamic); });
+ Expect.throws(() { x247 = confuse(f247); });
+ List<T> Function([List<Function> x]) l247;
+ Expect.throws(() { l247 = (f247 as dynamic); });
+ Expect.throws(() { l247 = confuse(f247); });
+ }
+ List<T> Function([List<Function> x]) l247 = m247;
+ // In checked mode, verifies the type.
+ x247 = m247;
+ x247 = confuse(m247);
+ }
+ }
+
+ void testF347() {
+ // Function Function<A>(core.List<core.int> x)
+ Expect.isTrue(f347 is F347);
+ Expect.isTrue(confuse(f347) is F347);
+ // In checked mode, verifies the type.
+ Function Function<A>(core.List<core.int> x) l347;
+ // The static function f347 sets `T` to `int`.
+ if (!tIsBool) {
+ x347 = f347 as dynamic;
+ l347 = f347 as dynamic;
+ x347 = confuse(f347);
+ l347 = confuse(f347);
+ }
+
+ Expect.isTrue(m347 is F347);
+ Expect.isTrue(m347 is Function Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m347) is F347);
+ // In checked mode, verifies the type.
+ x347 = m347;
+ l347 = m347;
+ x347 = confuse(m347);
+ l347 = confuse(m347);
+
+ }
+
+ void testF447() {
+ // int Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f447 is F447);
+ Expect.isTrue(confuse(f447) is F447);
+ // In checked mode, verifies the type.
+ int Function(Function x) Function<B extends core.int>(int x) l447;
+ // The static function f447 sets `T` to `int`.
+ if (!tIsBool) {
+ x447 = f447 as dynamic;
+ l447 = f447 as dynamic;
+ x447 = confuse(f447);
+ l447 = confuse(f447);
+ }
+
+ Expect.isTrue(m447 is F447);
+ Expect.isTrue(m447 is int Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m447) is F447);
+ // In checked mode, verifies the type.
+ x447 = m447;
+ l447 = m447;
+ x447 = confuse(m447);
+ l447 = confuse(m447);
+
+ }
+
+ void testF547() {
+ // int Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f547 is F547);
+ Expect.isTrue(confuse(f547) is F547);
+ // In checked mode, verifies the type.
+ int Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l547;
+ // The static function f547 sets `T` to `int`.
+ if (!tIsBool) {
+ x547 = f547 as dynamic;
+ l547 = f547 as dynamic;
+ x547 = confuse(f547);
+ l547 = confuse(f547);
+ }
+
+ Expect.isTrue(m547 is F547);
+ Expect.isTrue(m547 is int Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m547) is F547);
+ // In checked mode, verifies the type.
+ x547 = m547;
+ l547 = m547;
+ x547 = confuse(m547);
+ l547 = confuse(m547);
+
+ }
+
+ void testF647() {
+ // Function Function([int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f647 is F647);
+ Expect.isTrue(confuse(f647) is F647);
+ // In checked mode, verifies the type.
+ Function Function([int x1]) Function<B extends core.int>(int x) l647;
+ // The static function f647 sets `T` to `int`.
+ if (!tIsBool) {
+ x647 = f647 as dynamic;
+ l647 = f647 as dynamic;
+ x647 = confuse(f647);
+ l647 = confuse(f647);
+ }
+
+ Expect.isTrue(m647 is F647);
+ Expect.isTrue(m647 is Function Function([int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m647) is F647);
+ // In checked mode, verifies the type.
+ x647 = m647;
+ l647 = m647;
+ x647 = confuse(m647);
+ l647 = confuse(m647);
+
+ }
+
+ void testF747() {
+ // Function Function({List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f747 is F747);
+ Expect.isTrue(confuse(f747) is F747);
+ // In checked mode, verifies the type.
+ Function Function({List<Function> x}) Function<B extends core.int>(int x) l747;
+ // The static function f747 sets `T` to `int`.
+ if (!tIsBool) {
+ x747 = f747 as dynamic;
+ l747 = f747 as dynamic;
+ x747 = confuse(f747);
+ l747 = confuse(f747);
+ }
+
+ Expect.isTrue(m747 is F747);
+ Expect.isTrue(m747 is Function Function({List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m747) is F747);
+ // In checked mode, verifies the type.
+ x747 = m747;
+ l747 = m747;
+ x747 = confuse(m747);
+ l747 = confuse(m747);
+
+ }
+
+ void testF847() {
+ // Function Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f847 is F847);
+ Expect.isTrue(confuse(f847) is F847);
+ // In checked mode, verifies the type.
+ Function Function() Function<B extends core.int>(int x) l847;
+ // The static function f847 sets `T` to `int`.
+ if (!tIsBool) {
+ x847 = f847 as dynamic;
+ l847 = f847 as dynamic;
+ x847 = confuse(f847);
+ l847 = confuse(f847);
+ }
+
+ Expect.isTrue(m847 is F847);
+ Expect.isTrue(m847 is Function Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m847) is F847);
+ // In checked mode, verifies the type.
+ x847 = m847;
+ l847 = m847;
+ x847 = confuse(m847);
+ l847 = confuse(m847);
+
+ }
+
+ void testF947() {
+ // List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f947 is F947);
+ Expect.isTrue(confuse(f947) is F947);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l947;
+ // The static function f947 sets `T` to `int`.
+ if (!tIsBool) {
+ x947 = f947 as dynamic;
+ l947 = f947 as dynamic;
+ x947 = confuse(f947);
+ l947 = confuse(f947);
+ }
+
+ Expect.isTrue(m947 is F947);
+ Expect.isTrue(m947 is List<Function> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m947) is F947);
+ // In checked mode, verifies the type.
+ x947 = m947;
+ l947 = m947;
+ x947 = confuse(m947);
+ l947 = confuse(m947);
+
+ }
+
+ void testF1047() {
+ // List<Function> Function([List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1047 is F1047);
+ Expect.isTrue(confuse(f1047) is F1047);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x1]) Function<B extends core.int>(int x) l1047;
+ // The static function f1047 sets `T` to `int`.
+ if (!tIsBool) {
+ x1047 = f1047 as dynamic;
+ l1047 = f1047 as dynamic;
+ x1047 = confuse(f1047);
+ l1047 = confuse(f1047);
+ }
+
+ Expect.isTrue(m1047 is F1047);
+ Expect.isTrue(m1047 is List<Function> Function([List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1047) is F1047);
+ // In checked mode, verifies the type.
+ x1047 = m1047;
+ l1047 = m1047;
+ x1047 = confuse(m1047);
+ l1047 = confuse(m1047);
+ if (!tIsBool) {
+ Expect.isTrue(f1047 is F1047<int>);
+ Expect.isFalse(f1047 is F1047<bool>);
+ Expect.isTrue(confuse(f1047) is F1047<int>);
+ Expect.isFalse(confuse(f1047) is F1047<bool>);
+ Expect.equals(tIsDynamic, m1047 is F1047<bool>);
+ Expect.equals(tIsDynamic, confuse(m1047) is F1047<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1047 = (f1047 as dynamic); });
+ Expect.throws(() { x1047 = confuse(f1047); });
+ List<Function> Function([List<T> x1]) Function<B extends core.int>(int x) l1047;
+ Expect.throws(() { l1047 = (f1047 as dynamic); });
+ Expect.throws(() { l1047 = confuse(f1047); });
+ }
+ List<Function> Function([List<T> x1]) Function<B extends core.int>(int x) l1047 = m1047;
+ // In checked mode, verifies the type.
+ x1047 = m1047;
+ x1047 = confuse(m1047);
+ }
+ }
+
+ void testF1147() {
+ // core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1147 is F1147);
+ Expect.isTrue(confuse(f1147) is F1147);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>(int x) l1147;
+ // The static function f1147 sets `T` to `int`.
+ if (!tIsBool) {
+ x1147 = f1147 as dynamic;
+ l1147 = f1147 as dynamic;
+ x1147 = confuse(f1147);
+ l1147 = confuse(f1147);
+ }
+
+ Expect.isTrue(m1147 is F1147);
+ Expect.isTrue(m1147 is core.List<core.int> Function(int x, [Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1147) is F1147);
+ // In checked mode, verifies the type.
+ x1147 = m1147;
+ l1147 = m1147;
+ x1147 = confuse(m1147);
+ l1147 = confuse(m1147);
+
+ }
+
+ void testF1247() {
+ // core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1247 is F1247);
+ Expect.isTrue(confuse(f1247) is F1247);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l1247;
+ // The static function f1247 sets `T` to `int`.
+ if (!tIsBool) {
+ x1247 = f1247 as dynamic;
+ l1247 = f1247 as dynamic;
+ x1247 = confuse(f1247);
+ l1247 = confuse(f1247);
+ }
+
+ Expect.isTrue(m1247 is F1247);
+ Expect.isTrue(m1247 is core.List<core.int> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1247) is F1247);
+ // In checked mode, verifies the type.
+ x1247 = m1247;
+ l1247 = m1247;
+ x1247 = confuse(m1247);
+ l1247 = confuse(m1247);
+
+ }
+
+ void testF1347() {
+ // List<T> Function([Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1347 is F1347);
+ Expect.isTrue(confuse(f1347) is F1347);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x]) Function<B extends core.int>(int x) l1347;
+ // The static function f1347 sets `T` to `int`.
+ if (!tIsBool) {
+ x1347 = f1347 as dynamic;
+ l1347 = f1347 as dynamic;
+ x1347 = confuse(f1347);
+ l1347 = confuse(f1347);
+ }
+
+ Expect.isTrue(m1347 is F1347);
+ Expect.isTrue(m1347 is List<T> Function([Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1347) is F1347);
+ // In checked mode, verifies the type.
+ x1347 = m1347;
+ l1347 = m1347;
+ x1347 = confuse(m1347);
+ l1347 = confuse(m1347);
+ if (!tIsBool) {
+ Expect.isTrue(f1347 is F1347<int>);
+ Expect.isFalse(f1347 is F1347<bool>);
+ Expect.isTrue(confuse(f1347) is F1347<int>);
+ Expect.isFalse(confuse(f1347) is F1347<bool>);
+ Expect.equals(tIsDynamic, m1347 is F1347<bool>);
+ Expect.equals(tIsDynamic, confuse(m1347) is F1347<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1347 = (f1347 as dynamic); });
+ Expect.throws(() { x1347 = confuse(f1347); });
+ List<T> Function([Function x]) Function<B extends core.int>(int x) l1347;
+ Expect.throws(() { l1347 = (f1347 as dynamic); });
+ Expect.throws(() { l1347 = confuse(f1347); });
+ }
+ List<T> Function([Function x]) Function<B extends core.int>(int x) l1347 = m1347;
+ // In checked mode, verifies the type.
+ x1347 = m1347;
+ x1347 = confuse(m1347);
+ }
+ }
+
+ void testF1447() {
+ // List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1447 is F1447);
+ Expect.isTrue(confuse(f1447) is F1447);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x) l1447;
+ // The static function f1447 sets `T` to `int`.
+ if (!tIsBool) {
+ x1447 = f1447 as dynamic;
+ l1447 = f1447 as dynamic;
+ x1447 = confuse(f1447);
+ l1447 = confuse(f1447);
+ }
+
+ Expect.isTrue(m1447 is F1447);
+ Expect.isTrue(m1447 is List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1447) is F1447);
+ // In checked mode, verifies the type.
+ x1447 = m1447;
+ l1447 = m1447;
+ x1447 = confuse(m1447);
+ l1447 = confuse(m1447);
+ if (!tIsBool) {
+ Expect.isTrue(f1447 is F1447<int>);
+ Expect.isFalse(f1447 is F1447<bool>);
+ Expect.isTrue(confuse(f1447) is F1447<int>);
+ Expect.isFalse(confuse(f1447) is F1447<bool>);
+ Expect.equals(tIsDynamic, m1447 is F1447<bool>);
+ Expect.equals(tIsDynamic, confuse(m1447) is F1447<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1447 = (f1447 as dynamic); });
+ Expect.throws(() { x1447 = confuse(f1447); });
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x) l1447;
+ Expect.throws(() { l1447 = (f1447 as dynamic); });
+ Expect.throws(() { l1447 = confuse(f1447); });
+ }
+ List<T> Function(core.List<core.int> x1) Function<B extends core.int>(int x) l1447 = m1447;
+ // In checked mode, verifies the type.
+ x1447 = m1447;
+ x1447 = confuse(m1447);
+ }
+ }
+
+ void testF1547() {
+ // Function(int x2, [int x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1547 is F1547);
+ Expect.isTrue(confuse(f1547) is F1547);
+ // In checked mode, verifies the type.
+ Function(int x2, [int x3]) Function<B extends core.int>(int x) l1547;
+ // The static function f1547 sets `T` to `int`.
+ if (!tIsBool) {
+ x1547 = f1547 as dynamic;
+ l1547 = f1547 as dynamic;
+ x1547 = confuse(f1547);
+ l1547 = confuse(f1547);
+ }
+
+ Expect.isTrue(m1547 is F1547);
+ Expect.isTrue(m1547 is Function(int x2, [int x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1547) is F1547);
+ // In checked mode, verifies the type.
+ x1547 = m1547;
+ l1547 = m1547;
+ x1547 = confuse(m1547);
+ l1547 = confuse(m1547);
+
+ }
+
+ void testF1647() {
+ // Function(int x1, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1647 is F1647);
+ Expect.isTrue(confuse(f1647) is F1647);
+ // In checked mode, verifies the type.
+ Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l1647;
+ // The static function f1647 sets `T` to `int`.
+ if (!tIsBool) {
+ x1647 = f1647 as dynamic;
+ l1647 = f1647 as dynamic;
+ x1647 = confuse(f1647);
+ l1647 = confuse(f1647);
+ }
+
+ Expect.isTrue(m1647 is F1647);
+ Expect.isTrue(m1647 is Function(int x1, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1647) is F1647);
+ // In checked mode, verifies the type.
+ x1647 = m1647;
+ l1647 = m1647;
+ x1647 = confuse(m1647);
+ l1647 = confuse(m1647);
+
+ }
+
+ void testF1747() {
+ // int Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1747 is F1747);
+ Expect.isTrue(confuse(f1747) is F1747);
+ // In checked mode, verifies the type.
+ int Function<A>(int x) Function<B extends core.int>(int x) l1747;
+ // The static function f1747 sets `T` to `int`.
+ if (!tIsBool) {
+ x1747 = f1747 as dynamic;
+ l1747 = f1747 as dynamic;
+ x1747 = confuse(f1747);
+ l1747 = confuse(f1747);
+ }
+
+ Expect.isTrue(m1747 is F1747);
+ Expect.isTrue(m1747 is int Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1747) is F1747);
+ // In checked mode, verifies the type.
+ x1747 = m1747;
+ l1747 = m1747;
+ x1747 = confuse(m1747);
+ l1747 = confuse(m1747);
+
+ }
+
+ void testF1847() {
+ // core.List<core.int> Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1847 is F1847);
+ Expect.isTrue(confuse(f1847) is F1847);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(Function x) Function<B extends core.int>(int x) l1847;
+ // The static function f1847 sets `T` to `int`.
+ if (!tIsBool) {
+ x1847 = f1847 as dynamic;
+ l1847 = f1847 as dynamic;
+ x1847 = confuse(f1847);
+ l1847 = confuse(f1847);
+ }
+
+ Expect.isTrue(m1847 is F1847);
+ Expect.isTrue(m1847 is core.List<core.int> Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1847) is F1847);
+ // In checked mode, verifies the type.
+ x1847 = m1847;
+ l1847 = m1847;
+ x1847 = confuse(m1847);
+ l1847 = confuse(m1847);
+
+ }
+
+ void testF1947() {
+ // A Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1947 is F1947);
+ Expect.isTrue(confuse(f1947) is F1947);
+ // In checked mode, verifies the type.
+ A Function<A>(List<Function> x) Function<B extends core.int>(int x) l1947;
+ // The static function f1947 sets `T` to `int`.
+ if (!tIsBool) {
+ x1947 = f1947 as dynamic;
+ l1947 = f1947 as dynamic;
+ x1947 = confuse(f1947);
+ l1947 = confuse(f1947);
+ }
+
+ Expect.isTrue(m1947 is F1947);
+ Expect.isTrue(m1947 is A Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1947) is F1947);
+ // In checked mode, verifies the type.
+ x1947 = m1947;
+ l1947 = m1947;
+ x1947 = confuse(m1947);
+ l1947 = confuse(m1947);
+
+ }
+
+
+}
+
+class C48<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(List<T> x0) x48;
+ List<Function> Function(int y, [core.List<core.int> x]) x148;
+ List<T> Function(int x0, [List<Function> x]) x248;
+ Function Function<A>(List<T> x) x348;
+ int Function([Function x]) Function() x448;
+ int Function(core.List<core.int> x0) Function() x548;
+ Function Function(int x1, [int x2]) Function() x648;
+ Function Function(int x0, {List<Function> x}) Function() x748;
+ List<Function> Function(int x) Function() x848;
+ List<Function> Function(int y, [List<Function> x]) Function() x948;
+ List<Function> Function(int x1, [List<T> x2]) Function() x1048;
+ core.List<core.int> Function({Function x}) Function() x1148;
+ core.List<core.int> Function(List<T> x) Function() x1248;
+ List<T> Function(int x0, [Function x]) Function() x1348;
+ List<T> Function([core.List<core.int> x1]) Function() x1448;
+ Function(int x, [int x2]) Function() x1548;
+ Function(int y, {List<Function> x}) Function() x1648;
+ int Function<A>(Function x) Function() x1748;
+ core.List<core.int> Function<A>(List<Function> x) Function() x1848;
+ A Function<A>(core.List<core.int> x) Function() x1948;
+
+
+ C48({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m48(List<T> x0) => null;
+ List<Function> m148(int y, [core.List<core.int> x]) => null;
+ List<T> m248(int x0, [List<Function> x]) => null;
+ Function m348<A>(List<T> x) => null;
+ int Function([Function x]) m448() => null;
+ int Function(core.List<core.int> x0) m548() => null;
+ Function Function(int x0, [int x1]) m648() => null;
+ Function Function(int x0, {List<Function> x}) m748() => null;
+ List<Function> Function(int x) m848() => null;
+ List<Function> Function(int y, [List<Function> x]) m948() => null;
+ List<Function> Function(int x0, [List<T> x1]) m1048() => null;
+ core.List<core.int> Function({Function x}) m1148() => null;
+ core.List<core.int> Function(List<T> x) m1248() => null;
+ List<T> Function(int x0, [Function x]) m1348() => null;
+ List<T> Function([core.List<core.int> x0]) m1448() => null;
+ Function(int x, [int x0]) m1548() => null;
+ Function(int y, {List<Function> x}) m1648() => null;
+ int Function<A>(Function x) m1748() => null;
+ core.List<core.int> Function<A>(List<Function> x) m1848() => null;
+ A Function<A>(core.List<core.int> x) m1948() => null;
+
+
+ runTests() {
+ testF48();
+ testF148();
+ testF248();
+ testF348();
+ testF448();
+ testF548();
+ testF648();
+ testF748();
+ testF848();
+ testF948();
+ testF1048();
+ testF1148();
+ testF1248();
+ testF1348();
+ testF1448();
+ testF1548();
+ testF1648();
+ testF1748();
+ testF1848();
+ testF1948();
+ }
+
+ void testF48() {
+ // int Function(List<T> x0)
+ Expect.isTrue(f48 is F48);
+ Expect.isTrue(confuse(f48) is F48);
+ // In checked mode, verifies the type.
+ int Function(List<T> x0) l48;
+ // The static function f48 sets `T` to `int`.
+ if (!tIsBool) {
+ x48 = f48 as dynamic;
+ l48 = f48 as dynamic;
+ x48 = confuse(f48);
+ l48 = confuse(f48);
+ }
+
+ Expect.isTrue(m48 is F48);
+ Expect.isTrue(m48 is int Function(List<T> x0));
+ Expect.isTrue(confuse(m48) is F48);
+ // In checked mode, verifies the type.
+ x48 = m48;
+ l48 = m48;
+ x48 = confuse(m48);
+ l48 = confuse(m48);
+ if (!tIsBool) {
+ Expect.isTrue(f48 is F48<int>);
+ Expect.isFalse(f48 is F48<bool>);
+ Expect.isTrue(confuse(f48) is F48<int>);
+ Expect.isFalse(confuse(f48) is F48<bool>);
+ Expect.equals(tIsDynamic, m48 is F48<bool>);
+ Expect.equals(tIsDynamic, confuse(m48) is F48<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x48 = (f48 as dynamic); });
+ Expect.throws(() { x48 = confuse(f48); });
+ int Function(List<T> x0) l48;
+ Expect.throws(() { l48 = (f48 as dynamic); });
+ Expect.throws(() { l48 = confuse(f48); });
+ }
+ int Function(List<T> x0) l48 = m48;
+ // In checked mode, verifies the type.
+ x48 = m48;
+ x48 = confuse(m48);
+ }
+ }
+
+ void testF148() {
+ // List<Function> Function(int y, [core.List<core.int> x])
+ Expect.isTrue(f148 is F148);
+ Expect.isTrue(confuse(f148) is F148);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [core.List<core.int> x]) l148;
+ // The static function f148 sets `T` to `int`.
+ if (!tIsBool) {
+ x148 = f148 as dynamic;
+ l148 = f148 as dynamic;
+ x148 = confuse(f148);
+ l148 = confuse(f148);
+ }
+
+ Expect.isTrue(m148 is F148);
+ Expect.isTrue(m148 is List<Function> Function(int y, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m148) is F148);
+ // In checked mode, verifies the type.
+ x148 = m148;
+ l148 = m148;
+ x148 = confuse(m148);
+ l148 = confuse(m148);
+
+ }
+
+ void testF248() {
+ // List<T> Function(int x0, [List<Function> x])
+ Expect.isTrue(f248 is F248);
+ Expect.isTrue(confuse(f248) is F248);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [List<Function> x]) l248;
+ // The static function f248 sets `T` to `int`.
+ if (!tIsBool) {
+ x248 = f248 as dynamic;
+ l248 = f248 as dynamic;
+ x248 = confuse(f248);
+ l248 = confuse(f248);
+ }
+
+ Expect.isTrue(m248 is F248);
+ Expect.isTrue(m248 is List<T> Function(int x0, [List<Function> x]));
+ Expect.isTrue(confuse(m248) is F248);
+ // In checked mode, verifies the type.
+ x248 = m248;
+ l248 = m248;
+ x248 = confuse(m248);
+ l248 = confuse(m248);
+ if (!tIsBool) {
+ Expect.isTrue(f248 is F248<int>);
+ Expect.isFalse(f248 is F248<bool>);
+ Expect.isTrue(confuse(f248) is F248<int>);
+ Expect.isFalse(confuse(f248) is F248<bool>);
+ Expect.equals(tIsDynamic, m248 is F248<bool>);
+ Expect.equals(tIsDynamic, confuse(m248) is F248<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x248 = (f248 as dynamic); });
+ Expect.throws(() { x248 = confuse(f248); });
+ List<T> Function(int x0, [List<Function> x]) l248;
+ Expect.throws(() { l248 = (f248 as dynamic); });
+ Expect.throws(() { l248 = confuse(f248); });
+ }
+ List<T> Function(int x0, [List<Function> x]) l248 = m248;
+ // In checked mode, verifies the type.
+ x248 = m248;
+ x248 = confuse(m248);
+ }
+ }
+
+ void testF348() {
+ // Function Function<A>(List<T> x)
+ Expect.isTrue(f348 is F348);
+ Expect.isTrue(confuse(f348) is F348);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<T> x) l348;
+ // The static function f348 sets `T` to `int`.
+ if (!tIsBool) {
+ x348 = f348 as dynamic;
+ l348 = f348 as dynamic;
+ x348 = confuse(f348);
+ l348 = confuse(f348);
+ }
+
+ Expect.isTrue(m348 is F348);
+ Expect.isTrue(m348 is Function Function<A>(List<T> x));
+ Expect.isTrue(confuse(m348) is F348);
+ // In checked mode, verifies the type.
+ x348 = m348;
+ l348 = m348;
+ x348 = confuse(m348);
+ l348 = confuse(m348);
+ if (!tIsBool) {
+ Expect.isTrue(f348 is F348<int>);
+ Expect.isFalse(f348 is F348<bool>);
+ Expect.isTrue(confuse(f348) is F348<int>);
+ Expect.isFalse(confuse(f348) is F348<bool>);
+ Expect.equals(tIsDynamic, m348 is F348<bool>);
+ Expect.equals(tIsDynamic, confuse(m348) is F348<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x348 = (f348 as dynamic); });
+ Expect.throws(() { x348 = confuse(f348); });
+ Function Function<A>(List<T> x) l348;
+ Expect.throws(() { l348 = (f348 as dynamic); });
+ Expect.throws(() { l348 = confuse(f348); });
+ }
+ Function Function<A>(List<T> x) l348 = m348;
+ // In checked mode, verifies the type.
+ x348 = m348;
+ x348 = confuse(m348);
+ }
+ }
+
+ void testF448() {
+ // int Function([Function x]) Function()
+ Expect.isTrue(f448 is F448);
+ Expect.isTrue(confuse(f448) is F448);
+ // In checked mode, verifies the type.
+ int Function([Function x]) Function() l448;
+ // The static function f448 sets `T` to `int`.
+ if (!tIsBool) {
+ x448 = f448 as dynamic;
+ l448 = f448 as dynamic;
+ x448 = confuse(f448);
+ l448 = confuse(f448);
+ }
+
+ Expect.isTrue(m448 is F448);
+ Expect.isTrue(m448 is int Function([Function x]) Function());
+ Expect.isTrue(confuse(m448) is F448);
+ // In checked mode, verifies the type.
+ x448 = m448;
+ l448 = m448;
+ x448 = confuse(m448);
+ l448 = confuse(m448);
+
+ }
+
+ void testF548() {
+ // int Function(core.List<core.int> x0) Function()
+ Expect.isTrue(f548 is F548);
+ Expect.isTrue(confuse(f548) is F548);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x0) Function() l548;
+ // The static function f548 sets `T` to `int`.
+ if (!tIsBool) {
+ x548 = f548 as dynamic;
+ l548 = f548 as dynamic;
+ x548 = confuse(f548);
+ l548 = confuse(f548);
+ }
+
+ Expect.isTrue(m548 is F548);
+ Expect.isTrue(m548 is int Function(core.List<core.int> x0) Function());
+ Expect.isTrue(confuse(m548) is F548);
+ // In checked mode, verifies the type.
+ x548 = m548;
+ l548 = m548;
+ x548 = confuse(m548);
+ l548 = confuse(m548);
+
+ }
+
+ void testF648() {
+ // Function Function(int x1, [int x2]) Function()
+ Expect.isTrue(f648 is F648);
+ Expect.isTrue(confuse(f648) is F648);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [int x2]) Function() l648;
+ // The static function f648 sets `T` to `int`.
+ if (!tIsBool) {
+ x648 = f648 as dynamic;
+ l648 = f648 as dynamic;
+ x648 = confuse(f648);
+ l648 = confuse(f648);
+ }
+
+ Expect.isTrue(m648 is F648);
+ Expect.isTrue(m648 is Function Function(int x1, [int x2]) Function());
+ Expect.isTrue(confuse(m648) is F648);
+ // In checked mode, verifies the type.
+ x648 = m648;
+ l648 = m648;
+ x648 = confuse(m648);
+ l648 = confuse(m648);
+
+ }
+
+ void testF748() {
+ // Function Function(int x0, {List<Function> x}) Function()
+ Expect.isTrue(f748 is F748);
+ Expect.isTrue(confuse(f748) is F748);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {List<Function> x}) Function() l748;
+ // The static function f748 sets `T` to `int`.
+ if (!tIsBool) {
+ x748 = f748 as dynamic;
+ l748 = f748 as dynamic;
+ x748 = confuse(f748);
+ l748 = confuse(f748);
+ }
+
+ Expect.isTrue(m748 is F748);
+ Expect.isTrue(m748 is Function Function(int x0, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m748) is F748);
+ // In checked mode, verifies the type.
+ x748 = m748;
+ l748 = m748;
+ x748 = confuse(m748);
+ l748 = confuse(m748);
+
+ }
+
+ void testF848() {
+ // List<Function> Function(int x) Function()
+ Expect.isTrue(f848 is F848);
+ Expect.isTrue(confuse(f848) is F848);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x) Function() l848;
+ // The static function f848 sets `T` to `int`.
+ if (!tIsBool) {
+ x848 = f848 as dynamic;
+ l848 = f848 as dynamic;
+ x848 = confuse(f848);
+ l848 = confuse(f848);
+ }
+
+ Expect.isTrue(m848 is F848);
+ Expect.isTrue(m848 is List<Function> Function(int x) Function());
+ Expect.isTrue(confuse(m848) is F848);
+ // In checked mode, verifies the type.
+ x848 = m848;
+ l848 = m848;
+ x848 = confuse(m848);
+ l848 = confuse(m848);
+
+ }
+
+ void testF948() {
+ // List<Function> Function(int y, [List<Function> x]) Function()
+ Expect.isTrue(f948 is F948);
+ Expect.isTrue(confuse(f948) is F948);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<Function> x]) Function() l948;
+ // The static function f948 sets `T` to `int`.
+ if (!tIsBool) {
+ x948 = f948 as dynamic;
+ l948 = f948 as dynamic;
+ x948 = confuse(f948);
+ l948 = confuse(f948);
+ }
+
+ Expect.isTrue(m948 is F948);
+ Expect.isTrue(m948 is List<Function> Function(int y, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m948) is F948);
+ // In checked mode, verifies the type.
+ x948 = m948;
+ l948 = m948;
+ x948 = confuse(m948);
+ l948 = confuse(m948);
+
+ }
+
+ void testF1048() {
+ // List<Function> Function(int x1, [List<T> x2]) Function()
+ Expect.isTrue(f1048 is F1048);
+ Expect.isTrue(confuse(f1048) is F1048);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<T> x2]) Function() l1048;
+ // The static function f1048 sets `T` to `int`.
+ if (!tIsBool) {
+ x1048 = f1048 as dynamic;
+ l1048 = f1048 as dynamic;
+ x1048 = confuse(f1048);
+ l1048 = confuse(f1048);
+ }
+
+ Expect.isTrue(m1048 is F1048);
+ Expect.isTrue(m1048 is List<Function> Function(int x1, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1048) is F1048);
+ // In checked mode, verifies the type.
+ x1048 = m1048;
+ l1048 = m1048;
+ x1048 = confuse(m1048);
+ l1048 = confuse(m1048);
+ if (!tIsBool) {
+ Expect.isTrue(f1048 is F1048<int>);
+ Expect.isFalse(f1048 is F1048<bool>);
+ Expect.isTrue(confuse(f1048) is F1048<int>);
+ Expect.isFalse(confuse(f1048) is F1048<bool>);
+ Expect.equals(tIsDynamic, m1048 is F1048<bool>);
+ Expect.equals(tIsDynamic, confuse(m1048) is F1048<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1048 = (f1048 as dynamic); });
+ Expect.throws(() { x1048 = confuse(f1048); });
+ List<Function> Function(int x1, [List<T> x2]) Function() l1048;
+ Expect.throws(() { l1048 = (f1048 as dynamic); });
+ Expect.throws(() { l1048 = confuse(f1048); });
+ }
+ List<Function> Function(int x1, [List<T> x2]) Function() l1048 = m1048;
+ // In checked mode, verifies the type.
+ x1048 = m1048;
+ x1048 = confuse(m1048);
+ }
+ }
+
+ void testF1148() {
+ // core.List<core.int> Function({Function x}) Function()
+ Expect.isTrue(f1148 is F1148);
+ Expect.isTrue(confuse(f1148) is F1148);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({Function x}) Function() l1148;
+ // The static function f1148 sets `T` to `int`.
+ if (!tIsBool) {
+ x1148 = f1148 as dynamic;
+ l1148 = f1148 as dynamic;
+ x1148 = confuse(f1148);
+ l1148 = confuse(f1148);
+ }
+
+ Expect.isTrue(m1148 is F1148);
+ Expect.isTrue(m1148 is core.List<core.int> Function({Function x}) Function());
+ Expect.isTrue(confuse(m1148) is F1148);
+ // In checked mode, verifies the type.
+ x1148 = m1148;
+ l1148 = m1148;
+ x1148 = confuse(m1148);
+ l1148 = confuse(m1148);
+
+ }
+
+ void testF1248() {
+ // core.List<core.int> Function(List<T> x) Function()
+ Expect.isTrue(f1248 is F1248);
+ Expect.isTrue(confuse(f1248) is F1248);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x) Function() l1248;
+ // The static function f1248 sets `T` to `int`.
+ if (!tIsBool) {
+ x1248 = f1248 as dynamic;
+ l1248 = f1248 as dynamic;
+ x1248 = confuse(f1248);
+ l1248 = confuse(f1248);
+ }
+
+ Expect.isTrue(m1248 is F1248);
+ Expect.isTrue(m1248 is core.List<core.int> Function(List<T> x) Function());
+ Expect.isTrue(confuse(m1248) is F1248);
+ // In checked mode, verifies the type.
+ x1248 = m1248;
+ l1248 = m1248;
+ x1248 = confuse(m1248);
+ l1248 = confuse(m1248);
+ if (!tIsBool) {
+ Expect.isTrue(f1248 is F1248<int>);
+ Expect.isFalse(f1248 is F1248<bool>);
+ Expect.isTrue(confuse(f1248) is F1248<int>);
+ Expect.isFalse(confuse(f1248) is F1248<bool>);
+ Expect.equals(tIsDynamic, m1248 is F1248<bool>);
+ Expect.equals(tIsDynamic, confuse(m1248) is F1248<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1248 = (f1248 as dynamic); });
+ Expect.throws(() { x1248 = confuse(f1248); });
+ core.List<core.int> Function(List<T> x) Function() l1248;
+ Expect.throws(() { l1248 = (f1248 as dynamic); });
+ Expect.throws(() { l1248 = confuse(f1248); });
+ }
+ core.List<core.int> Function(List<T> x) Function() l1248 = m1248;
+ // In checked mode, verifies the type.
+ x1248 = m1248;
+ x1248 = confuse(m1248);
+ }
+ }
+
+ void testF1348() {
+ // List<T> Function(int x0, [Function x]) Function()
+ Expect.isTrue(f1348 is F1348);
+ Expect.isTrue(confuse(f1348) is F1348);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [Function x]) Function() l1348;
+ // The static function f1348 sets `T` to `int`.
+ if (!tIsBool) {
+ x1348 = f1348 as dynamic;
+ l1348 = f1348 as dynamic;
+ x1348 = confuse(f1348);
+ l1348 = confuse(f1348);
+ }
+
+ Expect.isTrue(m1348 is F1348);
+ Expect.isTrue(m1348 is List<T> Function(int x0, [Function x]) Function());
+ Expect.isTrue(confuse(m1348) is F1348);
+ // In checked mode, verifies the type.
+ x1348 = m1348;
+ l1348 = m1348;
+ x1348 = confuse(m1348);
+ l1348 = confuse(m1348);
+ if (!tIsBool) {
+ Expect.isTrue(f1348 is F1348<int>);
+ Expect.isFalse(f1348 is F1348<bool>);
+ Expect.isTrue(confuse(f1348) is F1348<int>);
+ Expect.isFalse(confuse(f1348) is F1348<bool>);
+ Expect.equals(tIsDynamic, m1348 is F1348<bool>);
+ Expect.equals(tIsDynamic, confuse(m1348) is F1348<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1348 = (f1348 as dynamic); });
+ Expect.throws(() { x1348 = confuse(f1348); });
+ List<T> Function(int x0, [Function x]) Function() l1348;
+ Expect.throws(() { l1348 = (f1348 as dynamic); });
+ Expect.throws(() { l1348 = confuse(f1348); });
+ }
+ List<T> Function(int x0, [Function x]) Function() l1348 = m1348;
+ // In checked mode, verifies the type.
+ x1348 = m1348;
+ x1348 = confuse(m1348);
+ }
+ }
+
+ void testF1448() {
+ // List<T> Function([core.List<core.int> x1]) Function()
+ Expect.isTrue(f1448 is F1448);
+ Expect.isTrue(confuse(f1448) is F1448);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x1]) Function() l1448;
+ // The static function f1448 sets `T` to `int`.
+ if (!tIsBool) {
+ x1448 = f1448 as dynamic;
+ l1448 = f1448 as dynamic;
+ x1448 = confuse(f1448);
+ l1448 = confuse(f1448);
+ }
+
+ Expect.isTrue(m1448 is F1448);
+ Expect.isTrue(m1448 is List<T> Function([core.List<core.int> x1]) Function());
+ Expect.isTrue(confuse(m1448) is F1448);
+ // In checked mode, verifies the type.
+ x1448 = m1448;
+ l1448 = m1448;
+ x1448 = confuse(m1448);
+ l1448 = confuse(m1448);
+ if (!tIsBool) {
+ Expect.isTrue(f1448 is F1448<int>);
+ Expect.isFalse(f1448 is F1448<bool>);
+ Expect.isTrue(confuse(f1448) is F1448<int>);
+ Expect.isFalse(confuse(f1448) is F1448<bool>);
+ Expect.equals(tIsDynamic, m1448 is F1448<bool>);
+ Expect.equals(tIsDynamic, confuse(m1448) is F1448<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1448 = (f1448 as dynamic); });
+ Expect.throws(() { x1448 = confuse(f1448); });
+ List<T> Function([core.List<core.int> x1]) Function() l1448;
+ Expect.throws(() { l1448 = (f1448 as dynamic); });
+ Expect.throws(() { l1448 = confuse(f1448); });
+ }
+ List<T> Function([core.List<core.int> x1]) Function() l1448 = m1448;
+ // In checked mode, verifies the type.
+ x1448 = m1448;
+ x1448 = confuse(m1448);
+ }
+ }
+
+ void testF1548() {
+ // Function(int x, [int x2]) Function()
+ Expect.isTrue(f1548 is F1548);
+ Expect.isTrue(confuse(f1548) is F1548);
+ // In checked mode, verifies the type.
+ Function(int x, [int x2]) Function() l1548;
+ // The static function f1548 sets `T` to `int`.
+ if (!tIsBool) {
+ x1548 = f1548 as dynamic;
+ l1548 = f1548 as dynamic;
+ x1548 = confuse(f1548);
+ l1548 = confuse(f1548);
+ }
+
+ Expect.isTrue(m1548 is F1548);
+ Expect.isTrue(m1548 is Function(int x, [int x2]) Function());
+ Expect.isTrue(confuse(m1548) is F1548);
+ // In checked mode, verifies the type.
+ x1548 = m1548;
+ l1548 = m1548;
+ x1548 = confuse(m1548);
+ l1548 = confuse(m1548);
+
+ }
+
+ void testF1648() {
+ // Function(int y, {List<Function> x}) Function()
+ Expect.isTrue(f1648 is F1648);
+ Expect.isTrue(confuse(f1648) is F1648);
+ // In checked mode, verifies the type.
+ Function(int y, {List<Function> x}) Function() l1648;
+ // The static function f1648 sets `T` to `int`.
+ if (!tIsBool) {
+ x1648 = f1648 as dynamic;
+ l1648 = f1648 as dynamic;
+ x1648 = confuse(f1648);
+ l1648 = confuse(f1648);
+ }
+
+ Expect.isTrue(m1648 is F1648);
+ Expect.isTrue(m1648 is Function(int y, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m1648) is F1648);
+ // In checked mode, verifies the type.
+ x1648 = m1648;
+ l1648 = m1648;
+ x1648 = confuse(m1648);
+ l1648 = confuse(m1648);
+
+ }
+
+ void testF1748() {
+ // int Function<A>(Function x) Function()
+ Expect.isTrue(f1748 is F1748);
+ Expect.isTrue(confuse(f1748) is F1748);
+ // In checked mode, verifies the type.
+ int Function<A>(Function x) Function() l1748;
+ // The static function f1748 sets `T` to `int`.
+ if (!tIsBool) {
+ x1748 = f1748 as dynamic;
+ l1748 = f1748 as dynamic;
+ x1748 = confuse(f1748);
+ l1748 = confuse(f1748);
+ }
+
+ Expect.isTrue(m1748 is F1748);
+ Expect.isTrue(m1748 is int Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1748) is F1748);
+ // In checked mode, verifies the type.
+ x1748 = m1748;
+ l1748 = m1748;
+ x1748 = confuse(m1748);
+ l1748 = confuse(m1748);
+
+ }
+
+ void testF1848() {
+ // core.List<core.int> Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1848 is F1848);
+ Expect.isTrue(confuse(f1848) is F1848);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<Function> x) Function() l1848;
+ // The static function f1848 sets `T` to `int`.
+ if (!tIsBool) {
+ x1848 = f1848 as dynamic;
+ l1848 = f1848 as dynamic;
+ x1848 = confuse(f1848);
+ l1848 = confuse(f1848);
+ }
+
+ Expect.isTrue(m1848 is F1848);
+ Expect.isTrue(m1848 is core.List<core.int> Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1848) is F1848);
+ // In checked mode, verifies the type.
+ x1848 = m1848;
+ l1848 = m1848;
+ x1848 = confuse(m1848);
+ l1848 = confuse(m1848);
+
+ }
+
+ void testF1948() {
+ // A Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1948 is F1948);
+ Expect.isTrue(confuse(f1948) is F1948);
+ // In checked mode, verifies the type.
+ A Function<A>(core.List<core.int> x) Function() l1948;
+ // The static function f1948 sets `T` to `int`.
+ if (!tIsBool) {
+ x1948 = f1948 as dynamic;
+ l1948 = f1948 as dynamic;
+ x1948 = confuse(f1948);
+ l1948 = confuse(f1948);
+ }
+
+ Expect.isTrue(m1948 is F1948);
+ Expect.isTrue(m1948 is A Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1948) is F1948);
+ // In checked mode, verifies the type.
+ x1948 = m1948;
+ l1948 = m1948;
+ x1948 = confuse(m1948);
+ l1948 = confuse(m1948);
+
+ }
+
+
+}
+
+class C49<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function([List<T> x1]) x49;
+ List<Function> Function(core.List<core.int> x0) x149;
+ List<T> Function(int y, [List<Function> x]) x249;
+ Function Function<A>() x349;
+ int Function([Function x]) Function(int x) x449;
+ int Function(core.List<core.int> x1) Function(int x) x549;
+ Function Function(int x2, [int x3]) Function(int x) x649;
+ Function Function(int x1, {List<Function> x}) Function(int x) x749;
+ List<Function> Function(int x) Function(int x) x849;
+ List<Function> Function(int y, [List<Function> x]) Function(int x) x949;
+ List<Function> Function(int x2, [List<T> x3]) Function(int x) x1049;
+ core.List<core.int> Function({Function x}) Function(int x) x1149;
+ core.List<core.int> Function(List<T> x) Function(int x) x1249;
+ List<T> Function(int x1, [Function x]) Function(int x) x1349;
+ List<T> Function([core.List<core.int> x1]) Function(int x) x1449;
+ Function(int x, [int x1]) Function(int x) x1549;
+ Function(int y, {List<Function> x}) Function(int x) x1649;
+ int Function<A>(Function x) Function(int x) x1749;
+ core.List<core.int> Function<A>(List<Function> x) Function(int x) x1849;
+ A Function<A>(core.List<core.int> x) Function(int x) x1949;
+
+
+ C49({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m49([List<T> x0]) => null;
+ List<Function> m149(core.List<core.int> x0) => null;
+ List<T> m249(int y, [List<Function> x]) => null;
+ Function m349<A>() => null;
+ int Function([Function x]) m449(int x) => null;
+ int Function(core.List<core.int> x0) m549(int x) => null;
+ Function Function(int x0, [int x1]) m649(int x) => null;
+ Function Function(int x0, {List<Function> x}) m749(int x) => null;
+ List<Function> Function(int x) m849(int x) => null;
+ List<Function> Function(int y, [List<Function> x]) m949(int x) => null;
+ List<Function> Function(int x0, [List<T> x1]) m1049(int x) => null;
+ core.List<core.int> Function({Function x}) m1149(int x) => null;
+ core.List<core.int> Function(List<T> x) m1249(int x) => null;
+ List<T> Function(int x0, [Function x]) m1349(int x) => null;
+ List<T> Function([core.List<core.int> x0]) m1449(int x) => null;
+ Function(int x, [int x0]) m1549(int x) => null;
+ Function(int y, {List<Function> x}) m1649(int x) => null;
+ int Function<A>(Function x) m1749(int x) => null;
+ core.List<core.int> Function<A>(List<Function> x) m1849(int x) => null;
+ A Function<A>(core.List<core.int> x) m1949(int x) => null;
+
+
+ runTests() {
+ testF49();
+ testF149();
+ testF249();
+ testF349();
+ testF449();
+ testF549();
+ testF649();
+ testF749();
+ testF849();
+ testF949();
+ testF1049();
+ testF1149();
+ testF1249();
+ testF1349();
+ testF1449();
+ testF1549();
+ testF1649();
+ testF1749();
+ testF1849();
+ testF1949();
+ }
+
+ void testF49() {
+ // int Function([List<T> x1])
+ Expect.isTrue(f49 is F49);
+ Expect.isTrue(confuse(f49) is F49);
+ // In checked mode, verifies the type.
+ int Function([List<T> x1]) l49;
+ // The static function f49 sets `T` to `int`.
+ if (!tIsBool) {
+ x49 = f49 as dynamic;
+ l49 = f49 as dynamic;
+ x49 = confuse(f49);
+ l49 = confuse(f49);
+ }
+
+ Expect.isTrue(m49 is F49);
+ Expect.isTrue(m49 is int Function([List<T> x1]));
+ Expect.isTrue(confuse(m49) is F49);
+ // In checked mode, verifies the type.
+ x49 = m49;
+ l49 = m49;
+ x49 = confuse(m49);
+ l49 = confuse(m49);
+ if (!tIsBool) {
+ Expect.isTrue(f49 is F49<int>);
+ Expect.isFalse(f49 is F49<bool>);
+ Expect.isTrue(confuse(f49) is F49<int>);
+ Expect.isFalse(confuse(f49) is F49<bool>);
+ Expect.equals(tIsDynamic, m49 is F49<bool>);
+ Expect.equals(tIsDynamic, confuse(m49) is F49<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x49 = (f49 as dynamic); });
+ Expect.throws(() { x49 = confuse(f49); });
+ int Function([List<T> x1]) l49;
+ Expect.throws(() { l49 = (f49 as dynamic); });
+ Expect.throws(() { l49 = confuse(f49); });
+ }
+ int Function([List<T> x1]) l49 = m49;
+ // In checked mode, verifies the type.
+ x49 = m49;
+ x49 = confuse(m49);
+ }
+ }
+
+ void testF149() {
+ // List<Function> Function(core.List<core.int> x0)
+ Expect.isTrue(f149 is F149);
+ Expect.isTrue(confuse(f149) is F149);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x0) l149;
+ // The static function f149 sets `T` to `int`.
+ if (!tIsBool) {
+ x149 = f149 as dynamic;
+ l149 = f149 as dynamic;
+ x149 = confuse(f149);
+ l149 = confuse(f149);
+ }
+
+ Expect.isTrue(m149 is F149);
+ Expect.isTrue(m149 is List<Function> Function(core.List<core.int> x0));
+ Expect.isTrue(confuse(m149) is F149);
+ // In checked mode, verifies the type.
+ x149 = m149;
+ l149 = m149;
+ x149 = confuse(m149);
+ l149 = confuse(m149);
+
+ }
+
+ void testF249() {
+ // List<T> Function(int y, [List<Function> x])
+ Expect.isTrue(f249 is F249);
+ Expect.isTrue(confuse(f249) is F249);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<Function> x]) l249;
+ // The static function f249 sets `T` to `int`.
+ if (!tIsBool) {
+ x249 = f249 as dynamic;
+ l249 = f249 as dynamic;
+ x249 = confuse(f249);
+ l249 = confuse(f249);
+ }
+
+ Expect.isTrue(m249 is F249);
+ Expect.isTrue(m249 is List<T> Function(int y, [List<Function> x]));
+ Expect.isTrue(confuse(m249) is F249);
+ // In checked mode, verifies the type.
+ x249 = m249;
+ l249 = m249;
+ x249 = confuse(m249);
+ l249 = confuse(m249);
+ if (!tIsBool) {
+ Expect.isTrue(f249 is F249<int>);
+ Expect.isFalse(f249 is F249<bool>);
+ Expect.isTrue(confuse(f249) is F249<int>);
+ Expect.isFalse(confuse(f249) is F249<bool>);
+ Expect.equals(tIsDynamic, m249 is F249<bool>);
+ Expect.equals(tIsDynamic, confuse(m249) is F249<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x249 = (f249 as dynamic); });
+ Expect.throws(() { x249 = confuse(f249); });
+ List<T> Function(int y, [List<Function> x]) l249;
+ Expect.throws(() { l249 = (f249 as dynamic); });
+ Expect.throws(() { l249 = confuse(f249); });
+ }
+ List<T> Function(int y, [List<Function> x]) l249 = m249;
+ // In checked mode, verifies the type.
+ x249 = m249;
+ x249 = confuse(m249);
+ }
+ }
+
+ void testF349() {
+ // Function Function<A>()
+ Expect.isTrue(f349 is F349);
+ Expect.isTrue(confuse(f349) is F349);
+ // In checked mode, verifies the type.
+ Function Function<A>() l349;
+ // The static function f349 sets `T` to `int`.
+ if (!tIsBool) {
+ x349 = f349 as dynamic;
+ l349 = f349 as dynamic;
+ x349 = confuse(f349);
+ l349 = confuse(f349);
+ }
+
+ Expect.isTrue(m349 is F349);
+ Expect.isTrue(m349 is Function Function<A>());
+ Expect.isTrue(confuse(m349) is F349);
+ // In checked mode, verifies the type.
+ x349 = m349;
+ l349 = m349;
+ x349 = confuse(m349);
+ l349 = confuse(m349);
+
+ }
+
+ void testF449() {
+ // int Function([Function x]) Function(int x)
+ Expect.isTrue(f449 is F449);
+ Expect.isTrue(confuse(f449) is F449);
+ // In checked mode, verifies the type.
+ int Function([Function x]) Function(int x) l449;
+ // The static function f449 sets `T` to `int`.
+ if (!tIsBool) {
+ x449 = f449 as dynamic;
+ l449 = f449 as dynamic;
+ x449 = confuse(f449);
+ l449 = confuse(f449);
+ }
+
+ Expect.isTrue(m449 is F449);
+ Expect.isTrue(m449 is int Function([Function x]) Function(int x));
+ Expect.isTrue(confuse(m449) is F449);
+ // In checked mode, verifies the type.
+ x449 = m449;
+ l449 = m449;
+ x449 = confuse(m449);
+ l449 = confuse(m449);
+
+ }
+
+ void testF549() {
+ // int Function(core.List<core.int> x1) Function(int x)
+ Expect.isTrue(f549 is F549);
+ Expect.isTrue(confuse(f549) is F549);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x1) Function(int x) l549;
+ // The static function f549 sets `T` to `int`.
+ if (!tIsBool) {
+ x549 = f549 as dynamic;
+ l549 = f549 as dynamic;
+ x549 = confuse(f549);
+ l549 = confuse(f549);
+ }
+
+ Expect.isTrue(m549 is F549);
+ Expect.isTrue(m549 is int Function(core.List<core.int> x1) Function(int x));
+ Expect.isTrue(confuse(m549) is F549);
+ // In checked mode, verifies the type.
+ x549 = m549;
+ l549 = m549;
+ x549 = confuse(m549);
+ l549 = confuse(m549);
+
+ }
+
+ void testF649() {
+ // Function Function(int x2, [int x3]) Function(int x)
+ Expect.isTrue(f649 is F649);
+ Expect.isTrue(confuse(f649) is F649);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [int x3]) Function(int x) l649;
+ // The static function f649 sets `T` to `int`.
+ if (!tIsBool) {
+ x649 = f649 as dynamic;
+ l649 = f649 as dynamic;
+ x649 = confuse(f649);
+ l649 = confuse(f649);
+ }
+
+ Expect.isTrue(m649 is F649);
+ Expect.isTrue(m649 is Function Function(int x2, [int x3]) Function(int x));
+ Expect.isTrue(confuse(m649) is F649);
+ // In checked mode, verifies the type.
+ x649 = m649;
+ l649 = m649;
+ x649 = confuse(m649);
+ l649 = confuse(m649);
+
+ }
+
+ void testF749() {
+ // Function Function(int x1, {List<Function> x}) Function(int x)
+ Expect.isTrue(f749 is F749);
+ Expect.isTrue(confuse(f749) is F749);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {List<Function> x}) Function(int x) l749;
+ // The static function f749 sets `T` to `int`.
+ if (!tIsBool) {
+ x749 = f749 as dynamic;
+ l749 = f749 as dynamic;
+ x749 = confuse(f749);
+ l749 = confuse(f749);
+ }
+
+ Expect.isTrue(m749 is F749);
+ Expect.isTrue(m749 is Function Function(int x1, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m749) is F749);
+ // In checked mode, verifies the type.
+ x749 = m749;
+ l749 = m749;
+ x749 = confuse(m749);
+ l749 = confuse(m749);
+
+ }
+
+ void testF849() {
+ // List<Function> Function(int x) Function(int x)
+ Expect.isTrue(f849 is F849);
+ Expect.isTrue(confuse(f849) is F849);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x) Function(int x) l849;
+ // The static function f849 sets `T` to `int`.
+ if (!tIsBool) {
+ x849 = f849 as dynamic;
+ l849 = f849 as dynamic;
+ x849 = confuse(f849);
+ l849 = confuse(f849);
+ }
+
+ Expect.isTrue(m849 is F849);
+ Expect.isTrue(m849 is List<Function> Function(int x) Function(int x));
+ Expect.isTrue(confuse(m849) is F849);
+ // In checked mode, verifies the type.
+ x849 = m849;
+ l849 = m849;
+ x849 = confuse(m849);
+ l849 = confuse(m849);
+
+ }
+
+ void testF949() {
+ // List<Function> Function(int y, [List<Function> x]) Function(int x)
+ Expect.isTrue(f949 is F949);
+ Expect.isTrue(confuse(f949) is F949);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<Function> x]) Function(int x) l949;
+ // The static function f949 sets `T` to `int`.
+ if (!tIsBool) {
+ x949 = f949 as dynamic;
+ l949 = f949 as dynamic;
+ x949 = confuse(f949);
+ l949 = confuse(f949);
+ }
+
+ Expect.isTrue(m949 is F949);
+ Expect.isTrue(m949 is List<Function> Function(int y, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m949) is F949);
+ // In checked mode, verifies the type.
+ x949 = m949;
+ l949 = m949;
+ x949 = confuse(m949);
+ l949 = confuse(m949);
+
+ }
+
+ void testF1049() {
+ // List<Function> Function(int x2, [List<T> x3]) Function(int x)
+ Expect.isTrue(f1049 is F1049);
+ Expect.isTrue(confuse(f1049) is F1049);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [List<T> x3]) Function(int x) l1049;
+ // The static function f1049 sets `T` to `int`.
+ if (!tIsBool) {
+ x1049 = f1049 as dynamic;
+ l1049 = f1049 as dynamic;
+ x1049 = confuse(f1049);
+ l1049 = confuse(f1049);
+ }
+
+ Expect.isTrue(m1049 is F1049);
+ Expect.isTrue(m1049 is List<Function> Function(int x2, [List<T> x3]) Function(int x));
+ Expect.isTrue(confuse(m1049) is F1049);
+ // In checked mode, verifies the type.
+ x1049 = m1049;
+ l1049 = m1049;
+ x1049 = confuse(m1049);
+ l1049 = confuse(m1049);
+ if (!tIsBool) {
+ Expect.isTrue(f1049 is F1049<int>);
+ Expect.isFalse(f1049 is F1049<bool>);
+ Expect.isTrue(confuse(f1049) is F1049<int>);
+ Expect.isFalse(confuse(f1049) is F1049<bool>);
+ Expect.equals(tIsDynamic, m1049 is F1049<bool>);
+ Expect.equals(tIsDynamic, confuse(m1049) is F1049<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1049 = (f1049 as dynamic); });
+ Expect.throws(() { x1049 = confuse(f1049); });
+ List<Function> Function(int x2, [List<T> x3]) Function(int x) l1049;
+ Expect.throws(() { l1049 = (f1049 as dynamic); });
+ Expect.throws(() { l1049 = confuse(f1049); });
+ }
+ List<Function> Function(int x2, [List<T> x3]) Function(int x) l1049 = m1049;
+ // In checked mode, verifies the type.
+ x1049 = m1049;
+ x1049 = confuse(m1049);
+ }
+ }
+
+ void testF1149() {
+ // core.List<core.int> Function({Function x}) Function(int x)
+ Expect.isTrue(f1149 is F1149);
+ Expect.isTrue(confuse(f1149) is F1149);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({Function x}) Function(int x) l1149;
+ // The static function f1149 sets `T` to `int`.
+ if (!tIsBool) {
+ x1149 = f1149 as dynamic;
+ l1149 = f1149 as dynamic;
+ x1149 = confuse(f1149);
+ l1149 = confuse(f1149);
+ }
+
+ Expect.isTrue(m1149 is F1149);
+ Expect.isTrue(m1149 is core.List<core.int> Function({Function x}) Function(int x));
+ Expect.isTrue(confuse(m1149) is F1149);
+ // In checked mode, verifies the type.
+ x1149 = m1149;
+ l1149 = m1149;
+ x1149 = confuse(m1149);
+ l1149 = confuse(m1149);
+
+ }
+
+ void testF1249() {
+ // core.List<core.int> Function(List<T> x) Function(int x)
+ Expect.isTrue(f1249 is F1249);
+ Expect.isTrue(confuse(f1249) is F1249);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x) Function(int x) l1249;
+ // The static function f1249 sets `T` to `int`.
+ if (!tIsBool) {
+ x1249 = f1249 as dynamic;
+ l1249 = f1249 as dynamic;
+ x1249 = confuse(f1249);
+ l1249 = confuse(f1249);
+ }
+
+ Expect.isTrue(m1249 is F1249);
+ Expect.isTrue(m1249 is core.List<core.int> Function(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1249) is F1249);
+ // In checked mode, verifies the type.
+ x1249 = m1249;
+ l1249 = m1249;
+ x1249 = confuse(m1249);
+ l1249 = confuse(m1249);
+ if (!tIsBool) {
+ Expect.isTrue(f1249 is F1249<int>);
+ Expect.isFalse(f1249 is F1249<bool>);
+ Expect.isTrue(confuse(f1249) is F1249<int>);
+ Expect.isFalse(confuse(f1249) is F1249<bool>);
+ Expect.equals(tIsDynamic, m1249 is F1249<bool>);
+ Expect.equals(tIsDynamic, confuse(m1249) is F1249<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1249 = (f1249 as dynamic); });
+ Expect.throws(() { x1249 = confuse(f1249); });
+ core.List<core.int> Function(List<T> x) Function(int x) l1249;
+ Expect.throws(() { l1249 = (f1249 as dynamic); });
+ Expect.throws(() { l1249 = confuse(f1249); });
+ }
+ core.List<core.int> Function(List<T> x) Function(int x) l1249 = m1249;
+ // In checked mode, verifies the type.
+ x1249 = m1249;
+ x1249 = confuse(m1249);
+ }
+ }
+
+ void testF1349() {
+ // List<T> Function(int x1, [Function x]) Function(int x)
+ Expect.isTrue(f1349 is F1349);
+ Expect.isTrue(confuse(f1349) is F1349);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [Function x]) Function(int x) l1349;
+ // The static function f1349 sets `T` to `int`.
+ if (!tIsBool) {
+ x1349 = f1349 as dynamic;
+ l1349 = f1349 as dynamic;
+ x1349 = confuse(f1349);
+ l1349 = confuse(f1349);
+ }
+
+ Expect.isTrue(m1349 is F1349);
+ Expect.isTrue(m1349 is List<T> Function(int x1, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m1349) is F1349);
+ // In checked mode, verifies the type.
+ x1349 = m1349;
+ l1349 = m1349;
+ x1349 = confuse(m1349);
+ l1349 = confuse(m1349);
+ if (!tIsBool) {
+ Expect.isTrue(f1349 is F1349<int>);
+ Expect.isFalse(f1349 is F1349<bool>);
+ Expect.isTrue(confuse(f1349) is F1349<int>);
+ Expect.isFalse(confuse(f1349) is F1349<bool>);
+ Expect.equals(tIsDynamic, m1349 is F1349<bool>);
+ Expect.equals(tIsDynamic, confuse(m1349) is F1349<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1349 = (f1349 as dynamic); });
+ Expect.throws(() { x1349 = confuse(f1349); });
+ List<T> Function(int x1, [Function x]) Function(int x) l1349;
+ Expect.throws(() { l1349 = (f1349 as dynamic); });
+ Expect.throws(() { l1349 = confuse(f1349); });
+ }
+ List<T> Function(int x1, [Function x]) Function(int x) l1349 = m1349;
+ // In checked mode, verifies the type.
+ x1349 = m1349;
+ x1349 = confuse(m1349);
+ }
+ }
+
+ void testF1449() {
+ // List<T> Function([core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1449 is F1449);
+ Expect.isTrue(confuse(f1449) is F1449);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x1]) Function(int x) l1449;
+ // The static function f1449 sets `T` to `int`.
+ if (!tIsBool) {
+ x1449 = f1449 as dynamic;
+ l1449 = f1449 as dynamic;
+ x1449 = confuse(f1449);
+ l1449 = confuse(f1449);
+ }
+
+ Expect.isTrue(m1449 is F1449);
+ Expect.isTrue(m1449 is List<T> Function([core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1449) is F1449);
+ // In checked mode, verifies the type.
+ x1449 = m1449;
+ l1449 = m1449;
+ x1449 = confuse(m1449);
+ l1449 = confuse(m1449);
+ if (!tIsBool) {
+ Expect.isTrue(f1449 is F1449<int>);
+ Expect.isFalse(f1449 is F1449<bool>);
+ Expect.isTrue(confuse(f1449) is F1449<int>);
+ Expect.isFalse(confuse(f1449) is F1449<bool>);
+ Expect.equals(tIsDynamic, m1449 is F1449<bool>);
+ Expect.equals(tIsDynamic, confuse(m1449) is F1449<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1449 = (f1449 as dynamic); });
+ Expect.throws(() { x1449 = confuse(f1449); });
+ List<T> Function([core.List<core.int> x1]) Function(int x) l1449;
+ Expect.throws(() { l1449 = (f1449 as dynamic); });
+ Expect.throws(() { l1449 = confuse(f1449); });
+ }
+ List<T> Function([core.List<core.int> x1]) Function(int x) l1449 = m1449;
+ // In checked mode, verifies the type.
+ x1449 = m1449;
+ x1449 = confuse(m1449);
+ }
+ }
+
+ void testF1549() {
+ // Function(int x, [int x1]) Function(int x)
+ Expect.isTrue(f1549 is F1549);
+ Expect.isTrue(confuse(f1549) is F1549);
+ // In checked mode, verifies the type.
+ Function(int x, [int x1]) Function(int x) l1549;
+ // The static function f1549 sets `T` to `int`.
+ if (!tIsBool) {
+ x1549 = f1549 as dynamic;
+ l1549 = f1549 as dynamic;
+ x1549 = confuse(f1549);
+ l1549 = confuse(f1549);
+ }
+
+ Expect.isTrue(m1549 is F1549);
+ Expect.isTrue(m1549 is Function(int x, [int x1]) Function(int x));
+ Expect.isTrue(confuse(m1549) is F1549);
+ // In checked mode, verifies the type.
+ x1549 = m1549;
+ l1549 = m1549;
+ x1549 = confuse(m1549);
+ l1549 = confuse(m1549);
+
+ }
+
+ void testF1649() {
+ // Function(int y, {List<Function> x}) Function(int x)
+ Expect.isTrue(f1649 is F1649);
+ Expect.isTrue(confuse(f1649) is F1649);
+ // In checked mode, verifies the type.
+ Function(int y, {List<Function> x}) Function(int x) l1649;
+ // The static function f1649 sets `T` to `int`.
+ if (!tIsBool) {
+ x1649 = f1649 as dynamic;
+ l1649 = f1649 as dynamic;
+ x1649 = confuse(f1649);
+ l1649 = confuse(f1649);
+ }
+
+ Expect.isTrue(m1649 is F1649);
+ Expect.isTrue(m1649 is Function(int y, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1649) is F1649);
+ // In checked mode, verifies the type.
+ x1649 = m1649;
+ l1649 = m1649;
+ x1649 = confuse(m1649);
+ l1649 = confuse(m1649);
+
+ }
+
+ void testF1749() {
+ // int Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1749 is F1749);
+ Expect.isTrue(confuse(f1749) is F1749);
+ // In checked mode, verifies the type.
+ int Function<A>(Function x) Function(int x) l1749;
+ // The static function f1749 sets `T` to `int`.
+ if (!tIsBool) {
+ x1749 = f1749 as dynamic;
+ l1749 = f1749 as dynamic;
+ x1749 = confuse(f1749);
+ l1749 = confuse(f1749);
+ }
+
+ Expect.isTrue(m1749 is F1749);
+ Expect.isTrue(m1749 is int Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1749) is F1749);
+ // In checked mode, verifies the type.
+ x1749 = m1749;
+ l1749 = m1749;
+ x1749 = confuse(m1749);
+ l1749 = confuse(m1749);
+
+ }
+
+ void testF1849() {
+ // core.List<core.int> Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1849 is F1849);
+ Expect.isTrue(confuse(f1849) is F1849);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<Function> x) Function(int x) l1849;
+ // The static function f1849 sets `T` to `int`.
+ if (!tIsBool) {
+ x1849 = f1849 as dynamic;
+ l1849 = f1849 as dynamic;
+ x1849 = confuse(f1849);
+ l1849 = confuse(f1849);
+ }
+
+ Expect.isTrue(m1849 is F1849);
+ Expect.isTrue(m1849 is core.List<core.int> Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1849) is F1849);
+ // In checked mode, verifies the type.
+ x1849 = m1849;
+ l1849 = m1849;
+ x1849 = confuse(m1849);
+ l1849 = confuse(m1849);
+
+ }
+
+ void testF1949() {
+ // A Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1949 is F1949);
+ Expect.isTrue(confuse(f1949) is F1949);
+ // In checked mode, verifies the type.
+ A Function<A>(core.List<core.int> x) Function(int x) l1949;
+ // The static function f1949 sets `T` to `int`.
+ if (!tIsBool) {
+ x1949 = f1949 as dynamic;
+ l1949 = f1949 as dynamic;
+ x1949 = confuse(f1949);
+ l1949 = confuse(f1949);
+ }
+
+ Expect.isTrue(m1949 is F1949);
+ Expect.isTrue(m1949 is A Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1949) is F1949);
+ // In checked mode, verifies the type.
+ x1949 = m1949;
+ l1949 = m1949;
+ x1949 = confuse(m1949);
+ l1949 = confuse(m1949);
+
+ }
+
+
+}
+
+class C50<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x1, [List<T> x2]) x50;
+ List<Function> Function([core.List<core.int> x1]) x150;
+ List<T> Function(List<Function> x0) x250;
+ Function Function<A>(A x) x350;
+ int Function([Function x]) Function<B extends core.int>() x450;
+ int Function(core.List<core.int> x1) Function<B extends core.int>() x550;
+ Function Function(int x2, [int x3]) Function<B extends core.int>() x650;
+ Function Function(int x1, {List<Function> x}) Function<B extends core.int>() x750;
+ List<Function> Function(int x) Function<B extends core.int>() x850;
+ List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>() x950;
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>() x1050;
+ core.List<core.int> Function({Function x}) Function<B extends core.int>() x1150;
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>() x1250;
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>() x1350;
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>() x1450;
+ Function(int x, [int x1]) Function<B extends core.int>() x1550;
+ Function(int y, {List<Function> x}) Function<B extends core.int>() x1650;
+ int Function<A>(Function x) Function<B extends core.int>() x1750;
+ core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>() x1850;
+ A Function<A>(core.List<core.int> x) Function<B extends core.int>() x1950;
+
+
+ C50({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m50(int x0, [List<T> x1]) => null;
+ List<Function> m150([core.List<core.int> x0]) => null;
+ List<T> m250(List<Function> x0) => null;
+ Function m350<A>(A x) => null;
+ int Function([Function x]) m450<B extends core.int>() => null;
+ int Function(core.List<core.int> x0) m550<B extends core.int>() => null;
+ Function Function(int x0, [int x1]) m650<B extends core.int>() => null;
+ Function Function(int x0, {List<Function> x}) m750<B extends core.int>() => null;
+ List<Function> Function(int x) m850<B extends core.int>() => null;
+ List<Function> Function(int y, [List<Function> x]) m950<B extends core.int>() => null;
+ List<Function> Function(int x0, [List<T> x1]) m1050<B extends core.int>() => null;
+ core.List<core.int> Function({Function x}) m1150<B extends core.int>() => null;
+ core.List<core.int> Function(List<T> x) m1250<B extends core.int>() => null;
+ List<T> Function(int x0, [Function x]) m1350<B extends core.int>() => null;
+ List<T> Function([core.List<core.int> x0]) m1450<B extends core.int>() => null;
+ Function(int x, [int x0]) m1550<B extends core.int>() => null;
+ Function(int y, {List<Function> x}) m1650<B extends core.int>() => null;
+ int Function<A>(Function x) m1750<B extends core.int>() => null;
+ core.List<core.int> Function<A>(List<Function> x) m1850<B extends core.int>() => null;
+ A Function<A>(core.List<core.int> x) m1950<B extends core.int>() => null;
+
+
+ runTests() {
+ testF50();
+ testF150();
+ testF250();
+ testF350();
+ testF450();
+ testF550();
+ testF650();
+ testF750();
+ testF850();
+ testF950();
+ testF1050();
+ testF1150();
+ testF1250();
+ testF1350();
+ testF1450();
+ testF1550();
+ testF1650();
+ testF1750();
+ testF1850();
+ testF1950();
+ }
+
+ void testF50() {
+ // int Function(int x1, [List<T> x2])
+ Expect.isTrue(f50 is F50);
+ Expect.isTrue(confuse(f50) is F50);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<T> x2]) l50;
+ // The static function f50 sets `T` to `int`.
+ if (!tIsBool) {
+ x50 = f50 as dynamic;
+ l50 = f50 as dynamic;
+ x50 = confuse(f50);
+ l50 = confuse(f50);
+ }
+
+ Expect.isTrue(m50 is F50);
+ Expect.isTrue(m50 is int Function(int x1, [List<T> x2]));
+ Expect.isTrue(confuse(m50) is F50);
+ // In checked mode, verifies the type.
+ x50 = m50;
+ l50 = m50;
+ x50 = confuse(m50);
+ l50 = confuse(m50);
+ if (!tIsBool) {
+ Expect.isTrue(f50 is F50<int>);
+ Expect.isFalse(f50 is F50<bool>);
+ Expect.isTrue(confuse(f50) is F50<int>);
+ Expect.isFalse(confuse(f50) is F50<bool>);
+ Expect.equals(tIsDynamic, m50 is F50<bool>);
+ Expect.equals(tIsDynamic, confuse(m50) is F50<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x50 = (f50 as dynamic); });
+ Expect.throws(() { x50 = confuse(f50); });
+ int Function(int x1, [List<T> x2]) l50;
+ Expect.throws(() { l50 = (f50 as dynamic); });
+ Expect.throws(() { l50 = confuse(f50); });
+ }
+ int Function(int x1, [List<T> x2]) l50 = m50;
+ // In checked mode, verifies the type.
+ x50 = m50;
+ x50 = confuse(m50);
+ }
+ }
+
+ void testF150() {
+ // List<Function> Function([core.List<core.int> x1])
+ Expect.isTrue(f150 is F150);
+ Expect.isTrue(confuse(f150) is F150);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x1]) l150;
+ // The static function f150 sets `T` to `int`.
+ if (!tIsBool) {
+ x150 = f150 as dynamic;
+ l150 = f150 as dynamic;
+ x150 = confuse(f150);
+ l150 = confuse(f150);
+ }
+
+ Expect.isTrue(m150 is F150);
+ Expect.isTrue(m150 is List<Function> Function([core.List<core.int> x1]));
+ Expect.isTrue(confuse(m150) is F150);
+ // In checked mode, verifies the type.
+ x150 = m150;
+ l150 = m150;
+ x150 = confuse(m150);
+ l150 = confuse(m150);
+
+ }
+
+ void testF250() {
+ // List<T> Function(List<Function> x0)
+ Expect.isTrue(f250 is F250);
+ Expect.isTrue(confuse(f250) is F250);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x0) l250;
+ // The static function f250 sets `T` to `int`.
+ if (!tIsBool) {
+ x250 = f250 as dynamic;
+ l250 = f250 as dynamic;
+ x250 = confuse(f250);
+ l250 = confuse(f250);
+ }
+
+ Expect.isTrue(m250 is F250);
+ Expect.isTrue(m250 is List<T> Function(List<Function> x0));
+ Expect.isTrue(confuse(m250) is F250);
+ // In checked mode, verifies the type.
+ x250 = m250;
+ l250 = m250;
+ x250 = confuse(m250);
+ l250 = confuse(m250);
+ if (!tIsBool) {
+ Expect.isTrue(f250 is F250<int>);
+ Expect.isFalse(f250 is F250<bool>);
+ Expect.isTrue(confuse(f250) is F250<int>);
+ Expect.isFalse(confuse(f250) is F250<bool>);
+ Expect.equals(tIsDynamic, m250 is F250<bool>);
+ Expect.equals(tIsDynamic, confuse(m250) is F250<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x250 = (f250 as dynamic); });
+ Expect.throws(() { x250 = confuse(f250); });
+ List<T> Function(List<Function> x0) l250;
+ Expect.throws(() { l250 = (f250 as dynamic); });
+ Expect.throws(() { l250 = confuse(f250); });
+ }
+ List<T> Function(List<Function> x0) l250 = m250;
+ // In checked mode, verifies the type.
+ x250 = m250;
+ x250 = confuse(m250);
+ }
+ }
+
+ void testF350() {
+ // Function Function<A>(A x)
+ Expect.isTrue(f350 is F350);
+ Expect.isTrue(confuse(f350) is F350);
+ // In checked mode, verifies the type.
+ Function Function<A>(A x) l350;
+ // The static function f350 sets `T` to `int`.
+ if (!tIsBool) {
+ x350 = f350 as dynamic;
+ l350 = f350 as dynamic;
+ x350 = confuse(f350);
+ l350 = confuse(f350);
+ }
+
+ Expect.isTrue(m350 is F350);
+ Expect.isTrue(m350 is Function Function<A>(A x));
+ Expect.isTrue(confuse(m350) is F350);
+ // In checked mode, verifies the type.
+ x350 = m350;
+ l350 = m350;
+ x350 = confuse(m350);
+ l350 = confuse(m350);
+
+ }
+
+ void testF450() {
+ // int Function([Function x]) Function<B extends core.int>()
+ Expect.isTrue(f450 is F450);
+ Expect.isTrue(confuse(f450) is F450);
+ // In checked mode, verifies the type.
+ int Function([Function x]) Function<B extends core.int>() l450;
+ // The static function f450 sets `T` to `int`.
+ if (!tIsBool) {
+ x450 = f450 as dynamic;
+ l450 = f450 as dynamic;
+ x450 = confuse(f450);
+ l450 = confuse(f450);
+ }
+
+ Expect.isTrue(m450 is F450);
+ Expect.isTrue(m450 is int Function([Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m450) is F450);
+ // In checked mode, verifies the type.
+ x450 = m450;
+ l450 = m450;
+ x450 = confuse(m450);
+ l450 = confuse(m450);
+
+ }
+
+ void testF550() {
+ // int Function(core.List<core.int> x1) Function<B extends core.int>()
+ Expect.isTrue(f550 is F550);
+ Expect.isTrue(confuse(f550) is F550);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x1) Function<B extends core.int>() l550;
+ // The static function f550 sets `T` to `int`.
+ if (!tIsBool) {
+ x550 = f550 as dynamic;
+ l550 = f550 as dynamic;
+ x550 = confuse(f550);
+ l550 = confuse(f550);
+ }
+
+ Expect.isTrue(m550 is F550);
+ Expect.isTrue(m550 is int Function(core.List<core.int> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m550) is F550);
+ // In checked mode, verifies the type.
+ x550 = m550;
+ l550 = m550;
+ x550 = confuse(m550);
+ l550 = confuse(m550);
+
+ }
+
+ void testF650() {
+ // Function Function(int x2, [int x3]) Function<B extends core.int>()
+ Expect.isTrue(f650 is F650);
+ Expect.isTrue(confuse(f650) is F650);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [int x3]) Function<B extends core.int>() l650;
+ // The static function f650 sets `T` to `int`.
+ if (!tIsBool) {
+ x650 = f650 as dynamic;
+ l650 = f650 as dynamic;
+ x650 = confuse(f650);
+ l650 = confuse(f650);
+ }
+
+ Expect.isTrue(m650 is F650);
+ Expect.isTrue(m650 is Function Function(int x2, [int x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m650) is F650);
+ // In checked mode, verifies the type.
+ x650 = m650;
+ l650 = m650;
+ x650 = confuse(m650);
+ l650 = confuse(m650);
+
+ }
+
+ void testF750() {
+ // Function Function(int x1, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f750 is F750);
+ Expect.isTrue(confuse(f750) is F750);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {List<Function> x}) Function<B extends core.int>() l750;
+ // The static function f750 sets `T` to `int`.
+ if (!tIsBool) {
+ x750 = f750 as dynamic;
+ l750 = f750 as dynamic;
+ x750 = confuse(f750);
+ l750 = confuse(f750);
+ }
+
+ Expect.isTrue(m750 is F750);
+ Expect.isTrue(m750 is Function Function(int x1, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m750) is F750);
+ // In checked mode, verifies the type.
+ x750 = m750;
+ l750 = m750;
+ x750 = confuse(m750);
+ l750 = confuse(m750);
+
+ }
+
+ void testF850() {
+ // List<Function> Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f850 is F850);
+ Expect.isTrue(confuse(f850) is F850);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x) Function<B extends core.int>() l850;
+ // The static function f850 sets `T` to `int`.
+ if (!tIsBool) {
+ x850 = f850 as dynamic;
+ l850 = f850 as dynamic;
+ x850 = confuse(f850);
+ l850 = confuse(f850);
+ }
+
+ Expect.isTrue(m850 is F850);
+ Expect.isTrue(m850 is List<Function> Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m850) is F850);
+ // In checked mode, verifies the type.
+ x850 = m850;
+ l850 = m850;
+ x850 = confuse(m850);
+ l850 = confuse(m850);
+
+ }
+
+ void testF950() {
+ // List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f950 is F950);
+ Expect.isTrue(confuse(f950) is F950);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>() l950;
+ // The static function f950 sets `T` to `int`.
+ if (!tIsBool) {
+ x950 = f950 as dynamic;
+ l950 = f950 as dynamic;
+ x950 = confuse(f950);
+ l950 = confuse(f950);
+ }
+
+ Expect.isTrue(m950 is F950);
+ Expect.isTrue(m950 is List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m950) is F950);
+ // In checked mode, verifies the type.
+ x950 = m950;
+ l950 = m950;
+ x950 = confuse(m950);
+ l950 = confuse(m950);
+
+ }
+
+ void testF1050() {
+ // List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1050 is F1050);
+ Expect.isTrue(confuse(f1050) is F1050);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1050;
+ // The static function f1050 sets `T` to `int`.
+ if (!tIsBool) {
+ x1050 = f1050 as dynamic;
+ l1050 = f1050 as dynamic;
+ x1050 = confuse(f1050);
+ l1050 = confuse(f1050);
+ }
+
+ Expect.isTrue(m1050 is F1050);
+ Expect.isTrue(m1050 is List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1050) is F1050);
+ // In checked mode, verifies the type.
+ x1050 = m1050;
+ l1050 = m1050;
+ x1050 = confuse(m1050);
+ l1050 = confuse(m1050);
+ if (!tIsBool) {
+ Expect.isTrue(f1050 is F1050<int>);
+ Expect.isFalse(f1050 is F1050<bool>);
+ Expect.isTrue(confuse(f1050) is F1050<int>);
+ Expect.isFalse(confuse(f1050) is F1050<bool>);
+ Expect.equals(tIsDynamic, m1050 is F1050<bool>);
+ Expect.equals(tIsDynamic, confuse(m1050) is F1050<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1050 = (f1050 as dynamic); });
+ Expect.throws(() { x1050 = confuse(f1050); });
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1050;
+ Expect.throws(() { l1050 = (f1050 as dynamic); });
+ Expect.throws(() { l1050 = confuse(f1050); });
+ }
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1050 = m1050;
+ // In checked mode, verifies the type.
+ x1050 = m1050;
+ x1050 = confuse(m1050);
+ }
+ }
+
+ void testF1150() {
+ // core.List<core.int> Function({Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1150 is F1150);
+ Expect.isTrue(confuse(f1150) is F1150);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({Function x}) Function<B extends core.int>() l1150;
+ // The static function f1150 sets `T` to `int`.
+ if (!tIsBool) {
+ x1150 = f1150 as dynamic;
+ l1150 = f1150 as dynamic;
+ x1150 = confuse(f1150);
+ l1150 = confuse(f1150);
+ }
+
+ Expect.isTrue(m1150 is F1150);
+ Expect.isTrue(m1150 is core.List<core.int> Function({Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1150) is F1150);
+ // In checked mode, verifies the type.
+ x1150 = m1150;
+ l1150 = m1150;
+ x1150 = confuse(m1150);
+ l1150 = confuse(m1150);
+
+ }
+
+ void testF1250() {
+ // core.List<core.int> Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1250 is F1250);
+ Expect.isTrue(confuse(f1250) is F1250);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>() l1250;
+ // The static function f1250 sets `T` to `int`.
+ if (!tIsBool) {
+ x1250 = f1250 as dynamic;
+ l1250 = f1250 as dynamic;
+ x1250 = confuse(f1250);
+ l1250 = confuse(f1250);
+ }
+
+ Expect.isTrue(m1250 is F1250);
+ Expect.isTrue(m1250 is core.List<core.int> Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1250) is F1250);
+ // In checked mode, verifies the type.
+ x1250 = m1250;
+ l1250 = m1250;
+ x1250 = confuse(m1250);
+ l1250 = confuse(m1250);
+ if (!tIsBool) {
+ Expect.isTrue(f1250 is F1250<int>);
+ Expect.isFalse(f1250 is F1250<bool>);
+ Expect.isTrue(confuse(f1250) is F1250<int>);
+ Expect.isFalse(confuse(f1250) is F1250<bool>);
+ Expect.equals(tIsDynamic, m1250 is F1250<bool>);
+ Expect.equals(tIsDynamic, confuse(m1250) is F1250<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1250 = (f1250 as dynamic); });
+ Expect.throws(() { x1250 = confuse(f1250); });
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>() l1250;
+ Expect.throws(() { l1250 = (f1250 as dynamic); });
+ Expect.throws(() { l1250 = confuse(f1250); });
+ }
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>() l1250 = m1250;
+ // In checked mode, verifies the type.
+ x1250 = m1250;
+ x1250 = confuse(m1250);
+ }
+ }
+
+ void testF1350() {
+ // List<T> Function(int x1, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1350 is F1350);
+ Expect.isTrue(confuse(f1350) is F1350);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>() l1350;
+ // The static function f1350 sets `T` to `int`.
+ if (!tIsBool) {
+ x1350 = f1350 as dynamic;
+ l1350 = f1350 as dynamic;
+ x1350 = confuse(f1350);
+ l1350 = confuse(f1350);
+ }
+
+ Expect.isTrue(m1350 is F1350);
+ Expect.isTrue(m1350 is List<T> Function(int x1, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1350) is F1350);
+ // In checked mode, verifies the type.
+ x1350 = m1350;
+ l1350 = m1350;
+ x1350 = confuse(m1350);
+ l1350 = confuse(m1350);
+ if (!tIsBool) {
+ Expect.isTrue(f1350 is F1350<int>);
+ Expect.isFalse(f1350 is F1350<bool>);
+ Expect.isTrue(confuse(f1350) is F1350<int>);
+ Expect.isFalse(confuse(f1350) is F1350<bool>);
+ Expect.equals(tIsDynamic, m1350 is F1350<bool>);
+ Expect.equals(tIsDynamic, confuse(m1350) is F1350<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1350 = (f1350 as dynamic); });
+ Expect.throws(() { x1350 = confuse(f1350); });
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>() l1350;
+ Expect.throws(() { l1350 = (f1350 as dynamic); });
+ Expect.throws(() { l1350 = confuse(f1350); });
+ }
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>() l1350 = m1350;
+ // In checked mode, verifies the type.
+ x1350 = m1350;
+ x1350 = confuse(m1350);
+ }
+ }
+
+ void testF1450() {
+ // List<T> Function([core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1450 is F1450);
+ Expect.isTrue(confuse(f1450) is F1450);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>() l1450;
+ // The static function f1450 sets `T` to `int`.
+ if (!tIsBool) {
+ x1450 = f1450 as dynamic;
+ l1450 = f1450 as dynamic;
+ x1450 = confuse(f1450);
+ l1450 = confuse(f1450);
+ }
+
+ Expect.isTrue(m1450 is F1450);
+ Expect.isTrue(m1450 is List<T> Function([core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1450) is F1450);
+ // In checked mode, verifies the type.
+ x1450 = m1450;
+ l1450 = m1450;
+ x1450 = confuse(m1450);
+ l1450 = confuse(m1450);
+ if (!tIsBool) {
+ Expect.isTrue(f1450 is F1450<int>);
+ Expect.isFalse(f1450 is F1450<bool>);
+ Expect.isTrue(confuse(f1450) is F1450<int>);
+ Expect.isFalse(confuse(f1450) is F1450<bool>);
+ Expect.equals(tIsDynamic, m1450 is F1450<bool>);
+ Expect.equals(tIsDynamic, confuse(m1450) is F1450<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1450 = (f1450 as dynamic); });
+ Expect.throws(() { x1450 = confuse(f1450); });
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>() l1450;
+ Expect.throws(() { l1450 = (f1450 as dynamic); });
+ Expect.throws(() { l1450 = confuse(f1450); });
+ }
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>() l1450 = m1450;
+ // In checked mode, verifies the type.
+ x1450 = m1450;
+ x1450 = confuse(m1450);
+ }
+ }
+
+ void testF1550() {
+ // Function(int x, [int x1]) Function<B extends core.int>()
+ Expect.isTrue(f1550 is F1550);
+ Expect.isTrue(confuse(f1550) is F1550);
+ // In checked mode, verifies the type.
+ Function(int x, [int x1]) Function<B extends core.int>() l1550;
+ // The static function f1550 sets `T` to `int`.
+ if (!tIsBool) {
+ x1550 = f1550 as dynamic;
+ l1550 = f1550 as dynamic;
+ x1550 = confuse(f1550);
+ l1550 = confuse(f1550);
+ }
+
+ Expect.isTrue(m1550 is F1550);
+ Expect.isTrue(m1550 is Function(int x, [int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1550) is F1550);
+ // In checked mode, verifies the type.
+ x1550 = m1550;
+ l1550 = m1550;
+ x1550 = confuse(m1550);
+ l1550 = confuse(m1550);
+
+ }
+
+ void testF1650() {
+ // Function(int y, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1650 is F1650);
+ Expect.isTrue(confuse(f1650) is F1650);
+ // In checked mode, verifies the type.
+ Function(int y, {List<Function> x}) Function<B extends core.int>() l1650;
+ // The static function f1650 sets `T` to `int`.
+ if (!tIsBool) {
+ x1650 = f1650 as dynamic;
+ l1650 = f1650 as dynamic;
+ x1650 = confuse(f1650);
+ l1650 = confuse(f1650);
+ }
+
+ Expect.isTrue(m1650 is F1650);
+ Expect.isTrue(m1650 is Function(int y, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1650) is F1650);
+ // In checked mode, verifies the type.
+ x1650 = m1650;
+ l1650 = m1650;
+ x1650 = confuse(m1650);
+ l1650 = confuse(m1650);
+
+ }
+
+ void testF1750() {
+ // int Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1750 is F1750);
+ Expect.isTrue(confuse(f1750) is F1750);
+ // In checked mode, verifies the type.
+ int Function<A>(Function x) Function<B extends core.int>() l1750;
+ // The static function f1750 sets `T` to `int`.
+ if (!tIsBool) {
+ x1750 = f1750 as dynamic;
+ l1750 = f1750 as dynamic;
+ x1750 = confuse(f1750);
+ l1750 = confuse(f1750);
+ }
+
+ Expect.isTrue(m1750 is F1750);
+ Expect.isTrue(m1750 is int Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1750) is F1750);
+ // In checked mode, verifies the type.
+ x1750 = m1750;
+ l1750 = m1750;
+ x1750 = confuse(m1750);
+ l1750 = confuse(m1750);
+
+ }
+
+ void testF1850() {
+ // core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1850 is F1850);
+ Expect.isTrue(confuse(f1850) is F1850);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>() l1850;
+ // The static function f1850 sets `T` to `int`.
+ if (!tIsBool) {
+ x1850 = f1850 as dynamic;
+ l1850 = f1850 as dynamic;
+ x1850 = confuse(f1850);
+ l1850 = confuse(f1850);
+ }
+
+ Expect.isTrue(m1850 is F1850);
+ Expect.isTrue(m1850 is core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1850) is F1850);
+ // In checked mode, verifies the type.
+ x1850 = m1850;
+ l1850 = m1850;
+ x1850 = confuse(m1850);
+ l1850 = confuse(m1850);
+
+ }
+
+ void testF1950() {
+ // A Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1950 is F1950);
+ Expect.isTrue(confuse(f1950) is F1950);
+ // In checked mode, verifies the type.
+ A Function<A>(core.List<core.int> x) Function<B extends core.int>() l1950;
+ // The static function f1950 sets `T` to `int`.
+ if (!tIsBool) {
+ x1950 = f1950 as dynamic;
+ l1950 = f1950 as dynamic;
+ x1950 = confuse(f1950);
+ l1950 = confuse(f1950);
+ }
+
+ Expect.isTrue(m1950 is F1950);
+ Expect.isTrue(m1950 is A Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1950) is F1950);
+ // In checked mode, verifies the type.
+ x1950 = m1950;
+ l1950 = m1950;
+ x1950 = confuse(m1950);
+ l1950 = confuse(m1950);
+
+ }
+
+
+}
+
+class C51<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x, [List<T> x2]) x51;
+ List<Function> Function(int x1, [core.List<core.int> x2]) x151;
+ List<T> Function([List<Function> x1]) x251;
+ Function Function<A>(List<A> x) x351;
+ int Function([Function x]) Function<B extends core.int>(int x) x451;
+ int Function(core.List<core.int> x1) Function<B extends core.int>(int x) x551;
+ Function Function(int x2, [int x3]) Function<B extends core.int>(int x) x651;
+ Function Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) x751;
+ List<Function> Function(int x) Function<B extends core.int>(int x) x851;
+ List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) x951;
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) x1051;
+ core.List<core.int> Function({Function x}) Function<B extends core.int>(int x) x1151;
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x) x1251;
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x) x1351;
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) x1451;
+ Function(int x, [int x1]) Function<B extends core.int>(int x) x1551;
+ Function(int y, {List<Function> x}) Function<B extends core.int>(int x) x1651;
+ int Function<A>(Function x) Function<B extends core.int>(int x) x1751;
+ core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>(int x) x1851;
+ A Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1951;
+
+
+ C51({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m51(int x, [List<T> x0]) => null;
+ List<Function> m151(int x0, [core.List<core.int> x1]) => null;
+ List<T> m251([List<Function> x0]) => null;
+ Function m351<A>(List<A> x) => null;
+ int Function([Function x]) m451<B extends core.int>(int x) => null;
+ int Function(core.List<core.int> x0) m551<B extends core.int>(int x) => null;
+ Function Function(int x0, [int x1]) m651<B extends core.int>(int x) => null;
+ Function Function(int x0, {List<Function> x}) m751<B extends core.int>(int x) => null;
+ List<Function> Function(int x) m851<B extends core.int>(int x) => null;
+ List<Function> Function(int y, [List<Function> x]) m951<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [List<T> x1]) m1051<B extends core.int>(int x) => null;
+ core.List<core.int> Function({Function x}) m1151<B extends core.int>(int x) => null;
+ core.List<core.int> Function(List<T> x) m1251<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [Function x]) m1351<B extends core.int>(int x) => null;
+ List<T> Function([core.List<core.int> x0]) m1451<B extends core.int>(int x) => null;
+ Function(int x, [int x0]) m1551<B extends core.int>(int x) => null;
+ Function(int y, {List<Function> x}) m1651<B extends core.int>(int x) => null;
+ int Function<A>(Function x) m1751<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(List<Function> x) m1851<B extends core.int>(int x) => null;
+ A Function<A>(core.List<core.int> x) m1951<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF51();
+ testF151();
+ testF251();
+ testF351();
+ testF451();
+ testF551();
+ testF651();
+ testF751();
+ testF851();
+ testF951();
+ testF1051();
+ testF1151();
+ testF1251();
+ testF1351();
+ testF1451();
+ testF1551();
+ testF1651();
+ testF1751();
+ testF1851();
+ testF1951();
+ }
+
+ void testF51() {
+ // int Function(int x, [List<T> x2])
+ Expect.isTrue(f51 is F51);
+ Expect.isTrue(confuse(f51) is F51);
+ // In checked mode, verifies the type.
+ int Function(int x, [List<T> x2]) l51;
+ // The static function f51 sets `T` to `int`.
+ if (!tIsBool) {
+ x51 = f51 as dynamic;
+ l51 = f51 as dynamic;
+ x51 = confuse(f51);
+ l51 = confuse(f51);
+ }
+
+ Expect.isTrue(m51 is F51);
+ Expect.isTrue(m51 is int Function(int x, [List<T> x2]));
+ Expect.isTrue(confuse(m51) is F51);
+ // In checked mode, verifies the type.
+ x51 = m51;
+ l51 = m51;
+ x51 = confuse(m51);
+ l51 = confuse(m51);
+ if (!tIsBool) {
+ Expect.isTrue(f51 is F51<int>);
+ Expect.isFalse(f51 is F51<bool>);
+ Expect.isTrue(confuse(f51) is F51<int>);
+ Expect.isFalse(confuse(f51) is F51<bool>);
+ Expect.equals(tIsDynamic, m51 is F51<bool>);
+ Expect.equals(tIsDynamic, confuse(m51) is F51<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x51 = (f51 as dynamic); });
+ Expect.throws(() { x51 = confuse(f51); });
+ int Function(int x, [List<T> x2]) l51;
+ Expect.throws(() { l51 = (f51 as dynamic); });
+ Expect.throws(() { l51 = confuse(f51); });
+ }
+ int Function(int x, [List<T> x2]) l51 = m51;
+ // In checked mode, verifies the type.
+ x51 = m51;
+ x51 = confuse(m51);
+ }
+ }
+
+ void testF151() {
+ // List<Function> Function(int x1, [core.List<core.int> x2])
+ Expect.isTrue(f151 is F151);
+ Expect.isTrue(confuse(f151) is F151);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [core.List<core.int> x2]) l151;
+ // The static function f151 sets `T` to `int`.
+ if (!tIsBool) {
+ x151 = f151 as dynamic;
+ l151 = f151 as dynamic;
+ x151 = confuse(f151);
+ l151 = confuse(f151);
+ }
+
+ Expect.isTrue(m151 is F151);
+ Expect.isTrue(m151 is List<Function> Function(int x1, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m151) is F151);
+ // In checked mode, verifies the type.
+ x151 = m151;
+ l151 = m151;
+ x151 = confuse(m151);
+ l151 = confuse(m151);
+
+ }
+
+ void testF251() {
+ // List<T> Function([List<Function> x1])
+ Expect.isTrue(f251 is F251);
+ Expect.isTrue(confuse(f251) is F251);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x1]) l251;
+ // The static function f251 sets `T` to `int`.
+ if (!tIsBool) {
+ x251 = f251 as dynamic;
+ l251 = f251 as dynamic;
+ x251 = confuse(f251);
+ l251 = confuse(f251);
+ }
+
+ Expect.isTrue(m251 is F251);
+ Expect.isTrue(m251 is List<T> Function([List<Function> x1]));
+ Expect.isTrue(confuse(m251) is F251);
+ // In checked mode, verifies the type.
+ x251 = m251;
+ l251 = m251;
+ x251 = confuse(m251);
+ l251 = confuse(m251);
+ if (!tIsBool) {
+ Expect.isTrue(f251 is F251<int>);
+ Expect.isFalse(f251 is F251<bool>);
+ Expect.isTrue(confuse(f251) is F251<int>);
+ Expect.isFalse(confuse(f251) is F251<bool>);
+ Expect.equals(tIsDynamic, m251 is F251<bool>);
+ Expect.equals(tIsDynamic, confuse(m251) is F251<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x251 = (f251 as dynamic); });
+ Expect.throws(() { x251 = confuse(f251); });
+ List<T> Function([List<Function> x1]) l251;
+ Expect.throws(() { l251 = (f251 as dynamic); });
+ Expect.throws(() { l251 = confuse(f251); });
+ }
+ List<T> Function([List<Function> x1]) l251 = m251;
+ // In checked mode, verifies the type.
+ x251 = m251;
+ x251 = confuse(m251);
+ }
+ }
+
+ void testF351() {
+ // Function Function<A>(List<A> x)
+ Expect.isTrue(f351 is F351);
+ Expect.isTrue(confuse(f351) is F351);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<A> x) l351;
+ // The static function f351 sets `T` to `int`.
+ if (!tIsBool) {
+ x351 = f351 as dynamic;
+ l351 = f351 as dynamic;
+ x351 = confuse(f351);
+ l351 = confuse(f351);
+ }
+
+ Expect.isTrue(m351 is F351);
+ Expect.isTrue(m351 is Function Function<A>(List<A> x));
+ Expect.isTrue(confuse(m351) is F351);
+ // In checked mode, verifies the type.
+ x351 = m351;
+ l351 = m351;
+ x351 = confuse(m351);
+ l351 = confuse(m351);
+
+ }
+
+ void testF451() {
+ // int Function([Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f451 is F451);
+ Expect.isTrue(confuse(f451) is F451);
+ // In checked mode, verifies the type.
+ int Function([Function x]) Function<B extends core.int>(int x) l451;
+ // The static function f451 sets `T` to `int`.
+ if (!tIsBool) {
+ x451 = f451 as dynamic;
+ l451 = f451 as dynamic;
+ x451 = confuse(f451);
+ l451 = confuse(f451);
+ }
+
+ Expect.isTrue(m451 is F451);
+ Expect.isTrue(m451 is int Function([Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m451) is F451);
+ // In checked mode, verifies the type.
+ x451 = m451;
+ l451 = m451;
+ x451 = confuse(m451);
+ l451 = confuse(m451);
+
+ }
+
+ void testF551() {
+ // int Function(core.List<core.int> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f551 is F551);
+ Expect.isTrue(confuse(f551) is F551);
+ // In checked mode, verifies the type.
+ int Function(core.List<core.int> x1) Function<B extends core.int>(int x) l551;
+ // The static function f551 sets `T` to `int`.
+ if (!tIsBool) {
+ x551 = f551 as dynamic;
+ l551 = f551 as dynamic;
+ x551 = confuse(f551);
+ l551 = confuse(f551);
+ }
+
+ Expect.isTrue(m551 is F551);
+ Expect.isTrue(m551 is int Function(core.List<core.int> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m551) is F551);
+ // In checked mode, verifies the type.
+ x551 = m551;
+ l551 = m551;
+ x551 = confuse(m551);
+ l551 = confuse(m551);
+
+ }
+
+ void testF651() {
+ // Function Function(int x2, [int x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f651 is F651);
+ Expect.isTrue(confuse(f651) is F651);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [int x3]) Function<B extends core.int>(int x) l651;
+ // The static function f651 sets `T` to `int`.
+ if (!tIsBool) {
+ x651 = f651 as dynamic;
+ l651 = f651 as dynamic;
+ x651 = confuse(f651);
+ l651 = confuse(f651);
+ }
+
+ Expect.isTrue(m651 is F651);
+ Expect.isTrue(m651 is Function Function(int x2, [int x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m651) is F651);
+ // In checked mode, verifies the type.
+ x651 = m651;
+ l651 = m651;
+ x651 = confuse(m651);
+ l651 = confuse(m651);
+
+ }
+
+ void testF751() {
+ // Function Function(int x1, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f751 is F751);
+ Expect.isTrue(confuse(f751) is F751);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l751;
+ // The static function f751 sets `T` to `int`.
+ if (!tIsBool) {
+ x751 = f751 as dynamic;
+ l751 = f751 as dynamic;
+ x751 = confuse(f751);
+ l751 = confuse(f751);
+ }
+
+ Expect.isTrue(m751 is F751);
+ Expect.isTrue(m751 is Function Function(int x1, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m751) is F751);
+ // In checked mode, verifies the type.
+ x751 = m751;
+ l751 = m751;
+ x751 = confuse(m751);
+ l751 = confuse(m751);
+
+ }
+
+ void testF851() {
+ // List<Function> Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f851 is F851);
+ Expect.isTrue(confuse(f851) is F851);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x) Function<B extends core.int>(int x) l851;
+ // The static function f851 sets `T` to `int`.
+ if (!tIsBool) {
+ x851 = f851 as dynamic;
+ l851 = f851 as dynamic;
+ x851 = confuse(f851);
+ l851 = confuse(f851);
+ }
+
+ Expect.isTrue(m851 is F851);
+ Expect.isTrue(m851 is List<Function> Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m851) is F851);
+ // In checked mode, verifies the type.
+ x851 = m851;
+ l851 = m851;
+ x851 = confuse(m851);
+ l851 = confuse(m851);
+
+ }
+
+ void testF951() {
+ // List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f951 is F951);
+ Expect.isTrue(confuse(f951) is F951);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l951;
+ // The static function f951 sets `T` to `int`.
+ if (!tIsBool) {
+ x951 = f951 as dynamic;
+ l951 = f951 as dynamic;
+ x951 = confuse(f951);
+ l951 = confuse(f951);
+ }
+
+ Expect.isTrue(m951 is F951);
+ Expect.isTrue(m951 is List<Function> Function(int y, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m951) is F951);
+ // In checked mode, verifies the type.
+ x951 = m951;
+ l951 = m951;
+ x951 = confuse(m951);
+ l951 = confuse(m951);
+
+ }
+
+ void testF1051() {
+ // List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1051 is F1051);
+ Expect.isTrue(confuse(f1051) is F1051);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1051;
+ // The static function f1051 sets `T` to `int`.
+ if (!tIsBool) {
+ x1051 = f1051 as dynamic;
+ l1051 = f1051 as dynamic;
+ x1051 = confuse(f1051);
+ l1051 = confuse(f1051);
+ }
+
+ Expect.isTrue(m1051 is F1051);
+ Expect.isTrue(m1051 is List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1051) is F1051);
+ // In checked mode, verifies the type.
+ x1051 = m1051;
+ l1051 = m1051;
+ x1051 = confuse(m1051);
+ l1051 = confuse(m1051);
+ if (!tIsBool) {
+ Expect.isTrue(f1051 is F1051<int>);
+ Expect.isFalse(f1051 is F1051<bool>);
+ Expect.isTrue(confuse(f1051) is F1051<int>);
+ Expect.isFalse(confuse(f1051) is F1051<bool>);
+ Expect.equals(tIsDynamic, m1051 is F1051<bool>);
+ Expect.equals(tIsDynamic, confuse(m1051) is F1051<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1051 = (f1051 as dynamic); });
+ Expect.throws(() { x1051 = confuse(f1051); });
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1051;
+ Expect.throws(() { l1051 = (f1051 as dynamic); });
+ Expect.throws(() { l1051 = confuse(f1051); });
+ }
+ List<Function> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1051 = m1051;
+ // In checked mode, verifies the type.
+ x1051 = m1051;
+ x1051 = confuse(m1051);
+ }
+ }
+
+ void testF1151() {
+ // core.List<core.int> Function({Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1151 is F1151);
+ Expect.isTrue(confuse(f1151) is F1151);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({Function x}) Function<B extends core.int>(int x) l1151;
+ // The static function f1151 sets `T` to `int`.
+ if (!tIsBool) {
+ x1151 = f1151 as dynamic;
+ l1151 = f1151 as dynamic;
+ x1151 = confuse(f1151);
+ l1151 = confuse(f1151);
+ }
+
+ Expect.isTrue(m1151 is F1151);
+ Expect.isTrue(m1151 is core.List<core.int> Function({Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1151) is F1151);
+ // In checked mode, verifies the type.
+ x1151 = m1151;
+ l1151 = m1151;
+ x1151 = confuse(m1151);
+ l1151 = confuse(m1151);
+
+ }
+
+ void testF1251() {
+ // core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1251 is F1251);
+ Expect.isTrue(confuse(f1251) is F1251);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x) l1251;
+ // The static function f1251 sets `T` to `int`.
+ if (!tIsBool) {
+ x1251 = f1251 as dynamic;
+ l1251 = f1251 as dynamic;
+ x1251 = confuse(f1251);
+ l1251 = confuse(f1251);
+ }
+
+ Expect.isTrue(m1251 is F1251);
+ Expect.isTrue(m1251 is core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1251) is F1251);
+ // In checked mode, verifies the type.
+ x1251 = m1251;
+ l1251 = m1251;
+ x1251 = confuse(m1251);
+ l1251 = confuse(m1251);
+ if (!tIsBool) {
+ Expect.isTrue(f1251 is F1251<int>);
+ Expect.isFalse(f1251 is F1251<bool>);
+ Expect.isTrue(confuse(f1251) is F1251<int>);
+ Expect.isFalse(confuse(f1251) is F1251<bool>);
+ Expect.equals(tIsDynamic, m1251 is F1251<bool>);
+ Expect.equals(tIsDynamic, confuse(m1251) is F1251<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1251 = (f1251 as dynamic); });
+ Expect.throws(() { x1251 = confuse(f1251); });
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x) l1251;
+ Expect.throws(() { l1251 = (f1251 as dynamic); });
+ Expect.throws(() { l1251 = confuse(f1251); });
+ }
+ core.List<core.int> Function(List<T> x) Function<B extends core.int>(int x) l1251 = m1251;
+ // In checked mode, verifies the type.
+ x1251 = m1251;
+ x1251 = confuse(m1251);
+ }
+ }
+
+ void testF1351() {
+ // List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1351 is F1351);
+ Expect.isTrue(confuse(f1351) is F1351);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x) l1351;
+ // The static function f1351 sets `T` to `int`.
+ if (!tIsBool) {
+ x1351 = f1351 as dynamic;
+ l1351 = f1351 as dynamic;
+ x1351 = confuse(f1351);
+ l1351 = confuse(f1351);
+ }
+
+ Expect.isTrue(m1351 is F1351);
+ Expect.isTrue(m1351 is List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1351) is F1351);
+ // In checked mode, verifies the type.
+ x1351 = m1351;
+ l1351 = m1351;
+ x1351 = confuse(m1351);
+ l1351 = confuse(m1351);
+ if (!tIsBool) {
+ Expect.isTrue(f1351 is F1351<int>);
+ Expect.isFalse(f1351 is F1351<bool>);
+ Expect.isTrue(confuse(f1351) is F1351<int>);
+ Expect.isFalse(confuse(f1351) is F1351<bool>);
+ Expect.equals(tIsDynamic, m1351 is F1351<bool>);
+ Expect.equals(tIsDynamic, confuse(m1351) is F1351<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1351 = (f1351 as dynamic); });
+ Expect.throws(() { x1351 = confuse(f1351); });
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x) l1351;
+ Expect.throws(() { l1351 = (f1351 as dynamic); });
+ Expect.throws(() { l1351 = confuse(f1351); });
+ }
+ List<T> Function(int x1, [Function x]) Function<B extends core.int>(int x) l1351 = m1351;
+ // In checked mode, verifies the type.
+ x1351 = m1351;
+ x1351 = confuse(m1351);
+ }
+ }
+
+ void testF1451() {
+ // List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1451 is F1451);
+ Expect.isTrue(confuse(f1451) is F1451);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l1451;
+ // The static function f1451 sets `T` to `int`.
+ if (!tIsBool) {
+ x1451 = f1451 as dynamic;
+ l1451 = f1451 as dynamic;
+ x1451 = confuse(f1451);
+ l1451 = confuse(f1451);
+ }
+
+ Expect.isTrue(m1451 is F1451);
+ Expect.isTrue(m1451 is List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1451) is F1451);
+ // In checked mode, verifies the type.
+ x1451 = m1451;
+ l1451 = m1451;
+ x1451 = confuse(m1451);
+ l1451 = confuse(m1451);
+ if (!tIsBool) {
+ Expect.isTrue(f1451 is F1451<int>);
+ Expect.isFalse(f1451 is F1451<bool>);
+ Expect.isTrue(confuse(f1451) is F1451<int>);
+ Expect.isFalse(confuse(f1451) is F1451<bool>);
+ Expect.equals(tIsDynamic, m1451 is F1451<bool>);
+ Expect.equals(tIsDynamic, confuse(m1451) is F1451<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1451 = (f1451 as dynamic); });
+ Expect.throws(() { x1451 = confuse(f1451); });
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l1451;
+ Expect.throws(() { l1451 = (f1451 as dynamic); });
+ Expect.throws(() { l1451 = confuse(f1451); });
+ }
+ List<T> Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l1451 = m1451;
+ // In checked mode, verifies the type.
+ x1451 = m1451;
+ x1451 = confuse(m1451);
+ }
+ }
+
+ void testF1551() {
+ // Function(int x, [int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1551 is F1551);
+ Expect.isTrue(confuse(f1551) is F1551);
+ // In checked mode, verifies the type.
+ Function(int x, [int x1]) Function<B extends core.int>(int x) l1551;
+ // The static function f1551 sets `T` to `int`.
+ if (!tIsBool) {
+ x1551 = f1551 as dynamic;
+ l1551 = f1551 as dynamic;
+ x1551 = confuse(f1551);
+ l1551 = confuse(f1551);
+ }
+
+ Expect.isTrue(m1551 is F1551);
+ Expect.isTrue(m1551 is Function(int x, [int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1551) is F1551);
+ // In checked mode, verifies the type.
+ x1551 = m1551;
+ l1551 = m1551;
+ x1551 = confuse(m1551);
+ l1551 = confuse(m1551);
+
+ }
+
+ void testF1651() {
+ // Function(int y, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1651 is F1651);
+ Expect.isTrue(confuse(f1651) is F1651);
+ // In checked mode, verifies the type.
+ Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l1651;
+ // The static function f1651 sets `T` to `int`.
+ if (!tIsBool) {
+ x1651 = f1651 as dynamic;
+ l1651 = f1651 as dynamic;
+ x1651 = confuse(f1651);
+ l1651 = confuse(f1651);
+ }
+
+ Expect.isTrue(m1651 is F1651);
+ Expect.isTrue(m1651 is Function(int y, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1651) is F1651);
+ // In checked mode, verifies the type.
+ x1651 = m1651;
+ l1651 = m1651;
+ x1651 = confuse(m1651);
+ l1651 = confuse(m1651);
+
+ }
+
+ void testF1751() {
+ // int Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1751 is F1751);
+ Expect.isTrue(confuse(f1751) is F1751);
+ // In checked mode, verifies the type.
+ int Function<A>(Function x) Function<B extends core.int>(int x) l1751;
+ // The static function f1751 sets `T` to `int`.
+ if (!tIsBool) {
+ x1751 = f1751 as dynamic;
+ l1751 = f1751 as dynamic;
+ x1751 = confuse(f1751);
+ l1751 = confuse(f1751);
+ }
+
+ Expect.isTrue(m1751 is F1751);
+ Expect.isTrue(m1751 is int Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1751) is F1751);
+ // In checked mode, verifies the type.
+ x1751 = m1751;
+ l1751 = m1751;
+ x1751 = confuse(m1751);
+ l1751 = confuse(m1751);
+
+ }
+
+ void testF1851() {
+ // core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1851 is F1851);
+ Expect.isTrue(confuse(f1851) is F1851);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>(int x) l1851;
+ // The static function f1851 sets `T` to `int`.
+ if (!tIsBool) {
+ x1851 = f1851 as dynamic;
+ l1851 = f1851 as dynamic;
+ x1851 = confuse(f1851);
+ l1851 = confuse(f1851);
+ }
+
+ Expect.isTrue(m1851 is F1851);
+ Expect.isTrue(m1851 is core.List<core.int> Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1851) is F1851);
+ // In checked mode, verifies the type.
+ x1851 = m1851;
+ l1851 = m1851;
+ x1851 = confuse(m1851);
+ l1851 = confuse(m1851);
+
+ }
+
+ void testF1951() {
+ // A Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1951 is F1951);
+ Expect.isTrue(confuse(f1951) is F1951);
+ // In checked mode, verifies the type.
+ A Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1951;
+ // The static function f1951 sets `T` to `int`.
+ if (!tIsBool) {
+ x1951 = f1951 as dynamic;
+ l1951 = f1951 as dynamic;
+ x1951 = confuse(f1951);
+ l1951 = confuse(f1951);
+ }
+
+ Expect.isTrue(m1951 is F1951);
+ Expect.isTrue(m1951 is A Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1951) is F1951);
+ // In checked mode, verifies the type.
+ x1951 = m1951;
+ l1951 = m1951;
+ x1951 = confuse(m1951);
+ l1951 = confuse(m1951);
+
+ }
+
+
+}
+
+class C52<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function({List<T> x}) x52;
+ List<Function> Function(int x, [core.List<core.int> x2]) x152;
+ List<T> Function(int x1, [List<Function> x2]) x252;
+ List<Function> Function<A>(int x) x352;
+ int Function(int x0, [Function x]) Function() x452;
+ int Function([core.List<core.int> x1]) Function() x552;
+ Function Function(int x, [int x2]) Function() x652;
+ Function Function(int y, {List<Function> x}) Function() x752;
+ List<Function> Function([int x]) Function() x852;
+ List<Function> Function(List<Function> x0) Function() x952;
+ List<Function> Function(int x, [List<T> x2]) Function() x1052;
+ core.List<core.int> Function(int x0, {Function x}) Function() x1152;
+ core.List<core.int> Function([List<T> x]) Function() x1252;
+ List<T> Function(int y, [Function x]) Function() x1352;
+ List<T> Function(int x1, [core.List<core.int> x2]) Function() x1452;
+ Function({int x}) Function() x1552;
+ Function(core.List<core.int> x) Function() x1652;
+ int Function<A>(List<Function> x) Function() x1752;
+ core.List<core.int> Function<A>(core.List<core.int> x) Function() x1852;
+ A Function<A>(List<T> x) Function() x1952;
+
+
+ C52({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m52({List<T> x}) => null;
+ List<Function> m152(int x, [core.List<core.int> x0]) => null;
+ List<T> m252(int x0, [List<Function> x1]) => null;
+ List<Function> m352<A>(int x) => null;
+ int Function(int x0, [Function x]) m452() => null;
+ int Function([core.List<core.int> x0]) m552() => null;
+ Function Function(int x, [int x0]) m652() => null;
+ Function Function(int y, {List<Function> x}) m752() => null;
+ List<Function> Function([int x]) m852() => null;
+ List<Function> Function(List<Function> x0) m952() => null;
+ List<Function> Function(int x, [List<T> x0]) m1052() => null;
+ core.List<core.int> Function(int x0, {Function x}) m1152() => null;
+ core.List<core.int> Function([List<T> x]) m1252() => null;
+ List<T> Function(int y, [Function x]) m1352() => null;
+ List<T> Function(int x0, [core.List<core.int> x1]) m1452() => null;
+ Function({int x}) m1552() => null;
+ Function(core.List<core.int> x) m1652() => null;
+ int Function<A>(List<Function> x) m1752() => null;
+ core.List<core.int> Function<A>(core.List<core.int> x) m1852() => null;
+ A Function<A>(List<T> x) m1952() => null;
+
+
+ runTests() {
+ testF52();
+ testF152();
+ testF252();
+ testF352();
+ testF452();
+ testF552();
+ testF652();
+ testF752();
+ testF852();
+ testF952();
+ testF1052();
+ testF1152();
+ testF1252();
+ testF1352();
+ testF1452();
+ testF1552();
+ testF1652();
+ testF1752();
+ testF1852();
+ testF1952();
+ }
+
+ void testF52() {
+ // int Function({List<T> x})
+ Expect.isTrue(f52 is F52);
+ Expect.isTrue(confuse(f52) is F52);
+ // In checked mode, verifies the type.
+ int Function({List<T> x}) l52;
+ // The static function f52 sets `T` to `int`.
+ if (!tIsBool) {
+ x52 = f52 as dynamic;
+ l52 = f52 as dynamic;
+ x52 = confuse(f52);
+ l52 = confuse(f52);
+ }
+
+ Expect.isTrue(m52 is F52);
+ Expect.isTrue(m52 is int Function({List<T> x}));
+ Expect.isTrue(confuse(m52) is F52);
+ // In checked mode, verifies the type.
+ x52 = m52;
+ l52 = m52;
+ x52 = confuse(m52);
+ l52 = confuse(m52);
+ if (!tIsBool) {
+ Expect.isTrue(f52 is F52<int>);
+ Expect.isFalse(f52 is F52<bool>);
+ Expect.isTrue(confuse(f52) is F52<int>);
+ Expect.isFalse(confuse(f52) is F52<bool>);
+ Expect.equals(tIsDynamic, m52 is F52<bool>);
+ Expect.equals(tIsDynamic, confuse(m52) is F52<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x52 = (f52 as dynamic); });
+ Expect.throws(() { x52 = confuse(f52); });
+ int Function({List<T> x}) l52;
+ Expect.throws(() { l52 = (f52 as dynamic); });
+ Expect.throws(() { l52 = confuse(f52); });
+ }
+ int Function({List<T> x}) l52 = m52;
+ // In checked mode, verifies the type.
+ x52 = m52;
+ x52 = confuse(m52);
+ }
+ }
+
+ void testF152() {
+ // List<Function> Function(int x, [core.List<core.int> x2])
+ Expect.isTrue(f152 is F152);
+ Expect.isTrue(confuse(f152) is F152);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [core.List<core.int> x2]) l152;
+ // The static function f152 sets `T` to `int`.
+ if (!tIsBool) {
+ x152 = f152 as dynamic;
+ l152 = f152 as dynamic;
+ x152 = confuse(f152);
+ l152 = confuse(f152);
+ }
+
+ Expect.isTrue(m152 is F152);
+ Expect.isTrue(m152 is List<Function> Function(int x, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m152) is F152);
+ // In checked mode, verifies the type.
+ x152 = m152;
+ l152 = m152;
+ x152 = confuse(m152);
+ l152 = confuse(m152);
+
+ }
+
+ void testF252() {
+ // List<T> Function(int x1, [List<Function> x2])
+ Expect.isTrue(f252 is F252);
+ Expect.isTrue(confuse(f252) is F252);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<Function> x2]) l252;
+ // The static function f252 sets `T` to `int`.
+ if (!tIsBool) {
+ x252 = f252 as dynamic;
+ l252 = f252 as dynamic;
+ x252 = confuse(f252);
+ l252 = confuse(f252);
+ }
+
+ Expect.isTrue(m252 is F252);
+ Expect.isTrue(m252 is List<T> Function(int x1, [List<Function> x2]));
+ Expect.isTrue(confuse(m252) is F252);
+ // In checked mode, verifies the type.
+ x252 = m252;
+ l252 = m252;
+ x252 = confuse(m252);
+ l252 = confuse(m252);
+ if (!tIsBool) {
+ Expect.isTrue(f252 is F252<int>);
+ Expect.isFalse(f252 is F252<bool>);
+ Expect.isTrue(confuse(f252) is F252<int>);
+ Expect.isFalse(confuse(f252) is F252<bool>);
+ Expect.equals(tIsDynamic, m252 is F252<bool>);
+ Expect.equals(tIsDynamic, confuse(m252) is F252<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x252 = (f252 as dynamic); });
+ Expect.throws(() { x252 = confuse(f252); });
+ List<T> Function(int x1, [List<Function> x2]) l252;
+ Expect.throws(() { l252 = (f252 as dynamic); });
+ Expect.throws(() { l252 = confuse(f252); });
+ }
+ List<T> Function(int x1, [List<Function> x2]) l252 = m252;
+ // In checked mode, verifies the type.
+ x252 = m252;
+ x252 = confuse(m252);
+ }
+ }
+
+ void testF352() {
+ // List<Function> Function<A>(int x)
+ Expect.isTrue(f352 is F352);
+ Expect.isTrue(confuse(f352) is F352);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(int x) l352;
+ // The static function f352 sets `T` to `int`.
+ if (!tIsBool) {
+ x352 = f352 as dynamic;
+ l352 = f352 as dynamic;
+ x352 = confuse(f352);
+ l352 = confuse(f352);
+ }
+
+ Expect.isTrue(m352 is F352);
+ Expect.isTrue(m352 is List<Function> Function<A>(int x));
+ Expect.isTrue(confuse(m352) is F352);
+ // In checked mode, verifies the type.
+ x352 = m352;
+ l352 = m352;
+ x352 = confuse(m352);
+ l352 = confuse(m352);
+
+ }
+
+ void testF452() {
+ // int Function(int x0, [Function x]) Function()
+ Expect.isTrue(f452 is F452);
+ Expect.isTrue(confuse(f452) is F452);
+ // In checked mode, verifies the type.
+ int Function(int x0, [Function x]) Function() l452;
+ // The static function f452 sets `T` to `int`.
+ if (!tIsBool) {
+ x452 = f452 as dynamic;
+ l452 = f452 as dynamic;
+ x452 = confuse(f452);
+ l452 = confuse(f452);
+ }
+
+ Expect.isTrue(m452 is F452);
+ Expect.isTrue(m452 is int Function(int x0, [Function x]) Function());
+ Expect.isTrue(confuse(m452) is F452);
+ // In checked mode, verifies the type.
+ x452 = m452;
+ l452 = m452;
+ x452 = confuse(m452);
+ l452 = confuse(m452);
+
+ }
+
+ void testF552() {
+ // int Function([core.List<core.int> x1]) Function()
+ Expect.isTrue(f552 is F552);
+ Expect.isTrue(confuse(f552) is F552);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x1]) Function() l552;
+ // The static function f552 sets `T` to `int`.
+ if (!tIsBool) {
+ x552 = f552 as dynamic;
+ l552 = f552 as dynamic;
+ x552 = confuse(f552);
+ l552 = confuse(f552);
+ }
+
+ Expect.isTrue(m552 is F552);
+ Expect.isTrue(m552 is int Function([core.List<core.int> x1]) Function());
+ Expect.isTrue(confuse(m552) is F552);
+ // In checked mode, verifies the type.
+ x552 = m552;
+ l552 = m552;
+ x552 = confuse(m552);
+ l552 = confuse(m552);
+
+ }
+
+ void testF652() {
+ // Function Function(int x, [int x2]) Function()
+ Expect.isTrue(f652 is F652);
+ Expect.isTrue(confuse(f652) is F652);
+ // In checked mode, verifies the type.
+ Function Function(int x, [int x2]) Function() l652;
+ // The static function f652 sets `T` to `int`.
+ if (!tIsBool) {
+ x652 = f652 as dynamic;
+ l652 = f652 as dynamic;
+ x652 = confuse(f652);
+ l652 = confuse(f652);
+ }
+
+ Expect.isTrue(m652 is F652);
+ Expect.isTrue(m652 is Function Function(int x, [int x2]) Function());
+ Expect.isTrue(confuse(m652) is F652);
+ // In checked mode, verifies the type.
+ x652 = m652;
+ l652 = m652;
+ x652 = confuse(m652);
+ l652 = confuse(m652);
+
+ }
+
+ void testF752() {
+ // Function Function(int y, {List<Function> x}) Function()
+ Expect.isTrue(f752 is F752);
+ Expect.isTrue(confuse(f752) is F752);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<Function> x}) Function() l752;
+ // The static function f752 sets `T` to `int`.
+ if (!tIsBool) {
+ x752 = f752 as dynamic;
+ l752 = f752 as dynamic;
+ x752 = confuse(f752);
+ l752 = confuse(f752);
+ }
+
+ Expect.isTrue(m752 is F752);
+ Expect.isTrue(m752 is Function Function(int y, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m752) is F752);
+ // In checked mode, verifies the type.
+ x752 = m752;
+ l752 = m752;
+ x752 = confuse(m752);
+ l752 = confuse(m752);
+
+ }
+
+ void testF852() {
+ // List<Function> Function([int x]) Function()
+ Expect.isTrue(f852 is F852);
+ Expect.isTrue(confuse(f852) is F852);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x]) Function() l852;
+ // The static function f852 sets `T` to `int`.
+ if (!tIsBool) {
+ x852 = f852 as dynamic;
+ l852 = f852 as dynamic;
+ x852 = confuse(f852);
+ l852 = confuse(f852);
+ }
+
+ Expect.isTrue(m852 is F852);
+ Expect.isTrue(m852 is List<Function> Function([int x]) Function());
+ Expect.isTrue(confuse(m852) is F852);
+ // In checked mode, verifies the type.
+ x852 = m852;
+ l852 = m852;
+ x852 = confuse(m852);
+ l852 = confuse(m852);
+
+ }
+
+ void testF952() {
+ // List<Function> Function(List<Function> x0) Function()
+ Expect.isTrue(f952 is F952);
+ Expect.isTrue(confuse(f952) is F952);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x0) Function() l952;
+ // The static function f952 sets `T` to `int`.
+ if (!tIsBool) {
+ x952 = f952 as dynamic;
+ l952 = f952 as dynamic;
+ x952 = confuse(f952);
+ l952 = confuse(f952);
+ }
+
+ Expect.isTrue(m952 is F952);
+ Expect.isTrue(m952 is List<Function> Function(List<Function> x0) Function());
+ Expect.isTrue(confuse(m952) is F952);
+ // In checked mode, verifies the type.
+ x952 = m952;
+ l952 = m952;
+ x952 = confuse(m952);
+ l952 = confuse(m952);
+
+ }
+
+ void testF1052() {
+ // List<Function> Function(int x, [List<T> x2]) Function()
+ Expect.isTrue(f1052 is F1052);
+ Expect.isTrue(confuse(f1052) is F1052);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<T> x2]) Function() l1052;
+ // The static function f1052 sets `T` to `int`.
+ if (!tIsBool) {
+ x1052 = f1052 as dynamic;
+ l1052 = f1052 as dynamic;
+ x1052 = confuse(f1052);
+ l1052 = confuse(f1052);
+ }
+
+ Expect.isTrue(m1052 is F1052);
+ Expect.isTrue(m1052 is List<Function> Function(int x, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1052) is F1052);
+ // In checked mode, verifies the type.
+ x1052 = m1052;
+ l1052 = m1052;
+ x1052 = confuse(m1052);
+ l1052 = confuse(m1052);
+ if (!tIsBool) {
+ Expect.isTrue(f1052 is F1052<int>);
+ Expect.isFalse(f1052 is F1052<bool>);
+ Expect.isTrue(confuse(f1052) is F1052<int>);
+ Expect.isFalse(confuse(f1052) is F1052<bool>);
+ Expect.equals(tIsDynamic, m1052 is F1052<bool>);
+ Expect.equals(tIsDynamic, confuse(m1052) is F1052<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1052 = (f1052 as dynamic); });
+ Expect.throws(() { x1052 = confuse(f1052); });
+ List<Function> Function(int x, [List<T> x2]) Function() l1052;
+ Expect.throws(() { l1052 = (f1052 as dynamic); });
+ Expect.throws(() { l1052 = confuse(f1052); });
+ }
+ List<Function> Function(int x, [List<T> x2]) Function() l1052 = m1052;
+ // In checked mode, verifies the type.
+ x1052 = m1052;
+ x1052 = confuse(m1052);
+ }
+ }
+
+ void testF1152() {
+ // core.List<core.int> Function(int x0, {Function x}) Function()
+ Expect.isTrue(f1152 is F1152);
+ Expect.isTrue(confuse(f1152) is F1152);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {Function x}) Function() l1152;
+ // The static function f1152 sets `T` to `int`.
+ if (!tIsBool) {
+ x1152 = f1152 as dynamic;
+ l1152 = f1152 as dynamic;
+ x1152 = confuse(f1152);
+ l1152 = confuse(f1152);
+ }
+
+ Expect.isTrue(m1152 is F1152);
+ Expect.isTrue(m1152 is core.List<core.int> Function(int x0, {Function x}) Function());
+ Expect.isTrue(confuse(m1152) is F1152);
+ // In checked mode, verifies the type.
+ x1152 = m1152;
+ l1152 = m1152;
+ x1152 = confuse(m1152);
+ l1152 = confuse(m1152);
+
+ }
+
+ void testF1252() {
+ // core.List<core.int> Function([List<T> x]) Function()
+ Expect.isTrue(f1252 is F1252);
+ Expect.isTrue(confuse(f1252) is F1252);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x]) Function() l1252;
+ // The static function f1252 sets `T` to `int`.
+ if (!tIsBool) {
+ x1252 = f1252 as dynamic;
+ l1252 = f1252 as dynamic;
+ x1252 = confuse(f1252);
+ l1252 = confuse(f1252);
+ }
+
+ Expect.isTrue(m1252 is F1252);
+ Expect.isTrue(m1252 is core.List<core.int> Function([List<T> x]) Function());
+ Expect.isTrue(confuse(m1252) is F1252);
+ // In checked mode, verifies the type.
+ x1252 = m1252;
+ l1252 = m1252;
+ x1252 = confuse(m1252);
+ l1252 = confuse(m1252);
+ if (!tIsBool) {
+ Expect.isTrue(f1252 is F1252<int>);
+ Expect.isFalse(f1252 is F1252<bool>);
+ Expect.isTrue(confuse(f1252) is F1252<int>);
+ Expect.isFalse(confuse(f1252) is F1252<bool>);
+ Expect.equals(tIsDynamic, m1252 is F1252<bool>);
+ Expect.equals(tIsDynamic, confuse(m1252) is F1252<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1252 = (f1252 as dynamic); });
+ Expect.throws(() { x1252 = confuse(f1252); });
+ core.List<core.int> Function([List<T> x]) Function() l1252;
+ Expect.throws(() { l1252 = (f1252 as dynamic); });
+ Expect.throws(() { l1252 = confuse(f1252); });
+ }
+ core.List<core.int> Function([List<T> x]) Function() l1252 = m1252;
+ // In checked mode, verifies the type.
+ x1252 = m1252;
+ x1252 = confuse(m1252);
+ }
+ }
+
+ void testF1352() {
+ // List<T> Function(int y, [Function x]) Function()
+ Expect.isTrue(f1352 is F1352);
+ Expect.isTrue(confuse(f1352) is F1352);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [Function x]) Function() l1352;
+ // The static function f1352 sets `T` to `int`.
+ if (!tIsBool) {
+ x1352 = f1352 as dynamic;
+ l1352 = f1352 as dynamic;
+ x1352 = confuse(f1352);
+ l1352 = confuse(f1352);
+ }
+
+ Expect.isTrue(m1352 is F1352);
+ Expect.isTrue(m1352 is List<T> Function(int y, [Function x]) Function());
+ Expect.isTrue(confuse(m1352) is F1352);
+ // In checked mode, verifies the type.
+ x1352 = m1352;
+ l1352 = m1352;
+ x1352 = confuse(m1352);
+ l1352 = confuse(m1352);
+ if (!tIsBool) {
+ Expect.isTrue(f1352 is F1352<int>);
+ Expect.isFalse(f1352 is F1352<bool>);
+ Expect.isTrue(confuse(f1352) is F1352<int>);
+ Expect.isFalse(confuse(f1352) is F1352<bool>);
+ Expect.equals(tIsDynamic, m1352 is F1352<bool>);
+ Expect.equals(tIsDynamic, confuse(m1352) is F1352<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1352 = (f1352 as dynamic); });
+ Expect.throws(() { x1352 = confuse(f1352); });
+ List<T> Function(int y, [Function x]) Function() l1352;
+ Expect.throws(() { l1352 = (f1352 as dynamic); });
+ Expect.throws(() { l1352 = confuse(f1352); });
+ }
+ List<T> Function(int y, [Function x]) Function() l1352 = m1352;
+ // In checked mode, verifies the type.
+ x1352 = m1352;
+ x1352 = confuse(m1352);
+ }
+ }
+
+ void testF1452() {
+ // List<T> Function(int x1, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1452 is F1452);
+ Expect.isTrue(confuse(f1452) is F1452);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [core.List<core.int> x2]) Function() l1452;
+ // The static function f1452 sets `T` to `int`.
+ if (!tIsBool) {
+ x1452 = f1452 as dynamic;
+ l1452 = f1452 as dynamic;
+ x1452 = confuse(f1452);
+ l1452 = confuse(f1452);
+ }
+
+ Expect.isTrue(m1452 is F1452);
+ Expect.isTrue(m1452 is List<T> Function(int x1, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1452) is F1452);
+ // In checked mode, verifies the type.
+ x1452 = m1452;
+ l1452 = m1452;
+ x1452 = confuse(m1452);
+ l1452 = confuse(m1452);
+ if (!tIsBool) {
+ Expect.isTrue(f1452 is F1452<int>);
+ Expect.isFalse(f1452 is F1452<bool>);
+ Expect.isTrue(confuse(f1452) is F1452<int>);
+ Expect.isFalse(confuse(f1452) is F1452<bool>);
+ Expect.equals(tIsDynamic, m1452 is F1452<bool>);
+ Expect.equals(tIsDynamic, confuse(m1452) is F1452<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1452 = (f1452 as dynamic); });
+ Expect.throws(() { x1452 = confuse(f1452); });
+ List<T> Function(int x1, [core.List<core.int> x2]) Function() l1452;
+ Expect.throws(() { l1452 = (f1452 as dynamic); });
+ Expect.throws(() { l1452 = confuse(f1452); });
+ }
+ List<T> Function(int x1, [core.List<core.int> x2]) Function() l1452 = m1452;
+ // In checked mode, verifies the type.
+ x1452 = m1452;
+ x1452 = confuse(m1452);
+ }
+ }
+
+ void testF1552() {
+ // Function({int x}) Function()
+ Expect.isTrue(f1552 is F1552);
+ Expect.isTrue(confuse(f1552) is F1552);
+ // In checked mode, verifies the type.
+ Function({int x}) Function() l1552;
+ // The static function f1552 sets `T` to `int`.
+ if (!tIsBool) {
+ x1552 = f1552 as dynamic;
+ l1552 = f1552 as dynamic;
+ x1552 = confuse(f1552);
+ l1552 = confuse(f1552);
+ }
+
+ Expect.isTrue(m1552 is F1552);
+ Expect.isTrue(m1552 is Function({int x}) Function());
+ Expect.isTrue(confuse(m1552) is F1552);
+ // In checked mode, verifies the type.
+ x1552 = m1552;
+ l1552 = m1552;
+ x1552 = confuse(m1552);
+ l1552 = confuse(m1552);
+
+ }
+
+ void testF1652() {
+ // Function(core.List<core.int> x) Function()
+ Expect.isTrue(f1652 is F1652);
+ Expect.isTrue(confuse(f1652) is F1652);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x) Function() l1652;
+ // The static function f1652 sets `T` to `int`.
+ if (!tIsBool) {
+ x1652 = f1652 as dynamic;
+ l1652 = f1652 as dynamic;
+ x1652 = confuse(f1652);
+ l1652 = confuse(f1652);
+ }
+
+ Expect.isTrue(m1652 is F1652);
+ Expect.isTrue(m1652 is Function(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1652) is F1652);
+ // In checked mode, verifies the type.
+ x1652 = m1652;
+ l1652 = m1652;
+ x1652 = confuse(m1652);
+ l1652 = confuse(m1652);
+
+ }
+
+ void testF1752() {
+ // int Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1752 is F1752);
+ Expect.isTrue(confuse(f1752) is F1752);
+ // In checked mode, verifies the type.
+ int Function<A>(List<Function> x) Function() l1752;
+ // The static function f1752 sets `T` to `int`.
+ if (!tIsBool) {
+ x1752 = f1752 as dynamic;
+ l1752 = f1752 as dynamic;
+ x1752 = confuse(f1752);
+ l1752 = confuse(f1752);
+ }
+
+ Expect.isTrue(m1752 is F1752);
+ Expect.isTrue(m1752 is int Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1752) is F1752);
+ // In checked mode, verifies the type.
+ x1752 = m1752;
+ l1752 = m1752;
+ x1752 = confuse(m1752);
+ l1752 = confuse(m1752);
+
+ }
+
+ void testF1852() {
+ // core.List<core.int> Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1852 is F1852);
+ Expect.isTrue(confuse(f1852) is F1852);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(core.List<core.int> x) Function() l1852;
+ // The static function f1852 sets `T` to `int`.
+ if (!tIsBool) {
+ x1852 = f1852 as dynamic;
+ l1852 = f1852 as dynamic;
+ x1852 = confuse(f1852);
+ l1852 = confuse(f1852);
+ }
+
+ Expect.isTrue(m1852 is F1852);
+ Expect.isTrue(m1852 is core.List<core.int> Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1852) is F1852);
+ // In checked mode, verifies the type.
+ x1852 = m1852;
+ l1852 = m1852;
+ x1852 = confuse(m1852);
+ l1852 = confuse(m1852);
+
+ }
+
+ void testF1952() {
+ // A Function<A>(List<T> x) Function()
+ Expect.isTrue(f1952 is F1952);
+ Expect.isTrue(confuse(f1952) is F1952);
+ // In checked mode, verifies the type.
+ A Function<A>(List<T> x) Function() l1952;
+ // The static function f1952 sets `T` to `int`.
+ if (!tIsBool) {
+ x1952 = f1952 as dynamic;
+ l1952 = f1952 as dynamic;
+ x1952 = confuse(f1952);
+ l1952 = confuse(f1952);
+ }
+
+ Expect.isTrue(m1952 is F1952);
+ Expect.isTrue(m1952 is A Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1952) is F1952);
+ // In checked mode, verifies the type.
+ x1952 = m1952;
+ l1952 = m1952;
+ x1952 = confuse(m1952);
+ l1952 = confuse(m1952);
+ if (!tIsBool) {
+ Expect.isTrue(f1952 is F1952<int>);
+ Expect.isFalse(f1952 is F1952<bool>);
+ Expect.isTrue(confuse(f1952) is F1952<int>);
+ Expect.isFalse(confuse(f1952) is F1952<bool>);
+ Expect.equals(tIsDynamic, m1952 is F1952<bool>);
+ Expect.equals(tIsDynamic, confuse(m1952) is F1952<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1952 = (f1952 as dynamic); });
+ Expect.throws(() { x1952 = confuse(f1952); });
+ A Function<A>(List<T> x) Function() l1952;
+ Expect.throws(() { l1952 = (f1952 as dynamic); });
+ Expect.throws(() { l1952 = confuse(f1952); });
+ }
+ A Function<A>(List<T> x) Function() l1952 = m1952;
+ // In checked mode, verifies the type.
+ x1952 = m1952;
+ x1952 = confuse(m1952);
+ }
+ }
+
+
+}
+
+class C53<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int x0, {List<T> x}) x53;
+ List<Function> Function({core.List<core.int> x}) x153;
+ List<T> Function(int x, [List<Function> x2]) x253;
+ List<Function> Function<A>(Function x) x353;
+ int Function(int x1, [Function x]) Function(int x) x453;
+ int Function([core.List<core.int> x1]) Function(int x) x553;
+ Function Function(int x, [int x1]) Function(int x) x653;
+ Function Function(int y, {List<Function> x}) Function(int x) x753;
+ List<Function> Function([int x]) Function(int x) x853;
+ List<Function> Function(List<Function> x1) Function(int x) x953;
+ List<Function> Function(int x, [List<T> x1]) Function(int x) x1053;
+ core.List<core.int> Function(int x1, {Function x}) Function(int x) x1153;
+ core.List<core.int> Function([List<T> x]) Function(int x) x1253;
+ List<T> Function(int y, [Function x]) Function(int x) x1353;
+ List<T> Function(int x2, [core.List<core.int> x3]) Function(int x) x1453;
+ Function({int x}) Function(int x) x1553;
+ Function(core.List<core.int> x) Function(int x) x1653;
+ int Function<A>(List<Function> x) Function(int x) x1753;
+ core.List<core.int> Function<A>(core.List<core.int> x) Function(int x) x1853;
+ A Function<A>(List<T> x) Function(int x) x1953;
+
+
+ C53({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m53(int x0, {List<T> x}) => null;
+ List<Function> m153({core.List<core.int> x}) => null;
+ List<T> m253(int x, [List<Function> x0]) => null;
+ List<Function> m353<A>(Function x) => null;
+ int Function(int x0, [Function x]) m453(int x) => null;
+ int Function([core.List<core.int> x0]) m553(int x) => null;
+ Function Function(int x, [int x0]) m653(int x) => null;
+ Function Function(int y, {List<Function> x}) m753(int x) => null;
+ List<Function> Function([int x]) m853(int x) => null;
+ List<Function> Function(List<Function> x0) m953(int x) => null;
+ List<Function> Function(int x, [List<T> x0]) m1053(int x) => null;
+ core.List<core.int> Function(int x0, {Function x}) m1153(int x) => null;
+ core.List<core.int> Function([List<T> x]) m1253(int x) => null;
+ List<T> Function(int y, [Function x]) m1353(int x) => null;
+ List<T> Function(int x0, [core.List<core.int> x1]) m1453(int x) => null;
+ Function({int x}) m1553(int x) => null;
+ Function(core.List<core.int> x) m1653(int x) => null;
+ int Function<A>(List<Function> x) m1753(int x) => null;
+ core.List<core.int> Function<A>(core.List<core.int> x) m1853(int x) => null;
+ A Function<A>(List<T> x) m1953(int x) => null;
+
+
+ runTests() {
+ testF53();
+ testF153();
+ testF253();
+ testF353();
+ testF453();
+ testF553();
+ testF653();
+ testF753();
+ testF853();
+ testF953();
+ testF1053();
+ testF1153();
+ testF1253();
+ testF1353();
+ testF1453();
+ testF1553();
+ testF1653();
+ testF1753();
+ testF1853();
+ testF1953();
+ }
+
+ void testF53() {
+ // int Function(int x0, {List<T> x})
+ Expect.isTrue(f53 is F53);
+ Expect.isTrue(confuse(f53) is F53);
+ // In checked mode, verifies the type.
+ int Function(int x0, {List<T> x}) l53;
+ // The static function f53 sets `T` to `int`.
+ if (!tIsBool) {
+ x53 = f53 as dynamic;
+ l53 = f53 as dynamic;
+ x53 = confuse(f53);
+ l53 = confuse(f53);
+ }
+
+ Expect.isTrue(m53 is F53);
+ Expect.isTrue(m53 is int Function(int x0, {List<T> x}));
+ Expect.isTrue(confuse(m53) is F53);
+ // In checked mode, verifies the type.
+ x53 = m53;
+ l53 = m53;
+ x53 = confuse(m53);
+ l53 = confuse(m53);
+ if (!tIsBool) {
+ Expect.isTrue(f53 is F53<int>);
+ Expect.isFalse(f53 is F53<bool>);
+ Expect.isTrue(confuse(f53) is F53<int>);
+ Expect.isFalse(confuse(f53) is F53<bool>);
+ Expect.equals(tIsDynamic, m53 is F53<bool>);
+ Expect.equals(tIsDynamic, confuse(m53) is F53<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x53 = (f53 as dynamic); });
+ Expect.throws(() { x53 = confuse(f53); });
+ int Function(int x0, {List<T> x}) l53;
+ Expect.throws(() { l53 = (f53 as dynamic); });
+ Expect.throws(() { l53 = confuse(f53); });
+ }
+ int Function(int x0, {List<T> x}) l53 = m53;
+ // In checked mode, verifies the type.
+ x53 = m53;
+ x53 = confuse(m53);
+ }
+ }
+
+ void testF153() {
+ // List<Function> Function({core.List<core.int> x})
+ Expect.isTrue(f153 is F153);
+ Expect.isTrue(confuse(f153) is F153);
+ // In checked mode, verifies the type.
+ List<Function> Function({core.List<core.int> x}) l153;
+ // The static function f153 sets `T` to `int`.
+ if (!tIsBool) {
+ x153 = f153 as dynamic;
+ l153 = f153 as dynamic;
+ x153 = confuse(f153);
+ l153 = confuse(f153);
+ }
+
+ Expect.isTrue(m153 is F153);
+ Expect.isTrue(m153 is List<Function> Function({core.List<core.int> x}));
+ Expect.isTrue(confuse(m153) is F153);
+ // In checked mode, verifies the type.
+ x153 = m153;
+ l153 = m153;
+ x153 = confuse(m153);
+ l153 = confuse(m153);
+
+ }
+
+ void testF253() {
+ // List<T> Function(int x, [List<Function> x2])
+ Expect.isTrue(f253 is F253);
+ Expect.isTrue(confuse(f253) is F253);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<Function> x2]) l253;
+ // The static function f253 sets `T` to `int`.
+ if (!tIsBool) {
+ x253 = f253 as dynamic;
+ l253 = f253 as dynamic;
+ x253 = confuse(f253);
+ l253 = confuse(f253);
+ }
+
+ Expect.isTrue(m253 is F253);
+ Expect.isTrue(m253 is List<T> Function(int x, [List<Function> x2]));
+ Expect.isTrue(confuse(m253) is F253);
+ // In checked mode, verifies the type.
+ x253 = m253;
+ l253 = m253;
+ x253 = confuse(m253);
+ l253 = confuse(m253);
+ if (!tIsBool) {
+ Expect.isTrue(f253 is F253<int>);
+ Expect.isFalse(f253 is F253<bool>);
+ Expect.isTrue(confuse(f253) is F253<int>);
+ Expect.isFalse(confuse(f253) is F253<bool>);
+ Expect.equals(tIsDynamic, m253 is F253<bool>);
+ Expect.equals(tIsDynamic, confuse(m253) is F253<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x253 = (f253 as dynamic); });
+ Expect.throws(() { x253 = confuse(f253); });
+ List<T> Function(int x, [List<Function> x2]) l253;
+ Expect.throws(() { l253 = (f253 as dynamic); });
+ Expect.throws(() { l253 = confuse(f253); });
+ }
+ List<T> Function(int x, [List<Function> x2]) l253 = m253;
+ // In checked mode, verifies the type.
+ x253 = m253;
+ x253 = confuse(m253);
+ }
+ }
+
+ void testF353() {
+ // List<Function> Function<A>(Function x)
+ Expect.isTrue(f353 is F353);
+ Expect.isTrue(confuse(f353) is F353);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(Function x) l353;
+ // The static function f353 sets `T` to `int`.
+ if (!tIsBool) {
+ x353 = f353 as dynamic;
+ l353 = f353 as dynamic;
+ x353 = confuse(f353);
+ l353 = confuse(f353);
+ }
+
+ Expect.isTrue(m353 is F353);
+ Expect.isTrue(m353 is List<Function> Function<A>(Function x));
+ Expect.isTrue(confuse(m353) is F353);
+ // In checked mode, verifies the type.
+ x353 = m353;
+ l353 = m353;
+ x353 = confuse(m353);
+ l353 = confuse(m353);
+
+ }
+
+ void testF453() {
+ // int Function(int x1, [Function x]) Function(int x)
+ Expect.isTrue(f453 is F453);
+ Expect.isTrue(confuse(f453) is F453);
+ // In checked mode, verifies the type.
+ int Function(int x1, [Function x]) Function(int x) l453;
+ // The static function f453 sets `T` to `int`.
+ if (!tIsBool) {
+ x453 = f453 as dynamic;
+ l453 = f453 as dynamic;
+ x453 = confuse(f453);
+ l453 = confuse(f453);
+ }
+
+ Expect.isTrue(m453 is F453);
+ Expect.isTrue(m453 is int Function(int x1, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m453) is F453);
+ // In checked mode, verifies the type.
+ x453 = m453;
+ l453 = m453;
+ x453 = confuse(m453);
+ l453 = confuse(m453);
+
+ }
+
+ void testF553() {
+ // int Function([core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f553 is F553);
+ Expect.isTrue(confuse(f553) is F553);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x1]) Function(int x) l553;
+ // The static function f553 sets `T` to `int`.
+ if (!tIsBool) {
+ x553 = f553 as dynamic;
+ l553 = f553 as dynamic;
+ x553 = confuse(f553);
+ l553 = confuse(f553);
+ }
+
+ Expect.isTrue(m553 is F553);
+ Expect.isTrue(m553 is int Function([core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m553) is F553);
+ // In checked mode, verifies the type.
+ x553 = m553;
+ l553 = m553;
+ x553 = confuse(m553);
+ l553 = confuse(m553);
+
+ }
+
+ void testF653() {
+ // Function Function(int x, [int x1]) Function(int x)
+ Expect.isTrue(f653 is F653);
+ Expect.isTrue(confuse(f653) is F653);
+ // In checked mode, verifies the type.
+ Function Function(int x, [int x1]) Function(int x) l653;
+ // The static function f653 sets `T` to `int`.
+ if (!tIsBool) {
+ x653 = f653 as dynamic;
+ l653 = f653 as dynamic;
+ x653 = confuse(f653);
+ l653 = confuse(f653);
+ }
+
+ Expect.isTrue(m653 is F653);
+ Expect.isTrue(m653 is Function Function(int x, [int x1]) Function(int x));
+ Expect.isTrue(confuse(m653) is F653);
+ // In checked mode, verifies the type.
+ x653 = m653;
+ l653 = m653;
+ x653 = confuse(m653);
+ l653 = confuse(m653);
+
+ }
+
+ void testF753() {
+ // Function Function(int y, {List<Function> x}) Function(int x)
+ Expect.isTrue(f753 is F753);
+ Expect.isTrue(confuse(f753) is F753);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<Function> x}) Function(int x) l753;
+ // The static function f753 sets `T` to `int`.
+ if (!tIsBool) {
+ x753 = f753 as dynamic;
+ l753 = f753 as dynamic;
+ x753 = confuse(f753);
+ l753 = confuse(f753);
+ }
+
+ Expect.isTrue(m753 is F753);
+ Expect.isTrue(m753 is Function Function(int y, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m753) is F753);
+ // In checked mode, verifies the type.
+ x753 = m753;
+ l753 = m753;
+ x753 = confuse(m753);
+ l753 = confuse(m753);
+
+ }
+
+ void testF853() {
+ // List<Function> Function([int x]) Function(int x)
+ Expect.isTrue(f853 is F853);
+ Expect.isTrue(confuse(f853) is F853);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x]) Function(int x) l853;
+ // The static function f853 sets `T` to `int`.
+ if (!tIsBool) {
+ x853 = f853 as dynamic;
+ l853 = f853 as dynamic;
+ x853 = confuse(f853);
+ l853 = confuse(f853);
+ }
+
+ Expect.isTrue(m853 is F853);
+ Expect.isTrue(m853 is List<Function> Function([int x]) Function(int x));
+ Expect.isTrue(confuse(m853) is F853);
+ // In checked mode, verifies the type.
+ x853 = m853;
+ l853 = m853;
+ x853 = confuse(m853);
+ l853 = confuse(m853);
+
+ }
+
+ void testF953() {
+ // List<Function> Function(List<Function> x1) Function(int x)
+ Expect.isTrue(f953 is F953);
+ Expect.isTrue(confuse(f953) is F953);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x1) Function(int x) l953;
+ // The static function f953 sets `T` to `int`.
+ if (!tIsBool) {
+ x953 = f953 as dynamic;
+ l953 = f953 as dynamic;
+ x953 = confuse(f953);
+ l953 = confuse(f953);
+ }
+
+ Expect.isTrue(m953 is F953);
+ Expect.isTrue(m953 is List<Function> Function(List<Function> x1) Function(int x));
+ Expect.isTrue(confuse(m953) is F953);
+ // In checked mode, verifies the type.
+ x953 = m953;
+ l953 = m953;
+ x953 = confuse(m953);
+ l953 = confuse(m953);
+
+ }
+
+ void testF1053() {
+ // List<Function> Function(int x, [List<T> x1]) Function(int x)
+ Expect.isTrue(f1053 is F1053);
+ Expect.isTrue(confuse(f1053) is F1053);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<T> x1]) Function(int x) l1053;
+ // The static function f1053 sets `T` to `int`.
+ if (!tIsBool) {
+ x1053 = f1053 as dynamic;
+ l1053 = f1053 as dynamic;
+ x1053 = confuse(f1053);
+ l1053 = confuse(f1053);
+ }
+
+ Expect.isTrue(m1053 is F1053);
+ Expect.isTrue(m1053 is List<Function> Function(int x, [List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1053) is F1053);
+ // In checked mode, verifies the type.
+ x1053 = m1053;
+ l1053 = m1053;
+ x1053 = confuse(m1053);
+ l1053 = confuse(m1053);
+ if (!tIsBool) {
+ Expect.isTrue(f1053 is F1053<int>);
+ Expect.isFalse(f1053 is F1053<bool>);
+ Expect.isTrue(confuse(f1053) is F1053<int>);
+ Expect.isFalse(confuse(f1053) is F1053<bool>);
+ Expect.equals(tIsDynamic, m1053 is F1053<bool>);
+ Expect.equals(tIsDynamic, confuse(m1053) is F1053<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1053 = (f1053 as dynamic); });
+ Expect.throws(() { x1053 = confuse(f1053); });
+ List<Function> Function(int x, [List<T> x1]) Function(int x) l1053;
+ Expect.throws(() { l1053 = (f1053 as dynamic); });
+ Expect.throws(() { l1053 = confuse(f1053); });
+ }
+ List<Function> Function(int x, [List<T> x1]) Function(int x) l1053 = m1053;
+ // In checked mode, verifies the type.
+ x1053 = m1053;
+ x1053 = confuse(m1053);
+ }
+ }
+
+ void testF1153() {
+ // core.List<core.int> Function(int x1, {Function x}) Function(int x)
+ Expect.isTrue(f1153 is F1153);
+ Expect.isTrue(confuse(f1153) is F1153);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {Function x}) Function(int x) l1153;
+ // The static function f1153 sets `T` to `int`.
+ if (!tIsBool) {
+ x1153 = f1153 as dynamic;
+ l1153 = f1153 as dynamic;
+ x1153 = confuse(f1153);
+ l1153 = confuse(f1153);
+ }
+
+ Expect.isTrue(m1153 is F1153);
+ Expect.isTrue(m1153 is core.List<core.int> Function(int x1, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m1153) is F1153);
+ // In checked mode, verifies the type.
+ x1153 = m1153;
+ l1153 = m1153;
+ x1153 = confuse(m1153);
+ l1153 = confuse(m1153);
+
+ }
+
+ void testF1253() {
+ // core.List<core.int> Function([List<T> x]) Function(int x)
+ Expect.isTrue(f1253 is F1253);
+ Expect.isTrue(confuse(f1253) is F1253);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x]) Function(int x) l1253;
+ // The static function f1253 sets `T` to `int`.
+ if (!tIsBool) {
+ x1253 = f1253 as dynamic;
+ l1253 = f1253 as dynamic;
+ x1253 = confuse(f1253);
+ l1253 = confuse(f1253);
+ }
+
+ Expect.isTrue(m1253 is F1253);
+ Expect.isTrue(m1253 is core.List<core.int> Function([List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1253) is F1253);
+ // In checked mode, verifies the type.
+ x1253 = m1253;
+ l1253 = m1253;
+ x1253 = confuse(m1253);
+ l1253 = confuse(m1253);
+ if (!tIsBool) {
+ Expect.isTrue(f1253 is F1253<int>);
+ Expect.isFalse(f1253 is F1253<bool>);
+ Expect.isTrue(confuse(f1253) is F1253<int>);
+ Expect.isFalse(confuse(f1253) is F1253<bool>);
+ Expect.equals(tIsDynamic, m1253 is F1253<bool>);
+ Expect.equals(tIsDynamic, confuse(m1253) is F1253<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1253 = (f1253 as dynamic); });
+ Expect.throws(() { x1253 = confuse(f1253); });
+ core.List<core.int> Function([List<T> x]) Function(int x) l1253;
+ Expect.throws(() { l1253 = (f1253 as dynamic); });
+ Expect.throws(() { l1253 = confuse(f1253); });
+ }
+ core.List<core.int> Function([List<T> x]) Function(int x) l1253 = m1253;
+ // In checked mode, verifies the type.
+ x1253 = m1253;
+ x1253 = confuse(m1253);
+ }
+ }
+
+ void testF1353() {
+ // List<T> Function(int y, [Function x]) Function(int x)
+ Expect.isTrue(f1353 is F1353);
+ Expect.isTrue(confuse(f1353) is F1353);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [Function x]) Function(int x) l1353;
+ // The static function f1353 sets `T` to `int`.
+ if (!tIsBool) {
+ x1353 = f1353 as dynamic;
+ l1353 = f1353 as dynamic;
+ x1353 = confuse(f1353);
+ l1353 = confuse(f1353);
+ }
+
+ Expect.isTrue(m1353 is F1353);
+ Expect.isTrue(m1353 is List<T> Function(int y, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m1353) is F1353);
+ // In checked mode, verifies the type.
+ x1353 = m1353;
+ l1353 = m1353;
+ x1353 = confuse(m1353);
+ l1353 = confuse(m1353);
+ if (!tIsBool) {
+ Expect.isTrue(f1353 is F1353<int>);
+ Expect.isFalse(f1353 is F1353<bool>);
+ Expect.isTrue(confuse(f1353) is F1353<int>);
+ Expect.isFalse(confuse(f1353) is F1353<bool>);
+ Expect.equals(tIsDynamic, m1353 is F1353<bool>);
+ Expect.equals(tIsDynamic, confuse(m1353) is F1353<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1353 = (f1353 as dynamic); });
+ Expect.throws(() { x1353 = confuse(f1353); });
+ List<T> Function(int y, [Function x]) Function(int x) l1353;
+ Expect.throws(() { l1353 = (f1353 as dynamic); });
+ Expect.throws(() { l1353 = confuse(f1353); });
+ }
+ List<T> Function(int y, [Function x]) Function(int x) l1353 = m1353;
+ // In checked mode, verifies the type.
+ x1353 = m1353;
+ x1353 = confuse(m1353);
+ }
+ }
+
+ void testF1453() {
+ // List<T> Function(int x2, [core.List<core.int> x3]) Function(int x)
+ Expect.isTrue(f1453 is F1453);
+ Expect.isTrue(confuse(f1453) is F1453);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [core.List<core.int> x3]) Function(int x) l1453;
+ // The static function f1453 sets `T` to `int`.
+ if (!tIsBool) {
+ x1453 = f1453 as dynamic;
+ l1453 = f1453 as dynamic;
+ x1453 = confuse(f1453);
+ l1453 = confuse(f1453);
+ }
+
+ Expect.isTrue(m1453 is F1453);
+ Expect.isTrue(m1453 is List<T> Function(int x2, [core.List<core.int> x3]) Function(int x));
+ Expect.isTrue(confuse(m1453) is F1453);
+ // In checked mode, verifies the type.
+ x1453 = m1453;
+ l1453 = m1453;
+ x1453 = confuse(m1453);
+ l1453 = confuse(m1453);
+ if (!tIsBool) {
+ Expect.isTrue(f1453 is F1453<int>);
+ Expect.isFalse(f1453 is F1453<bool>);
+ Expect.isTrue(confuse(f1453) is F1453<int>);
+ Expect.isFalse(confuse(f1453) is F1453<bool>);
+ Expect.equals(tIsDynamic, m1453 is F1453<bool>);
+ Expect.equals(tIsDynamic, confuse(m1453) is F1453<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1453 = (f1453 as dynamic); });
+ Expect.throws(() { x1453 = confuse(f1453); });
+ List<T> Function(int x2, [core.List<core.int> x3]) Function(int x) l1453;
+ Expect.throws(() { l1453 = (f1453 as dynamic); });
+ Expect.throws(() { l1453 = confuse(f1453); });
+ }
+ List<T> Function(int x2, [core.List<core.int> x3]) Function(int x) l1453 = m1453;
+ // In checked mode, verifies the type.
+ x1453 = m1453;
+ x1453 = confuse(m1453);
+ }
+ }
+
+ void testF1553() {
+ // Function({int x}) Function(int x)
+ Expect.isTrue(f1553 is F1553);
+ Expect.isTrue(confuse(f1553) is F1553);
+ // In checked mode, verifies the type.
+ Function({int x}) Function(int x) l1553;
+ // The static function f1553 sets `T` to `int`.
+ if (!tIsBool) {
+ x1553 = f1553 as dynamic;
+ l1553 = f1553 as dynamic;
+ x1553 = confuse(f1553);
+ l1553 = confuse(f1553);
+ }
+
+ Expect.isTrue(m1553 is F1553);
+ Expect.isTrue(m1553 is Function({int x}) Function(int x));
+ Expect.isTrue(confuse(m1553) is F1553);
+ // In checked mode, verifies the type.
+ x1553 = m1553;
+ l1553 = m1553;
+ x1553 = confuse(m1553);
+ l1553 = confuse(m1553);
+
+ }
+
+ void testF1653() {
+ // Function(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1653 is F1653);
+ Expect.isTrue(confuse(f1653) is F1653);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x) Function(int x) l1653;
+ // The static function f1653 sets `T` to `int`.
+ if (!tIsBool) {
+ x1653 = f1653 as dynamic;
+ l1653 = f1653 as dynamic;
+ x1653 = confuse(f1653);
+ l1653 = confuse(f1653);
+ }
+
+ Expect.isTrue(m1653 is F1653);
+ Expect.isTrue(m1653 is Function(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1653) is F1653);
+ // In checked mode, verifies the type.
+ x1653 = m1653;
+ l1653 = m1653;
+ x1653 = confuse(m1653);
+ l1653 = confuse(m1653);
+
+ }
+
+ void testF1753() {
+ // int Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1753 is F1753);
+ Expect.isTrue(confuse(f1753) is F1753);
+ // In checked mode, verifies the type.
+ int Function<A>(List<Function> x) Function(int x) l1753;
+ // The static function f1753 sets `T` to `int`.
+ if (!tIsBool) {
+ x1753 = f1753 as dynamic;
+ l1753 = f1753 as dynamic;
+ x1753 = confuse(f1753);
+ l1753 = confuse(f1753);
+ }
+
+ Expect.isTrue(m1753 is F1753);
+ Expect.isTrue(m1753 is int Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1753) is F1753);
+ // In checked mode, verifies the type.
+ x1753 = m1753;
+ l1753 = m1753;
+ x1753 = confuse(m1753);
+ l1753 = confuse(m1753);
+
+ }
+
+ void testF1853() {
+ // core.List<core.int> Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1853 is F1853);
+ Expect.isTrue(confuse(f1853) is F1853);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(core.List<core.int> x) Function(int x) l1853;
+ // The static function f1853 sets `T` to `int`.
+ if (!tIsBool) {
+ x1853 = f1853 as dynamic;
+ l1853 = f1853 as dynamic;
+ x1853 = confuse(f1853);
+ l1853 = confuse(f1853);
+ }
+
+ Expect.isTrue(m1853 is F1853);
+ Expect.isTrue(m1853 is core.List<core.int> Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1853) is F1853);
+ // In checked mode, verifies the type.
+ x1853 = m1853;
+ l1853 = m1853;
+ x1853 = confuse(m1853);
+ l1853 = confuse(m1853);
+
+ }
+
+ void testF1953() {
+ // A Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1953 is F1953);
+ Expect.isTrue(confuse(f1953) is F1953);
+ // In checked mode, verifies the type.
+ A Function<A>(List<T> x) Function(int x) l1953;
+ // The static function f1953 sets `T` to `int`.
+ if (!tIsBool) {
+ x1953 = f1953 as dynamic;
+ l1953 = f1953 as dynamic;
+ x1953 = confuse(f1953);
+ l1953 = confuse(f1953);
+ }
+
+ Expect.isTrue(m1953 is F1953);
+ Expect.isTrue(m1953 is A Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1953) is F1953);
+ // In checked mode, verifies the type.
+ x1953 = m1953;
+ l1953 = m1953;
+ x1953 = confuse(m1953);
+ l1953 = confuse(m1953);
+ if (!tIsBool) {
+ Expect.isTrue(f1953 is F1953<int>);
+ Expect.isFalse(f1953 is F1953<bool>);
+ Expect.isTrue(confuse(f1953) is F1953<int>);
+ Expect.isFalse(confuse(f1953) is F1953<bool>);
+ Expect.equals(tIsDynamic, m1953 is F1953<bool>);
+ Expect.equals(tIsDynamic, confuse(m1953) is F1953<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1953 = (f1953 as dynamic); });
+ Expect.throws(() { x1953 = confuse(f1953); });
+ A Function<A>(List<T> x) Function(int x) l1953;
+ Expect.throws(() { l1953 = (f1953 as dynamic); });
+ Expect.throws(() { l1953 = confuse(f1953); });
+ }
+ A Function<A>(List<T> x) Function(int x) l1953 = m1953;
+ // In checked mode, verifies the type.
+ x1953 = m1953;
+ x1953 = confuse(m1953);
+ }
+ }
+
+
+}
+
+class C54<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function(int y, {List<T> x}) x54;
+ List<Function> Function(int x0, {core.List<core.int> x}) x154;
+ List<T> Function({List<Function> x}) x254;
+ List<Function> Function<A>(List<Function> x) x354;
+ int Function(int x1, [Function x]) Function<B extends core.int>() x454;
+ int Function([core.List<core.int> x1]) Function<B extends core.int>() x554;
+ Function Function(int x, [int x1]) Function<B extends core.int>() x654;
+ Function Function(int y, {List<Function> x}) Function<B extends core.int>() x754;
+ List<Function> Function([int x]) Function<B extends core.int>() x854;
+ List<Function> Function(List<Function> x1) Function<B extends core.int>() x954;
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>() x1054;
+ core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>() x1154;
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>() x1254;
+ List<T> Function(int y, [Function x]) Function<B extends core.int>() x1354;
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() x1454;
+ Function({int x}) Function<B extends core.int>() x1554;
+ Function(core.List<core.int> x) Function<B extends core.int>() x1654;
+ int Function<A>(List<Function> x) Function<B extends core.int>() x1754;
+ core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>() x1854;
+ A Function<A>(List<T> x) Function<B extends core.int>() x1954;
+
+
+ C54({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m54(int y, {List<T> x}) => null;
+ List<Function> m154(int x0, {core.List<core.int> x}) => null;
+ List<T> m254({List<Function> x}) => null;
+ List<Function> m354<A>(List<Function> x) => null;
+ int Function(int x0, [Function x]) m454<B extends core.int>() => null;
+ int Function([core.List<core.int> x0]) m554<B extends core.int>() => null;
+ Function Function(int x, [int x0]) m654<B extends core.int>() => null;
+ Function Function(int y, {List<Function> x}) m754<B extends core.int>() => null;
+ List<Function> Function([int x]) m854<B extends core.int>() => null;
+ List<Function> Function(List<Function> x0) m954<B extends core.int>() => null;
+ List<Function> Function(int x, [List<T> x0]) m1054<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, {Function x}) m1154<B extends core.int>() => null;
+ core.List<core.int> Function([List<T> x]) m1254<B extends core.int>() => null;
+ List<T> Function(int y, [Function x]) m1354<B extends core.int>() => null;
+ List<T> Function(int x0, [core.List<core.int> x1]) m1454<B extends core.int>() => null;
+ Function({int x}) m1554<B extends core.int>() => null;
+ Function(core.List<core.int> x) m1654<B extends core.int>() => null;
+ int Function<A>(List<Function> x) m1754<B extends core.int>() => null;
+ core.List<core.int> Function<A>(core.List<core.int> x) m1854<B extends core.int>() => null;
+ A Function<A>(List<T> x) m1954<B extends core.int>() => null;
+
+
+ runTests() {
+ testF54();
+ testF154();
+ testF254();
+ testF354();
+ testF454();
+ testF554();
+ testF654();
+ testF754();
+ testF854();
+ testF954();
+ testF1054();
+ testF1154();
+ testF1254();
+ testF1354();
+ testF1454();
+ testF1554();
+ testF1654();
+ testF1754();
+ testF1854();
+ testF1954();
+ }
+
+ void testF54() {
+ // int Function(int y, {List<T> x})
+ Expect.isTrue(f54 is F54);
+ Expect.isTrue(confuse(f54) is F54);
+ // In checked mode, verifies the type.
+ int Function(int y, {List<T> x}) l54;
+ // The static function f54 sets `T` to `int`.
+ if (!tIsBool) {
+ x54 = f54 as dynamic;
+ l54 = f54 as dynamic;
+ x54 = confuse(f54);
+ l54 = confuse(f54);
+ }
+
+ Expect.isTrue(m54 is F54);
+ Expect.isTrue(m54 is int Function(int y, {List<T> x}));
+ Expect.isTrue(confuse(m54) is F54);
+ // In checked mode, verifies the type.
+ x54 = m54;
+ l54 = m54;
+ x54 = confuse(m54);
+ l54 = confuse(m54);
+ if (!tIsBool) {
+ Expect.isTrue(f54 is F54<int>);
+ Expect.isFalse(f54 is F54<bool>);
+ Expect.isTrue(confuse(f54) is F54<int>);
+ Expect.isFalse(confuse(f54) is F54<bool>);
+ Expect.equals(tIsDynamic, m54 is F54<bool>);
+ Expect.equals(tIsDynamic, confuse(m54) is F54<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x54 = (f54 as dynamic); });
+ Expect.throws(() { x54 = confuse(f54); });
+ int Function(int y, {List<T> x}) l54;
+ Expect.throws(() { l54 = (f54 as dynamic); });
+ Expect.throws(() { l54 = confuse(f54); });
+ }
+ int Function(int y, {List<T> x}) l54 = m54;
+ // In checked mode, verifies the type.
+ x54 = m54;
+ x54 = confuse(m54);
+ }
+ }
+
+ void testF154() {
+ // List<Function> Function(int x0, {core.List<core.int> x})
+ Expect.isTrue(f154 is F154);
+ Expect.isTrue(confuse(f154) is F154);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {core.List<core.int> x}) l154;
+ // The static function f154 sets `T` to `int`.
+ if (!tIsBool) {
+ x154 = f154 as dynamic;
+ l154 = f154 as dynamic;
+ x154 = confuse(f154);
+ l154 = confuse(f154);
+ }
+
+ Expect.isTrue(m154 is F154);
+ Expect.isTrue(m154 is List<Function> Function(int x0, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m154) is F154);
+ // In checked mode, verifies the type.
+ x154 = m154;
+ l154 = m154;
+ x154 = confuse(m154);
+ l154 = confuse(m154);
+
+ }
+
+ void testF254() {
+ // List<T> Function({List<Function> x})
+ Expect.isTrue(f254 is F254);
+ Expect.isTrue(confuse(f254) is F254);
+ // In checked mode, verifies the type.
+ List<T> Function({List<Function> x}) l254;
+ // The static function f254 sets `T` to `int`.
+ if (!tIsBool) {
+ x254 = f254 as dynamic;
+ l254 = f254 as dynamic;
+ x254 = confuse(f254);
+ l254 = confuse(f254);
+ }
+
+ Expect.isTrue(m254 is F254);
+ Expect.isTrue(m254 is List<T> Function({List<Function> x}));
+ Expect.isTrue(confuse(m254) is F254);
+ // In checked mode, verifies the type.
+ x254 = m254;
+ l254 = m254;
+ x254 = confuse(m254);
+ l254 = confuse(m254);
+ if (!tIsBool) {
+ Expect.isTrue(f254 is F254<int>);
+ Expect.isFalse(f254 is F254<bool>);
+ Expect.isTrue(confuse(f254) is F254<int>);
+ Expect.isFalse(confuse(f254) is F254<bool>);
+ Expect.equals(tIsDynamic, m254 is F254<bool>);
+ Expect.equals(tIsDynamic, confuse(m254) is F254<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x254 = (f254 as dynamic); });
+ Expect.throws(() { x254 = confuse(f254); });
+ List<T> Function({List<Function> x}) l254;
+ Expect.throws(() { l254 = (f254 as dynamic); });
+ Expect.throws(() { l254 = confuse(f254); });
+ }
+ List<T> Function({List<Function> x}) l254 = m254;
+ // In checked mode, verifies the type.
+ x254 = m254;
+ x254 = confuse(m254);
+ }
+ }
+
+ void testF354() {
+ // List<Function> Function<A>(List<Function> x)
+ Expect.isTrue(f354 is F354);
+ Expect.isTrue(confuse(f354) is F354);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<Function> x) l354;
+ // The static function f354 sets `T` to `int`.
+ if (!tIsBool) {
+ x354 = f354 as dynamic;
+ l354 = f354 as dynamic;
+ x354 = confuse(f354);
+ l354 = confuse(f354);
+ }
+
+ Expect.isTrue(m354 is F354);
+ Expect.isTrue(m354 is List<Function> Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m354) is F354);
+ // In checked mode, verifies the type.
+ x354 = m354;
+ l354 = m354;
+ x354 = confuse(m354);
+ l354 = confuse(m354);
+
+ }
+
+ void testF454() {
+ // int Function(int x1, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f454 is F454);
+ Expect.isTrue(confuse(f454) is F454);
+ // In checked mode, verifies the type.
+ int Function(int x1, [Function x]) Function<B extends core.int>() l454;
+ // The static function f454 sets `T` to `int`.
+ if (!tIsBool) {
+ x454 = f454 as dynamic;
+ l454 = f454 as dynamic;
+ x454 = confuse(f454);
+ l454 = confuse(f454);
+ }
+
+ Expect.isTrue(m454 is F454);
+ Expect.isTrue(m454 is int Function(int x1, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m454) is F454);
+ // In checked mode, verifies the type.
+ x454 = m454;
+ l454 = m454;
+ x454 = confuse(m454);
+ l454 = confuse(m454);
+
+ }
+
+ void testF554() {
+ // int Function([core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f554 is F554);
+ Expect.isTrue(confuse(f554) is F554);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x1]) Function<B extends core.int>() l554;
+ // The static function f554 sets `T` to `int`.
+ if (!tIsBool) {
+ x554 = f554 as dynamic;
+ l554 = f554 as dynamic;
+ x554 = confuse(f554);
+ l554 = confuse(f554);
+ }
+
+ Expect.isTrue(m554 is F554);
+ Expect.isTrue(m554 is int Function([core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m554) is F554);
+ // In checked mode, verifies the type.
+ x554 = m554;
+ l554 = m554;
+ x554 = confuse(m554);
+ l554 = confuse(m554);
+
+ }
+
+ void testF654() {
+ // Function Function(int x, [int x1]) Function<B extends core.int>()
+ Expect.isTrue(f654 is F654);
+ Expect.isTrue(confuse(f654) is F654);
+ // In checked mode, verifies the type.
+ Function Function(int x, [int x1]) Function<B extends core.int>() l654;
+ // The static function f654 sets `T` to `int`.
+ if (!tIsBool) {
+ x654 = f654 as dynamic;
+ l654 = f654 as dynamic;
+ x654 = confuse(f654);
+ l654 = confuse(f654);
+ }
+
+ Expect.isTrue(m654 is F654);
+ Expect.isTrue(m654 is Function Function(int x, [int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m654) is F654);
+ // In checked mode, verifies the type.
+ x654 = m654;
+ l654 = m654;
+ x654 = confuse(m654);
+ l654 = confuse(m654);
+
+ }
+
+ void testF754() {
+ // Function Function(int y, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f754 is F754);
+ Expect.isTrue(confuse(f754) is F754);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<Function> x}) Function<B extends core.int>() l754;
+ // The static function f754 sets `T` to `int`.
+ if (!tIsBool) {
+ x754 = f754 as dynamic;
+ l754 = f754 as dynamic;
+ x754 = confuse(f754);
+ l754 = confuse(f754);
+ }
+
+ Expect.isTrue(m754 is F754);
+ Expect.isTrue(m754 is Function Function(int y, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m754) is F754);
+ // In checked mode, verifies the type.
+ x754 = m754;
+ l754 = m754;
+ x754 = confuse(m754);
+ l754 = confuse(m754);
+
+ }
+
+ void testF854() {
+ // List<Function> Function([int x]) Function<B extends core.int>()
+ Expect.isTrue(f854 is F854);
+ Expect.isTrue(confuse(f854) is F854);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x]) Function<B extends core.int>() l854;
+ // The static function f854 sets `T` to `int`.
+ if (!tIsBool) {
+ x854 = f854 as dynamic;
+ l854 = f854 as dynamic;
+ x854 = confuse(f854);
+ l854 = confuse(f854);
+ }
+
+ Expect.isTrue(m854 is F854);
+ Expect.isTrue(m854 is List<Function> Function([int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m854) is F854);
+ // In checked mode, verifies the type.
+ x854 = m854;
+ l854 = m854;
+ x854 = confuse(m854);
+ l854 = confuse(m854);
+
+ }
+
+ void testF954() {
+ // List<Function> Function(List<Function> x1) Function<B extends core.int>()
+ Expect.isTrue(f954 is F954);
+ Expect.isTrue(confuse(f954) is F954);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x1) Function<B extends core.int>() l954;
+ // The static function f954 sets `T` to `int`.
+ if (!tIsBool) {
+ x954 = f954 as dynamic;
+ l954 = f954 as dynamic;
+ x954 = confuse(f954);
+ l954 = confuse(f954);
+ }
+
+ Expect.isTrue(m954 is F954);
+ Expect.isTrue(m954 is List<Function> Function(List<Function> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m954) is F954);
+ // In checked mode, verifies the type.
+ x954 = m954;
+ l954 = m954;
+ x954 = confuse(m954);
+ l954 = confuse(m954);
+
+ }
+
+ void testF1054() {
+ // List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1054 is F1054);
+ Expect.isTrue(confuse(f1054) is F1054);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>() l1054;
+ // The static function f1054 sets `T` to `int`.
+ if (!tIsBool) {
+ x1054 = f1054 as dynamic;
+ l1054 = f1054 as dynamic;
+ x1054 = confuse(f1054);
+ l1054 = confuse(f1054);
+ }
+
+ Expect.isTrue(m1054 is F1054);
+ Expect.isTrue(m1054 is List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1054) is F1054);
+ // In checked mode, verifies the type.
+ x1054 = m1054;
+ l1054 = m1054;
+ x1054 = confuse(m1054);
+ l1054 = confuse(m1054);
+ if (!tIsBool) {
+ Expect.isTrue(f1054 is F1054<int>);
+ Expect.isFalse(f1054 is F1054<bool>);
+ Expect.isTrue(confuse(f1054) is F1054<int>);
+ Expect.isFalse(confuse(f1054) is F1054<bool>);
+ Expect.equals(tIsDynamic, m1054 is F1054<bool>);
+ Expect.equals(tIsDynamic, confuse(m1054) is F1054<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1054 = (f1054 as dynamic); });
+ Expect.throws(() { x1054 = confuse(f1054); });
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>() l1054;
+ Expect.throws(() { l1054 = (f1054 as dynamic); });
+ Expect.throws(() { l1054 = confuse(f1054); });
+ }
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>() l1054 = m1054;
+ // In checked mode, verifies the type.
+ x1054 = m1054;
+ x1054 = confuse(m1054);
+ }
+ }
+
+ void testF1154() {
+ // core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1154 is F1154);
+ Expect.isTrue(confuse(f1154) is F1154);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>() l1154;
+ // The static function f1154 sets `T` to `int`.
+ if (!tIsBool) {
+ x1154 = f1154 as dynamic;
+ l1154 = f1154 as dynamic;
+ x1154 = confuse(f1154);
+ l1154 = confuse(f1154);
+ }
+
+ Expect.isTrue(m1154 is F1154);
+ Expect.isTrue(m1154 is core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1154) is F1154);
+ // In checked mode, verifies the type.
+ x1154 = m1154;
+ l1154 = m1154;
+ x1154 = confuse(m1154);
+ l1154 = confuse(m1154);
+
+ }
+
+ void testF1254() {
+ // core.List<core.int> Function([List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1254 is F1254);
+ Expect.isTrue(confuse(f1254) is F1254);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>() l1254;
+ // The static function f1254 sets `T` to `int`.
+ if (!tIsBool) {
+ x1254 = f1254 as dynamic;
+ l1254 = f1254 as dynamic;
+ x1254 = confuse(f1254);
+ l1254 = confuse(f1254);
+ }
+
+ Expect.isTrue(m1254 is F1254);
+ Expect.isTrue(m1254 is core.List<core.int> Function([List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1254) is F1254);
+ // In checked mode, verifies the type.
+ x1254 = m1254;
+ l1254 = m1254;
+ x1254 = confuse(m1254);
+ l1254 = confuse(m1254);
+ if (!tIsBool) {
+ Expect.isTrue(f1254 is F1254<int>);
+ Expect.isFalse(f1254 is F1254<bool>);
+ Expect.isTrue(confuse(f1254) is F1254<int>);
+ Expect.isFalse(confuse(f1254) is F1254<bool>);
+ Expect.equals(tIsDynamic, m1254 is F1254<bool>);
+ Expect.equals(tIsDynamic, confuse(m1254) is F1254<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1254 = (f1254 as dynamic); });
+ Expect.throws(() { x1254 = confuse(f1254); });
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>() l1254;
+ Expect.throws(() { l1254 = (f1254 as dynamic); });
+ Expect.throws(() { l1254 = confuse(f1254); });
+ }
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>() l1254 = m1254;
+ // In checked mode, verifies the type.
+ x1254 = m1254;
+ x1254 = confuse(m1254);
+ }
+ }
+
+ void testF1354() {
+ // List<T> Function(int y, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1354 is F1354);
+ Expect.isTrue(confuse(f1354) is F1354);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [Function x]) Function<B extends core.int>() l1354;
+ // The static function f1354 sets `T` to `int`.
+ if (!tIsBool) {
+ x1354 = f1354 as dynamic;
+ l1354 = f1354 as dynamic;
+ x1354 = confuse(f1354);
+ l1354 = confuse(f1354);
+ }
+
+ Expect.isTrue(m1354 is F1354);
+ Expect.isTrue(m1354 is List<T> Function(int y, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1354) is F1354);
+ // In checked mode, verifies the type.
+ x1354 = m1354;
+ l1354 = m1354;
+ x1354 = confuse(m1354);
+ l1354 = confuse(m1354);
+ if (!tIsBool) {
+ Expect.isTrue(f1354 is F1354<int>);
+ Expect.isFalse(f1354 is F1354<bool>);
+ Expect.isTrue(confuse(f1354) is F1354<int>);
+ Expect.isFalse(confuse(f1354) is F1354<bool>);
+ Expect.equals(tIsDynamic, m1354 is F1354<bool>);
+ Expect.equals(tIsDynamic, confuse(m1354) is F1354<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1354 = (f1354 as dynamic); });
+ Expect.throws(() { x1354 = confuse(f1354); });
+ List<T> Function(int y, [Function x]) Function<B extends core.int>() l1354;
+ Expect.throws(() { l1354 = (f1354 as dynamic); });
+ Expect.throws(() { l1354 = confuse(f1354); });
+ }
+ List<T> Function(int y, [Function x]) Function<B extends core.int>() l1354 = m1354;
+ // In checked mode, verifies the type.
+ x1354 = m1354;
+ x1354 = confuse(m1354);
+ }
+ }
+
+ void testF1454() {
+ // List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1454 is F1454);
+ Expect.isTrue(confuse(f1454) is F1454);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l1454;
+ // The static function f1454 sets `T` to `int`.
+ if (!tIsBool) {
+ x1454 = f1454 as dynamic;
+ l1454 = f1454 as dynamic;
+ x1454 = confuse(f1454);
+ l1454 = confuse(f1454);
+ }
+
+ Expect.isTrue(m1454 is F1454);
+ Expect.isTrue(m1454 is List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1454) is F1454);
+ // In checked mode, verifies the type.
+ x1454 = m1454;
+ l1454 = m1454;
+ x1454 = confuse(m1454);
+ l1454 = confuse(m1454);
+ if (!tIsBool) {
+ Expect.isTrue(f1454 is F1454<int>);
+ Expect.isFalse(f1454 is F1454<bool>);
+ Expect.isTrue(confuse(f1454) is F1454<int>);
+ Expect.isFalse(confuse(f1454) is F1454<bool>);
+ Expect.equals(tIsDynamic, m1454 is F1454<bool>);
+ Expect.equals(tIsDynamic, confuse(m1454) is F1454<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1454 = (f1454 as dynamic); });
+ Expect.throws(() { x1454 = confuse(f1454); });
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l1454;
+ Expect.throws(() { l1454 = (f1454 as dynamic); });
+ Expect.throws(() { l1454 = confuse(f1454); });
+ }
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l1454 = m1454;
+ // In checked mode, verifies the type.
+ x1454 = m1454;
+ x1454 = confuse(m1454);
+ }
+ }
+
+ void testF1554() {
+ // Function({int x}) Function<B extends core.int>()
+ Expect.isTrue(f1554 is F1554);
+ Expect.isTrue(confuse(f1554) is F1554);
+ // In checked mode, verifies the type.
+ Function({int x}) Function<B extends core.int>() l1554;
+ // The static function f1554 sets `T` to `int`.
+ if (!tIsBool) {
+ x1554 = f1554 as dynamic;
+ l1554 = f1554 as dynamic;
+ x1554 = confuse(f1554);
+ l1554 = confuse(f1554);
+ }
+
+ Expect.isTrue(m1554 is F1554);
+ Expect.isTrue(m1554 is Function({int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1554) is F1554);
+ // In checked mode, verifies the type.
+ x1554 = m1554;
+ l1554 = m1554;
+ x1554 = confuse(m1554);
+ l1554 = confuse(m1554);
+
+ }
+
+ void testF1654() {
+ // Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1654 is F1654);
+ Expect.isTrue(confuse(f1654) is F1654);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x) Function<B extends core.int>() l1654;
+ // The static function f1654 sets `T` to `int`.
+ if (!tIsBool) {
+ x1654 = f1654 as dynamic;
+ l1654 = f1654 as dynamic;
+ x1654 = confuse(f1654);
+ l1654 = confuse(f1654);
+ }
+
+ Expect.isTrue(m1654 is F1654);
+ Expect.isTrue(m1654 is Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1654) is F1654);
+ // In checked mode, verifies the type.
+ x1654 = m1654;
+ l1654 = m1654;
+ x1654 = confuse(m1654);
+ l1654 = confuse(m1654);
+
+ }
+
+ void testF1754() {
+ // int Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1754 is F1754);
+ Expect.isTrue(confuse(f1754) is F1754);
+ // In checked mode, verifies the type.
+ int Function<A>(List<Function> x) Function<B extends core.int>() l1754;
+ // The static function f1754 sets `T` to `int`.
+ if (!tIsBool) {
+ x1754 = f1754 as dynamic;
+ l1754 = f1754 as dynamic;
+ x1754 = confuse(f1754);
+ l1754 = confuse(f1754);
+ }
+
+ Expect.isTrue(m1754 is F1754);
+ Expect.isTrue(m1754 is int Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1754) is F1754);
+ // In checked mode, verifies the type.
+ x1754 = m1754;
+ l1754 = m1754;
+ x1754 = confuse(m1754);
+ l1754 = confuse(m1754);
+
+ }
+
+ void testF1854() {
+ // core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1854 is F1854);
+ Expect.isTrue(confuse(f1854) is F1854);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>() l1854;
+ // The static function f1854 sets `T` to `int`.
+ if (!tIsBool) {
+ x1854 = f1854 as dynamic;
+ l1854 = f1854 as dynamic;
+ x1854 = confuse(f1854);
+ l1854 = confuse(f1854);
+ }
+
+ Expect.isTrue(m1854 is F1854);
+ Expect.isTrue(m1854 is core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1854) is F1854);
+ // In checked mode, verifies the type.
+ x1854 = m1854;
+ l1854 = m1854;
+ x1854 = confuse(m1854);
+ l1854 = confuse(m1854);
+
+ }
+
+ void testF1954() {
+ // A Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1954 is F1954);
+ Expect.isTrue(confuse(f1954) is F1954);
+ // In checked mode, verifies the type.
+ A Function<A>(List<T> x) Function<B extends core.int>() l1954;
+ // The static function f1954 sets `T` to `int`.
+ if (!tIsBool) {
+ x1954 = f1954 as dynamic;
+ l1954 = f1954 as dynamic;
+ x1954 = confuse(f1954);
+ l1954 = confuse(f1954);
+ }
+
+ Expect.isTrue(m1954 is F1954);
+ Expect.isTrue(m1954 is A Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1954) is F1954);
+ // In checked mode, verifies the type.
+ x1954 = m1954;
+ l1954 = m1954;
+ x1954 = confuse(m1954);
+ l1954 = confuse(m1954);
+ if (!tIsBool) {
+ Expect.isTrue(f1954 is F1954<int>);
+ Expect.isFalse(f1954 is F1954<bool>);
+ Expect.isTrue(confuse(f1954) is F1954<int>);
+ Expect.isFalse(confuse(f1954) is F1954<bool>);
+ Expect.equals(tIsDynamic, m1954 is F1954<bool>);
+ Expect.equals(tIsDynamic, confuse(m1954) is F1954<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1954 = (f1954 as dynamic); });
+ Expect.throws(() { x1954 = confuse(f1954); });
+ A Function<A>(List<T> x) Function<B extends core.int>() l1954;
+ Expect.throws(() { l1954 = (f1954 as dynamic); });
+ Expect.throws(() { l1954 = confuse(f1954); });
+ }
+ A Function<A>(List<T> x) Function<B extends core.int>() l1954 = m1954;
+ // In checked mode, verifies the type.
+ x1954 = m1954;
+ x1954 = confuse(m1954);
+ }
+ }
+
+
+}
+
+class C55<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ int Function() x55;
+ List<Function> Function(int y, {core.List<core.int> x}) x155;
+ List<T> Function(int x0, {List<Function> x}) x255;
+ List<Function> Function<A>(core.List<core.int> x) x355;
+ int Function(int x1, [Function x]) Function<B extends core.int>(int x) x455;
+ int Function([core.List<core.int> x1]) Function<B extends core.int>(int x) x555;
+ Function Function(int x, [int x1]) Function<B extends core.int>(int x) x655;
+ Function Function(int y, {List<Function> x}) Function<B extends core.int>(int x) x755;
+ List<Function> Function([int x]) Function<B extends core.int>(int x) x855;
+ List<Function> Function(List<Function> x1) Function<B extends core.int>(int x) x955;
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) x1055;
+ core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>(int x) x1155;
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x) x1255;
+ List<T> Function(int y, [Function x]) Function<B extends core.int>(int x) x1355;
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) x1455;
+ Function({int x}) Function<B extends core.int>(int x) x1555;
+ Function(core.List<core.int> x) Function<B extends core.int>(int x) x1655;
+ int Function<A>(List<Function> x) Function<B extends core.int>(int x) x1755;
+ core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1855;
+ A Function<A>(List<T> x) Function<B extends core.int>(int x) x1955;
+
+
+ C55({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ int m55() => null;
+ List<Function> m155(int y, {core.List<core.int> x}) => null;
+ List<T> m255(int x0, {List<Function> x}) => null;
+ List<Function> m355<A>(core.List<core.int> x) => null;
+ int Function(int x0, [Function x]) m455<B extends core.int>(int x) => null;
+ int Function([core.List<core.int> x0]) m555<B extends core.int>(int x) => null;
+ Function Function(int x, [int x0]) m655<B extends core.int>(int x) => null;
+ Function Function(int y, {List<Function> x}) m755<B extends core.int>(int x) => null;
+ List<Function> Function([int x]) m855<B extends core.int>(int x) => null;
+ List<Function> Function(List<Function> x0) m955<B extends core.int>(int x) => null;
+ List<Function> Function(int x, [List<T> x0]) m1055<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, {Function x}) m1155<B extends core.int>(int x) => null;
+ core.List<core.int> Function([List<T> x]) m1255<B extends core.int>(int x) => null;
+ List<T> Function(int y, [Function x]) m1355<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [core.List<core.int> x1]) m1455<B extends core.int>(int x) => null;
+ Function({int x}) m1555<B extends core.int>(int x) => null;
+ Function(core.List<core.int> x) m1655<B extends core.int>(int x) => null;
+ int Function<A>(List<Function> x) m1755<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(core.List<core.int> x) m1855<B extends core.int>(int x) => null;
+ A Function<A>(List<T> x) m1955<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF55();
+ testF155();
+ testF255();
+ testF355();
+ testF455();
+ testF555();
+ testF655();
+ testF755();
+ testF855();
+ testF955();
+ testF1055();
+ testF1155();
+ testF1255();
+ testF1355();
+ testF1455();
+ testF1555();
+ testF1655();
+ testF1755();
+ testF1855();
+ testF1955();
+ }
+
+ void testF55() {
+ // int Function()
+ Expect.isTrue(f55 is F55);
+ Expect.isTrue(confuse(f55) is F55);
+ // In checked mode, verifies the type.
+ int Function() l55;
+ // The static function f55 sets `T` to `int`.
+ if (!tIsBool) {
+ x55 = f55 as dynamic;
+ l55 = f55 as dynamic;
+ x55 = confuse(f55);
+ l55 = confuse(f55);
+ }
+
+ Expect.isTrue(m55 is F55);
+ Expect.isTrue(m55 is int Function());
+ Expect.isTrue(confuse(m55) is F55);
+ // In checked mode, verifies the type.
+ x55 = m55;
+ l55 = m55;
+ x55 = confuse(m55);
+ l55 = confuse(m55);
+
+ }
+
+ void testF155() {
+ // List<Function> Function(int y, {core.List<core.int> x})
+ Expect.isTrue(f155 is F155);
+ Expect.isTrue(confuse(f155) is F155);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {core.List<core.int> x}) l155;
+ // The static function f155 sets `T` to `int`.
+ if (!tIsBool) {
+ x155 = f155 as dynamic;
+ l155 = f155 as dynamic;
+ x155 = confuse(f155);
+ l155 = confuse(f155);
+ }
+
+ Expect.isTrue(m155 is F155);
+ Expect.isTrue(m155 is List<Function> Function(int y, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m155) is F155);
+ // In checked mode, verifies the type.
+ x155 = m155;
+ l155 = m155;
+ x155 = confuse(m155);
+ l155 = confuse(m155);
+
+ }
+
+ void testF255() {
+ // List<T> Function(int x0, {List<Function> x})
+ Expect.isTrue(f255 is F255);
+ Expect.isTrue(confuse(f255) is F255);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {List<Function> x}) l255;
+ // The static function f255 sets `T` to `int`.
+ if (!tIsBool) {
+ x255 = f255 as dynamic;
+ l255 = f255 as dynamic;
+ x255 = confuse(f255);
+ l255 = confuse(f255);
+ }
+
+ Expect.isTrue(m255 is F255);
+ Expect.isTrue(m255 is List<T> Function(int x0, {List<Function> x}));
+ Expect.isTrue(confuse(m255) is F255);
+ // In checked mode, verifies the type.
+ x255 = m255;
+ l255 = m255;
+ x255 = confuse(m255);
+ l255 = confuse(m255);
+ if (!tIsBool) {
+ Expect.isTrue(f255 is F255<int>);
+ Expect.isFalse(f255 is F255<bool>);
+ Expect.isTrue(confuse(f255) is F255<int>);
+ Expect.isFalse(confuse(f255) is F255<bool>);
+ Expect.equals(tIsDynamic, m255 is F255<bool>);
+ Expect.equals(tIsDynamic, confuse(m255) is F255<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x255 = (f255 as dynamic); });
+ Expect.throws(() { x255 = confuse(f255); });
+ List<T> Function(int x0, {List<Function> x}) l255;
+ Expect.throws(() { l255 = (f255 as dynamic); });
+ Expect.throws(() { l255 = confuse(f255); });
+ }
+ List<T> Function(int x0, {List<Function> x}) l255 = m255;
+ // In checked mode, verifies the type.
+ x255 = m255;
+ x255 = confuse(m255);
+ }
+ }
+
+ void testF355() {
+ // List<Function> Function<A>(core.List<core.int> x)
+ Expect.isTrue(f355 is F355);
+ Expect.isTrue(confuse(f355) is F355);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(core.List<core.int> x) l355;
+ // The static function f355 sets `T` to `int`.
+ if (!tIsBool) {
+ x355 = f355 as dynamic;
+ l355 = f355 as dynamic;
+ x355 = confuse(f355);
+ l355 = confuse(f355);
+ }
+
+ Expect.isTrue(m355 is F355);
+ Expect.isTrue(m355 is List<Function> Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m355) is F355);
+ // In checked mode, verifies the type.
+ x355 = m355;
+ l355 = m355;
+ x355 = confuse(m355);
+ l355 = confuse(m355);
+
+ }
+
+ void testF455() {
+ // int Function(int x1, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f455 is F455);
+ Expect.isTrue(confuse(f455) is F455);
+ // In checked mode, verifies the type.
+ int Function(int x1, [Function x]) Function<B extends core.int>(int x) l455;
+ // The static function f455 sets `T` to `int`.
+ if (!tIsBool) {
+ x455 = f455 as dynamic;
+ l455 = f455 as dynamic;
+ x455 = confuse(f455);
+ l455 = confuse(f455);
+ }
+
+ Expect.isTrue(m455 is F455);
+ Expect.isTrue(m455 is int Function(int x1, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m455) is F455);
+ // In checked mode, verifies the type.
+ x455 = m455;
+ l455 = m455;
+ x455 = confuse(m455);
+ l455 = confuse(m455);
+
+ }
+
+ void testF555() {
+ // int Function([core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f555 is F555);
+ Expect.isTrue(confuse(f555) is F555);
+ // In checked mode, verifies the type.
+ int Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l555;
+ // The static function f555 sets `T` to `int`.
+ if (!tIsBool) {
+ x555 = f555 as dynamic;
+ l555 = f555 as dynamic;
+ x555 = confuse(f555);
+ l555 = confuse(f555);
+ }
+
+ Expect.isTrue(m555 is F555);
+ Expect.isTrue(m555 is int Function([core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m555) is F555);
+ // In checked mode, verifies the type.
+ x555 = m555;
+ l555 = m555;
+ x555 = confuse(m555);
+ l555 = confuse(m555);
+
+ }
+
+ void testF655() {
+ // Function Function(int x, [int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f655 is F655);
+ Expect.isTrue(confuse(f655) is F655);
+ // In checked mode, verifies the type.
+ Function Function(int x, [int x1]) Function<B extends core.int>(int x) l655;
+ // The static function f655 sets `T` to `int`.
+ if (!tIsBool) {
+ x655 = f655 as dynamic;
+ l655 = f655 as dynamic;
+ x655 = confuse(f655);
+ l655 = confuse(f655);
+ }
+
+ Expect.isTrue(m655 is F655);
+ Expect.isTrue(m655 is Function Function(int x, [int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m655) is F655);
+ // In checked mode, verifies the type.
+ x655 = m655;
+ l655 = m655;
+ x655 = confuse(m655);
+ l655 = confuse(m655);
+
+ }
+
+ void testF755() {
+ // Function Function(int y, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f755 is F755);
+ Expect.isTrue(confuse(f755) is F755);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l755;
+ // The static function f755 sets `T` to `int`.
+ if (!tIsBool) {
+ x755 = f755 as dynamic;
+ l755 = f755 as dynamic;
+ x755 = confuse(f755);
+ l755 = confuse(f755);
+ }
+
+ Expect.isTrue(m755 is F755);
+ Expect.isTrue(m755 is Function Function(int y, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m755) is F755);
+ // In checked mode, verifies the type.
+ x755 = m755;
+ l755 = m755;
+ x755 = confuse(m755);
+ l755 = confuse(m755);
+
+ }
+
+ void testF855() {
+ // List<Function> Function([int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f855 is F855);
+ Expect.isTrue(confuse(f855) is F855);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x]) Function<B extends core.int>(int x) l855;
+ // The static function f855 sets `T` to `int`.
+ if (!tIsBool) {
+ x855 = f855 as dynamic;
+ l855 = f855 as dynamic;
+ x855 = confuse(f855);
+ l855 = confuse(f855);
+ }
+
+ Expect.isTrue(m855 is F855);
+ Expect.isTrue(m855 is List<Function> Function([int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m855) is F855);
+ // In checked mode, verifies the type.
+ x855 = m855;
+ l855 = m855;
+ x855 = confuse(m855);
+ l855 = confuse(m855);
+
+ }
+
+ void testF955() {
+ // List<Function> Function(List<Function> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f955 is F955);
+ Expect.isTrue(confuse(f955) is F955);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<Function> x1) Function<B extends core.int>(int x) l955;
+ // The static function f955 sets `T` to `int`.
+ if (!tIsBool) {
+ x955 = f955 as dynamic;
+ l955 = f955 as dynamic;
+ x955 = confuse(f955);
+ l955 = confuse(f955);
+ }
+
+ Expect.isTrue(m955 is F955);
+ Expect.isTrue(m955 is List<Function> Function(List<Function> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m955) is F955);
+ // In checked mode, verifies the type.
+ x955 = m955;
+ l955 = m955;
+ x955 = confuse(m955);
+ l955 = confuse(m955);
+
+ }
+
+ void testF1055() {
+ // List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1055 is F1055);
+ Expect.isTrue(confuse(f1055) is F1055);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1055;
+ // The static function f1055 sets `T` to `int`.
+ if (!tIsBool) {
+ x1055 = f1055 as dynamic;
+ l1055 = f1055 as dynamic;
+ x1055 = confuse(f1055);
+ l1055 = confuse(f1055);
+ }
+
+ Expect.isTrue(m1055 is F1055);
+ Expect.isTrue(m1055 is List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1055) is F1055);
+ // In checked mode, verifies the type.
+ x1055 = m1055;
+ l1055 = m1055;
+ x1055 = confuse(m1055);
+ l1055 = confuse(m1055);
+ if (!tIsBool) {
+ Expect.isTrue(f1055 is F1055<int>);
+ Expect.isFalse(f1055 is F1055<bool>);
+ Expect.isTrue(confuse(f1055) is F1055<int>);
+ Expect.isFalse(confuse(f1055) is F1055<bool>);
+ Expect.equals(tIsDynamic, m1055 is F1055<bool>);
+ Expect.equals(tIsDynamic, confuse(m1055) is F1055<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1055 = (f1055 as dynamic); });
+ Expect.throws(() { x1055 = confuse(f1055); });
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1055;
+ Expect.throws(() { l1055 = (f1055 as dynamic); });
+ Expect.throws(() { l1055 = confuse(f1055); });
+ }
+ List<Function> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1055 = m1055;
+ // In checked mode, verifies the type.
+ x1055 = m1055;
+ x1055 = confuse(m1055);
+ }
+ }
+
+ void testF1155() {
+ // core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1155 is F1155);
+ Expect.isTrue(confuse(f1155) is F1155);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>(int x) l1155;
+ // The static function f1155 sets `T` to `int`.
+ if (!tIsBool) {
+ x1155 = f1155 as dynamic;
+ l1155 = f1155 as dynamic;
+ x1155 = confuse(f1155);
+ l1155 = confuse(f1155);
+ }
+
+ Expect.isTrue(m1155 is F1155);
+ Expect.isTrue(m1155 is core.List<core.int> Function(int x1, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1155) is F1155);
+ // In checked mode, verifies the type.
+ x1155 = m1155;
+ l1155 = m1155;
+ x1155 = confuse(m1155);
+ l1155 = confuse(m1155);
+
+ }
+
+ void testF1255() {
+ // core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1255 is F1255);
+ Expect.isTrue(confuse(f1255) is F1255);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x) l1255;
+ // The static function f1255 sets `T` to `int`.
+ if (!tIsBool) {
+ x1255 = f1255 as dynamic;
+ l1255 = f1255 as dynamic;
+ x1255 = confuse(f1255);
+ l1255 = confuse(f1255);
+ }
+
+ Expect.isTrue(m1255 is F1255);
+ Expect.isTrue(m1255 is core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1255) is F1255);
+ // In checked mode, verifies the type.
+ x1255 = m1255;
+ l1255 = m1255;
+ x1255 = confuse(m1255);
+ l1255 = confuse(m1255);
+ if (!tIsBool) {
+ Expect.isTrue(f1255 is F1255<int>);
+ Expect.isFalse(f1255 is F1255<bool>);
+ Expect.isTrue(confuse(f1255) is F1255<int>);
+ Expect.isFalse(confuse(f1255) is F1255<bool>);
+ Expect.equals(tIsDynamic, m1255 is F1255<bool>);
+ Expect.equals(tIsDynamic, confuse(m1255) is F1255<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1255 = (f1255 as dynamic); });
+ Expect.throws(() { x1255 = confuse(f1255); });
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x) l1255;
+ Expect.throws(() { l1255 = (f1255 as dynamic); });
+ Expect.throws(() { l1255 = confuse(f1255); });
+ }
+ core.List<core.int> Function([List<T> x]) Function<B extends core.int>(int x) l1255 = m1255;
+ // In checked mode, verifies the type.
+ x1255 = m1255;
+ x1255 = confuse(m1255);
+ }
+ }
+
+ void testF1355() {
+ // List<T> Function(int y, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1355 is F1355);
+ Expect.isTrue(confuse(f1355) is F1355);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [Function x]) Function<B extends core.int>(int x) l1355;
+ // The static function f1355 sets `T` to `int`.
+ if (!tIsBool) {
+ x1355 = f1355 as dynamic;
+ l1355 = f1355 as dynamic;
+ x1355 = confuse(f1355);
+ l1355 = confuse(f1355);
+ }
+
+ Expect.isTrue(m1355 is F1355);
+ Expect.isTrue(m1355 is List<T> Function(int y, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1355) is F1355);
+ // In checked mode, verifies the type.
+ x1355 = m1355;
+ l1355 = m1355;
+ x1355 = confuse(m1355);
+ l1355 = confuse(m1355);
+ if (!tIsBool) {
+ Expect.isTrue(f1355 is F1355<int>);
+ Expect.isFalse(f1355 is F1355<bool>);
+ Expect.isTrue(confuse(f1355) is F1355<int>);
+ Expect.isFalse(confuse(f1355) is F1355<bool>);
+ Expect.equals(tIsDynamic, m1355 is F1355<bool>);
+ Expect.equals(tIsDynamic, confuse(m1355) is F1355<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1355 = (f1355 as dynamic); });
+ Expect.throws(() { x1355 = confuse(f1355); });
+ List<T> Function(int y, [Function x]) Function<B extends core.int>(int x) l1355;
+ Expect.throws(() { l1355 = (f1355 as dynamic); });
+ Expect.throws(() { l1355 = confuse(f1355); });
+ }
+ List<T> Function(int y, [Function x]) Function<B extends core.int>(int x) l1355 = m1355;
+ // In checked mode, verifies the type.
+ x1355 = m1355;
+ x1355 = confuse(m1355);
+ }
+ }
+
+ void testF1455() {
+ // List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1455 is F1455);
+ Expect.isTrue(confuse(f1455) is F1455);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l1455;
+ // The static function f1455 sets `T` to `int`.
+ if (!tIsBool) {
+ x1455 = f1455 as dynamic;
+ l1455 = f1455 as dynamic;
+ x1455 = confuse(f1455);
+ l1455 = confuse(f1455);
+ }
+
+ Expect.isTrue(m1455 is F1455);
+ Expect.isTrue(m1455 is List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1455) is F1455);
+ // In checked mode, verifies the type.
+ x1455 = m1455;
+ l1455 = m1455;
+ x1455 = confuse(m1455);
+ l1455 = confuse(m1455);
+ if (!tIsBool) {
+ Expect.isTrue(f1455 is F1455<int>);
+ Expect.isFalse(f1455 is F1455<bool>);
+ Expect.isTrue(confuse(f1455) is F1455<int>);
+ Expect.isFalse(confuse(f1455) is F1455<bool>);
+ Expect.equals(tIsDynamic, m1455 is F1455<bool>);
+ Expect.equals(tIsDynamic, confuse(m1455) is F1455<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1455 = (f1455 as dynamic); });
+ Expect.throws(() { x1455 = confuse(f1455); });
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l1455;
+ Expect.throws(() { l1455 = (f1455 as dynamic); });
+ Expect.throws(() { l1455 = confuse(f1455); });
+ }
+ List<T> Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l1455 = m1455;
+ // In checked mode, verifies the type.
+ x1455 = m1455;
+ x1455 = confuse(m1455);
+ }
+ }
+
+ void testF1555() {
+ // Function({int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1555 is F1555);
+ Expect.isTrue(confuse(f1555) is F1555);
+ // In checked mode, verifies the type.
+ Function({int x}) Function<B extends core.int>(int x) l1555;
+ // The static function f1555 sets `T` to `int`.
+ if (!tIsBool) {
+ x1555 = f1555 as dynamic;
+ l1555 = f1555 as dynamic;
+ x1555 = confuse(f1555);
+ l1555 = confuse(f1555);
+ }
+
+ Expect.isTrue(m1555 is F1555);
+ Expect.isTrue(m1555 is Function({int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1555) is F1555);
+ // In checked mode, verifies the type.
+ x1555 = m1555;
+ l1555 = m1555;
+ x1555 = confuse(m1555);
+ l1555 = confuse(m1555);
+
+ }
+
+ void testF1655() {
+ // Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1655 is F1655);
+ Expect.isTrue(confuse(f1655) is F1655);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x) Function<B extends core.int>(int x) l1655;
+ // The static function f1655 sets `T` to `int`.
+ if (!tIsBool) {
+ x1655 = f1655 as dynamic;
+ l1655 = f1655 as dynamic;
+ x1655 = confuse(f1655);
+ l1655 = confuse(f1655);
+ }
+
+ Expect.isTrue(m1655 is F1655);
+ Expect.isTrue(m1655 is Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1655) is F1655);
+ // In checked mode, verifies the type.
+ x1655 = m1655;
+ l1655 = m1655;
+ x1655 = confuse(m1655);
+ l1655 = confuse(m1655);
+
+ }
+
+ void testF1755() {
+ // int Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1755 is F1755);
+ Expect.isTrue(confuse(f1755) is F1755);
+ // In checked mode, verifies the type.
+ int Function<A>(List<Function> x) Function<B extends core.int>(int x) l1755;
+ // The static function f1755 sets `T` to `int`.
+ if (!tIsBool) {
+ x1755 = f1755 as dynamic;
+ l1755 = f1755 as dynamic;
+ x1755 = confuse(f1755);
+ l1755 = confuse(f1755);
+ }
+
+ Expect.isTrue(m1755 is F1755);
+ Expect.isTrue(m1755 is int Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1755) is F1755);
+ // In checked mode, verifies the type.
+ x1755 = m1755;
+ l1755 = m1755;
+ x1755 = confuse(m1755);
+ l1755 = confuse(m1755);
+
+ }
+
+ void testF1855() {
+ // core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1855 is F1855);
+ Expect.isTrue(confuse(f1855) is F1855);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1855;
+ // The static function f1855 sets `T` to `int`.
+ if (!tIsBool) {
+ x1855 = f1855 as dynamic;
+ l1855 = f1855 as dynamic;
+ x1855 = confuse(f1855);
+ l1855 = confuse(f1855);
+ }
+
+ Expect.isTrue(m1855 is F1855);
+ Expect.isTrue(m1855 is core.List<core.int> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1855) is F1855);
+ // In checked mode, verifies the type.
+ x1855 = m1855;
+ l1855 = m1855;
+ x1855 = confuse(m1855);
+ l1855 = confuse(m1855);
+
+ }
+
+ void testF1955() {
+ // A Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1955 is F1955);
+ Expect.isTrue(confuse(f1955) is F1955);
+ // In checked mode, verifies the type.
+ A Function<A>(List<T> x) Function<B extends core.int>(int x) l1955;
+ // The static function f1955 sets `T` to `int`.
+ if (!tIsBool) {
+ x1955 = f1955 as dynamic;
+ l1955 = f1955 as dynamic;
+ x1955 = confuse(f1955);
+ l1955 = confuse(f1955);
+ }
+
+ Expect.isTrue(m1955 is F1955);
+ Expect.isTrue(m1955 is A Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1955) is F1955);
+ // In checked mode, verifies the type.
+ x1955 = m1955;
+ l1955 = m1955;
+ x1955 = confuse(m1955);
+ l1955 = confuse(m1955);
+ if (!tIsBool) {
+ Expect.isTrue(f1955 is F1955<int>);
+ Expect.isFalse(f1955 is F1955<bool>);
+ Expect.isTrue(confuse(f1955) is F1955<int>);
+ Expect.isFalse(confuse(f1955) is F1955<bool>);
+ Expect.equals(tIsDynamic, m1955 is F1955<bool>);
+ Expect.equals(tIsDynamic, confuse(m1955) is F1955<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1955 = (f1955 as dynamic); });
+ Expect.throws(() { x1955 = confuse(f1955); });
+ A Function<A>(List<T> x) Function<B extends core.int>(int x) l1955;
+ Expect.throws(() { l1955 = (f1955 as dynamic); });
+ Expect.throws(() { l1955 = confuse(f1955); });
+ }
+ A Function<A>(List<T> x) Function<B extends core.int>(int x) l1955 = m1955;
+ // In checked mode, verifies the type.
+ x1955 = m1955;
+ x1955 = confuse(m1955);
+ }
+ }
+
+
+}
+
+class C56<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x) x56;
+ List<Function> Function(List<T> x) x156;
+ List<T> Function(int y, {List<Function> x}) x256;
+ List<Function> Function<A>(List<T> x) x356;
+ int Function(int y, [Function x]) Function() x456;
+ int Function(int x1, [core.List<core.int> x2]) Function() x556;
+ Function Function({int x}) Function() x656;
+ Function Function(core.List<core.int> x) Function() x756;
+ List<Function> Function(int x0, [int x]) Function() x856;
+ List<Function> Function([List<Function> x1]) Function() x956;
+ List<Function> Function({List<T> x}) Function() x1056;
+ core.List<core.int> Function(int y, {Function x}) Function() x1156;
+ core.List<core.int> Function(int x0, [List<T> x]) Function() x1256;
+ List<T> Function(Function x0) Function() x1356;
+ List<T> Function(int x, [core.List<core.int> x2]) Function() x1456;
+ Function(int x0, {int x}) Function() x1556;
+ Function([core.List<core.int> x]) Function() x1656;
+ int Function<A>(core.List<core.int> x) Function() x1756;
+ core.List<core.int> Function<A>(List<T> x) Function() x1856;
+ A Function<A>() Function() x1956;
+
+
+ C56({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m56(int x) => null;
+ List<Function> m156(List<T> x) => null;
+ List<T> m256(int y, {List<Function> x}) => null;
+ List<Function> m356<A>(List<T> x) => null;
+ int Function(int y, [Function x]) m456() => null;
+ int Function(int x0, [core.List<core.int> x1]) m556() => null;
+ Function Function({int x}) m656() => null;
+ Function Function(core.List<core.int> x) m756() => null;
+ List<Function> Function(int x0, [int x]) m856() => null;
+ List<Function> Function([List<Function> x0]) m956() => null;
+ List<Function> Function({List<T> x}) m1056() => null;
+ core.List<core.int> Function(int y, {Function x}) m1156() => null;
+ core.List<core.int> Function(int x0, [List<T> x]) m1256() => null;
+ List<T> Function(Function x0) m1356() => null;
+ List<T> Function(int x, [core.List<core.int> x0]) m1456() => null;
+ Function(int x0, {int x}) m1556() => null;
+ Function([core.List<core.int> x]) m1656() => null;
+ int Function<A>(core.List<core.int> x) m1756() => null;
+ core.List<core.int> Function<A>(List<T> x) m1856() => null;
+ A Function<A>() m1956() => null;
+
+
+ runTests() {
+ testF56();
+ testF156();
+ testF256();
+ testF356();
+ testF456();
+ testF556();
+ testF656();
+ testF756();
+ testF856();
+ testF956();
+ testF1056();
+ testF1156();
+ testF1256();
+ testF1356();
+ testF1456();
+ testF1556();
+ testF1656();
+ testF1756();
+ testF1856();
+ testF1956();
+ }
+
+ void testF56() {
+ // Function Function(int x)
+ Expect.isTrue(f56 is F56);
+ Expect.isTrue(confuse(f56) is F56);
+ // In checked mode, verifies the type.
+ Function Function(int x) l56;
+ // The static function f56 sets `T` to `int`.
+ if (!tIsBool) {
+ x56 = f56 as dynamic;
+ l56 = f56 as dynamic;
+ x56 = confuse(f56);
+ l56 = confuse(f56);
+ }
+
+ Expect.isTrue(m56 is F56);
+ Expect.isTrue(m56 is Function Function(int x));
+ Expect.isTrue(confuse(m56) is F56);
+ // In checked mode, verifies the type.
+ x56 = m56;
+ l56 = m56;
+ x56 = confuse(m56);
+ l56 = confuse(m56);
+
+ }
+
+ void testF156() {
+ // List<Function> Function(List<T> x)
+ Expect.isTrue(f156 is F156);
+ Expect.isTrue(confuse(f156) is F156);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x) l156;
+ // The static function f156 sets `T` to `int`.
+ if (!tIsBool) {
+ x156 = f156 as dynamic;
+ l156 = f156 as dynamic;
+ x156 = confuse(f156);
+ l156 = confuse(f156);
+ }
+
+ Expect.isTrue(m156 is F156);
+ Expect.isTrue(m156 is List<Function> Function(List<T> x));
+ Expect.isTrue(confuse(m156) is F156);
+ // In checked mode, verifies the type.
+ x156 = m156;
+ l156 = m156;
+ x156 = confuse(m156);
+ l156 = confuse(m156);
+ if (!tIsBool) {
+ Expect.isTrue(f156 is F156<int>);
+ Expect.isFalse(f156 is F156<bool>);
+ Expect.isTrue(confuse(f156) is F156<int>);
+ Expect.isFalse(confuse(f156) is F156<bool>);
+ Expect.equals(tIsDynamic, m156 is F156<bool>);
+ Expect.equals(tIsDynamic, confuse(m156) is F156<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x156 = (f156 as dynamic); });
+ Expect.throws(() { x156 = confuse(f156); });
+ List<Function> Function(List<T> x) l156;
+ Expect.throws(() { l156 = (f156 as dynamic); });
+ Expect.throws(() { l156 = confuse(f156); });
+ }
+ List<Function> Function(List<T> x) l156 = m156;
+ // In checked mode, verifies the type.
+ x156 = m156;
+ x156 = confuse(m156);
+ }
+ }
+
+ void testF256() {
+ // List<T> Function(int y, {List<Function> x})
+ Expect.isTrue(f256 is F256);
+ Expect.isTrue(confuse(f256) is F256);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<Function> x}) l256;
+ // The static function f256 sets `T` to `int`.
+ if (!tIsBool) {
+ x256 = f256 as dynamic;
+ l256 = f256 as dynamic;
+ x256 = confuse(f256);
+ l256 = confuse(f256);
+ }
+
+ Expect.isTrue(m256 is F256);
+ Expect.isTrue(m256 is List<T> Function(int y, {List<Function> x}));
+ Expect.isTrue(confuse(m256) is F256);
+ // In checked mode, verifies the type.
+ x256 = m256;
+ l256 = m256;
+ x256 = confuse(m256);
+ l256 = confuse(m256);
+ if (!tIsBool) {
+ Expect.isTrue(f256 is F256<int>);
+ Expect.isFalse(f256 is F256<bool>);
+ Expect.isTrue(confuse(f256) is F256<int>);
+ Expect.isFalse(confuse(f256) is F256<bool>);
+ Expect.equals(tIsDynamic, m256 is F256<bool>);
+ Expect.equals(tIsDynamic, confuse(m256) is F256<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x256 = (f256 as dynamic); });
+ Expect.throws(() { x256 = confuse(f256); });
+ List<T> Function(int y, {List<Function> x}) l256;
+ Expect.throws(() { l256 = (f256 as dynamic); });
+ Expect.throws(() { l256 = confuse(f256); });
+ }
+ List<T> Function(int y, {List<Function> x}) l256 = m256;
+ // In checked mode, verifies the type.
+ x256 = m256;
+ x256 = confuse(m256);
+ }
+ }
+
+ void testF356() {
+ // List<Function> Function<A>(List<T> x)
+ Expect.isTrue(f356 is F356);
+ Expect.isTrue(confuse(f356) is F356);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<T> x) l356;
+ // The static function f356 sets `T` to `int`.
+ if (!tIsBool) {
+ x356 = f356 as dynamic;
+ l356 = f356 as dynamic;
+ x356 = confuse(f356);
+ l356 = confuse(f356);
+ }
+
+ Expect.isTrue(m356 is F356);
+ Expect.isTrue(m356 is List<Function> Function<A>(List<T> x));
+ Expect.isTrue(confuse(m356) is F356);
+ // In checked mode, verifies the type.
+ x356 = m356;
+ l356 = m356;
+ x356 = confuse(m356);
+ l356 = confuse(m356);
+ if (!tIsBool) {
+ Expect.isTrue(f356 is F356<int>);
+ Expect.isFalse(f356 is F356<bool>);
+ Expect.isTrue(confuse(f356) is F356<int>);
+ Expect.isFalse(confuse(f356) is F356<bool>);
+ Expect.equals(tIsDynamic, m356 is F356<bool>);
+ Expect.equals(tIsDynamic, confuse(m356) is F356<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x356 = (f356 as dynamic); });
+ Expect.throws(() { x356 = confuse(f356); });
+ List<Function> Function<A>(List<T> x) l356;
+ Expect.throws(() { l356 = (f356 as dynamic); });
+ Expect.throws(() { l356 = confuse(f356); });
+ }
+ List<Function> Function<A>(List<T> x) l356 = m356;
+ // In checked mode, verifies the type.
+ x356 = m356;
+ x356 = confuse(m356);
+ }
+ }
+
+ void testF456() {
+ // int Function(int y, [Function x]) Function()
+ Expect.isTrue(f456 is F456);
+ Expect.isTrue(confuse(f456) is F456);
+ // In checked mode, verifies the type.
+ int Function(int y, [Function x]) Function() l456;
+ // The static function f456 sets `T` to `int`.
+ if (!tIsBool) {
+ x456 = f456 as dynamic;
+ l456 = f456 as dynamic;
+ x456 = confuse(f456);
+ l456 = confuse(f456);
+ }
+
+ Expect.isTrue(m456 is F456);
+ Expect.isTrue(m456 is int Function(int y, [Function x]) Function());
+ Expect.isTrue(confuse(m456) is F456);
+ // In checked mode, verifies the type.
+ x456 = m456;
+ l456 = m456;
+ x456 = confuse(m456);
+ l456 = confuse(m456);
+
+ }
+
+ void testF556() {
+ // int Function(int x1, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f556 is F556);
+ Expect.isTrue(confuse(f556) is F556);
+ // In checked mode, verifies the type.
+ int Function(int x1, [core.List<core.int> x2]) Function() l556;
+ // The static function f556 sets `T` to `int`.
+ if (!tIsBool) {
+ x556 = f556 as dynamic;
+ l556 = f556 as dynamic;
+ x556 = confuse(f556);
+ l556 = confuse(f556);
+ }
+
+ Expect.isTrue(m556 is F556);
+ Expect.isTrue(m556 is int Function(int x1, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m556) is F556);
+ // In checked mode, verifies the type.
+ x556 = m556;
+ l556 = m556;
+ x556 = confuse(m556);
+ l556 = confuse(m556);
+
+ }
+
+ void testF656() {
+ // Function Function({int x}) Function()
+ Expect.isTrue(f656 is F656);
+ Expect.isTrue(confuse(f656) is F656);
+ // In checked mode, verifies the type.
+ Function Function({int x}) Function() l656;
+ // The static function f656 sets `T` to `int`.
+ if (!tIsBool) {
+ x656 = f656 as dynamic;
+ l656 = f656 as dynamic;
+ x656 = confuse(f656);
+ l656 = confuse(f656);
+ }
+
+ Expect.isTrue(m656 is F656);
+ Expect.isTrue(m656 is Function Function({int x}) Function());
+ Expect.isTrue(confuse(m656) is F656);
+ // In checked mode, verifies the type.
+ x656 = m656;
+ l656 = m656;
+ x656 = confuse(m656);
+ l656 = confuse(m656);
+
+ }
+
+ void testF756() {
+ // Function Function(core.List<core.int> x) Function()
+ Expect.isTrue(f756 is F756);
+ Expect.isTrue(confuse(f756) is F756);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x) Function() l756;
+ // The static function f756 sets `T` to `int`.
+ if (!tIsBool) {
+ x756 = f756 as dynamic;
+ l756 = f756 as dynamic;
+ x756 = confuse(f756);
+ l756 = confuse(f756);
+ }
+
+ Expect.isTrue(m756 is F756);
+ Expect.isTrue(m756 is Function Function(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m756) is F756);
+ // In checked mode, verifies the type.
+ x756 = m756;
+ l756 = m756;
+ x756 = confuse(m756);
+ l756 = confuse(m756);
+
+ }
+
+ void testF856() {
+ // List<Function> Function(int x0, [int x]) Function()
+ Expect.isTrue(f856 is F856);
+ Expect.isTrue(confuse(f856) is F856);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [int x]) Function() l856;
+ // The static function f856 sets `T` to `int`.
+ if (!tIsBool) {
+ x856 = f856 as dynamic;
+ l856 = f856 as dynamic;
+ x856 = confuse(f856);
+ l856 = confuse(f856);
+ }
+
+ Expect.isTrue(m856 is F856);
+ Expect.isTrue(m856 is List<Function> Function(int x0, [int x]) Function());
+ Expect.isTrue(confuse(m856) is F856);
+ // In checked mode, verifies the type.
+ x856 = m856;
+ l856 = m856;
+ x856 = confuse(m856);
+ l856 = confuse(m856);
+
+ }
+
+ void testF956() {
+ // List<Function> Function([List<Function> x1]) Function()
+ Expect.isTrue(f956 is F956);
+ Expect.isTrue(confuse(f956) is F956);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x1]) Function() l956;
+ // The static function f956 sets `T` to `int`.
+ if (!tIsBool) {
+ x956 = f956 as dynamic;
+ l956 = f956 as dynamic;
+ x956 = confuse(f956);
+ l956 = confuse(f956);
+ }
+
+ Expect.isTrue(m956 is F956);
+ Expect.isTrue(m956 is List<Function> Function([List<Function> x1]) Function());
+ Expect.isTrue(confuse(m956) is F956);
+ // In checked mode, verifies the type.
+ x956 = m956;
+ l956 = m956;
+ x956 = confuse(m956);
+ l956 = confuse(m956);
+
+ }
+
+ void testF1056() {
+ // List<Function> Function({List<T> x}) Function()
+ Expect.isTrue(f1056 is F1056);
+ Expect.isTrue(confuse(f1056) is F1056);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<T> x}) Function() l1056;
+ // The static function f1056 sets `T` to `int`.
+ if (!tIsBool) {
+ x1056 = f1056 as dynamic;
+ l1056 = f1056 as dynamic;
+ x1056 = confuse(f1056);
+ l1056 = confuse(f1056);
+ }
+
+ Expect.isTrue(m1056 is F1056);
+ Expect.isTrue(m1056 is List<Function> Function({List<T> x}) Function());
+ Expect.isTrue(confuse(m1056) is F1056);
+ // In checked mode, verifies the type.
+ x1056 = m1056;
+ l1056 = m1056;
+ x1056 = confuse(m1056);
+ l1056 = confuse(m1056);
+ if (!tIsBool) {
+ Expect.isTrue(f1056 is F1056<int>);
+ Expect.isFalse(f1056 is F1056<bool>);
+ Expect.isTrue(confuse(f1056) is F1056<int>);
+ Expect.isFalse(confuse(f1056) is F1056<bool>);
+ Expect.equals(tIsDynamic, m1056 is F1056<bool>);
+ Expect.equals(tIsDynamic, confuse(m1056) is F1056<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1056 = (f1056 as dynamic); });
+ Expect.throws(() { x1056 = confuse(f1056); });
+ List<Function> Function({List<T> x}) Function() l1056;
+ Expect.throws(() { l1056 = (f1056 as dynamic); });
+ Expect.throws(() { l1056 = confuse(f1056); });
+ }
+ List<Function> Function({List<T> x}) Function() l1056 = m1056;
+ // In checked mode, verifies the type.
+ x1056 = m1056;
+ x1056 = confuse(m1056);
+ }
+ }
+
+ void testF1156() {
+ // core.List<core.int> Function(int y, {Function x}) Function()
+ Expect.isTrue(f1156 is F1156);
+ Expect.isTrue(confuse(f1156) is F1156);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {Function x}) Function() l1156;
+ // The static function f1156 sets `T` to `int`.
+ if (!tIsBool) {
+ x1156 = f1156 as dynamic;
+ l1156 = f1156 as dynamic;
+ x1156 = confuse(f1156);
+ l1156 = confuse(f1156);
+ }
+
+ Expect.isTrue(m1156 is F1156);
+ Expect.isTrue(m1156 is core.List<core.int> Function(int y, {Function x}) Function());
+ Expect.isTrue(confuse(m1156) is F1156);
+ // In checked mode, verifies the type.
+ x1156 = m1156;
+ l1156 = m1156;
+ x1156 = confuse(m1156);
+ l1156 = confuse(m1156);
+
+ }
+
+ void testF1256() {
+ // core.List<core.int> Function(int x0, [List<T> x]) Function()
+ Expect.isTrue(f1256 is F1256);
+ Expect.isTrue(confuse(f1256) is F1256);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [List<T> x]) Function() l1256;
+ // The static function f1256 sets `T` to `int`.
+ if (!tIsBool) {
+ x1256 = f1256 as dynamic;
+ l1256 = f1256 as dynamic;
+ x1256 = confuse(f1256);
+ l1256 = confuse(f1256);
+ }
+
+ Expect.isTrue(m1256 is F1256);
+ Expect.isTrue(m1256 is core.List<core.int> Function(int x0, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1256) is F1256);
+ // In checked mode, verifies the type.
+ x1256 = m1256;
+ l1256 = m1256;
+ x1256 = confuse(m1256);
+ l1256 = confuse(m1256);
+ if (!tIsBool) {
+ Expect.isTrue(f1256 is F1256<int>);
+ Expect.isFalse(f1256 is F1256<bool>);
+ Expect.isTrue(confuse(f1256) is F1256<int>);
+ Expect.isFalse(confuse(f1256) is F1256<bool>);
+ Expect.equals(tIsDynamic, m1256 is F1256<bool>);
+ Expect.equals(tIsDynamic, confuse(m1256) is F1256<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1256 = (f1256 as dynamic); });
+ Expect.throws(() { x1256 = confuse(f1256); });
+ core.List<core.int> Function(int x0, [List<T> x]) Function() l1256;
+ Expect.throws(() { l1256 = (f1256 as dynamic); });
+ Expect.throws(() { l1256 = confuse(f1256); });
+ }
+ core.List<core.int> Function(int x0, [List<T> x]) Function() l1256 = m1256;
+ // In checked mode, verifies the type.
+ x1256 = m1256;
+ x1256 = confuse(m1256);
+ }
+ }
+
+ void testF1356() {
+ // List<T> Function(Function x0) Function()
+ Expect.isTrue(f1356 is F1356);
+ Expect.isTrue(confuse(f1356) is F1356);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x0) Function() l1356;
+ // The static function f1356 sets `T` to `int`.
+ if (!tIsBool) {
+ x1356 = f1356 as dynamic;
+ l1356 = f1356 as dynamic;
+ x1356 = confuse(f1356);
+ l1356 = confuse(f1356);
+ }
+
+ Expect.isTrue(m1356 is F1356);
+ Expect.isTrue(m1356 is List<T> Function(Function x0) Function());
+ Expect.isTrue(confuse(m1356) is F1356);
+ // In checked mode, verifies the type.
+ x1356 = m1356;
+ l1356 = m1356;
+ x1356 = confuse(m1356);
+ l1356 = confuse(m1356);
+ if (!tIsBool) {
+ Expect.isTrue(f1356 is F1356<int>);
+ Expect.isFalse(f1356 is F1356<bool>);
+ Expect.isTrue(confuse(f1356) is F1356<int>);
+ Expect.isFalse(confuse(f1356) is F1356<bool>);
+ Expect.equals(tIsDynamic, m1356 is F1356<bool>);
+ Expect.equals(tIsDynamic, confuse(m1356) is F1356<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1356 = (f1356 as dynamic); });
+ Expect.throws(() { x1356 = confuse(f1356); });
+ List<T> Function(Function x0) Function() l1356;
+ Expect.throws(() { l1356 = (f1356 as dynamic); });
+ Expect.throws(() { l1356 = confuse(f1356); });
+ }
+ List<T> Function(Function x0) Function() l1356 = m1356;
+ // In checked mode, verifies the type.
+ x1356 = m1356;
+ x1356 = confuse(m1356);
+ }
+ }
+
+ void testF1456() {
+ // List<T> Function(int x, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1456 is F1456);
+ Expect.isTrue(confuse(f1456) is F1456);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [core.List<core.int> x2]) Function() l1456;
+ // The static function f1456 sets `T` to `int`.
+ if (!tIsBool) {
+ x1456 = f1456 as dynamic;
+ l1456 = f1456 as dynamic;
+ x1456 = confuse(f1456);
+ l1456 = confuse(f1456);
+ }
+
+ Expect.isTrue(m1456 is F1456);
+ Expect.isTrue(m1456 is List<T> Function(int x, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1456) is F1456);
+ // In checked mode, verifies the type.
+ x1456 = m1456;
+ l1456 = m1456;
+ x1456 = confuse(m1456);
+ l1456 = confuse(m1456);
+ if (!tIsBool) {
+ Expect.isTrue(f1456 is F1456<int>);
+ Expect.isFalse(f1456 is F1456<bool>);
+ Expect.isTrue(confuse(f1456) is F1456<int>);
+ Expect.isFalse(confuse(f1456) is F1456<bool>);
+ Expect.equals(tIsDynamic, m1456 is F1456<bool>);
+ Expect.equals(tIsDynamic, confuse(m1456) is F1456<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1456 = (f1456 as dynamic); });
+ Expect.throws(() { x1456 = confuse(f1456); });
+ List<T> Function(int x, [core.List<core.int> x2]) Function() l1456;
+ Expect.throws(() { l1456 = (f1456 as dynamic); });
+ Expect.throws(() { l1456 = confuse(f1456); });
+ }
+ List<T> Function(int x, [core.List<core.int> x2]) Function() l1456 = m1456;
+ // In checked mode, verifies the type.
+ x1456 = m1456;
+ x1456 = confuse(m1456);
+ }
+ }
+
+ void testF1556() {
+ // Function(int x0, {int x}) Function()
+ Expect.isTrue(f1556 is F1556);
+ Expect.isTrue(confuse(f1556) is F1556);
+ // In checked mode, verifies the type.
+ Function(int x0, {int x}) Function() l1556;
+ // The static function f1556 sets `T` to `int`.
+ if (!tIsBool) {
+ x1556 = f1556 as dynamic;
+ l1556 = f1556 as dynamic;
+ x1556 = confuse(f1556);
+ l1556 = confuse(f1556);
+ }
+
+ Expect.isTrue(m1556 is F1556);
+ Expect.isTrue(m1556 is Function(int x0, {int x}) Function());
+ Expect.isTrue(confuse(m1556) is F1556);
+ // In checked mode, verifies the type.
+ x1556 = m1556;
+ l1556 = m1556;
+ x1556 = confuse(m1556);
+ l1556 = confuse(m1556);
+
+ }
+
+ void testF1656() {
+ // Function([core.List<core.int> x]) Function()
+ Expect.isTrue(f1656 is F1656);
+ Expect.isTrue(confuse(f1656) is F1656);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x]) Function() l1656;
+ // The static function f1656 sets `T` to `int`.
+ if (!tIsBool) {
+ x1656 = f1656 as dynamic;
+ l1656 = f1656 as dynamic;
+ x1656 = confuse(f1656);
+ l1656 = confuse(f1656);
+ }
+
+ Expect.isTrue(m1656 is F1656);
+ Expect.isTrue(m1656 is Function([core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1656) is F1656);
+ // In checked mode, verifies the type.
+ x1656 = m1656;
+ l1656 = m1656;
+ x1656 = confuse(m1656);
+ l1656 = confuse(m1656);
+
+ }
+
+ void testF1756() {
+ // int Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1756 is F1756);
+ Expect.isTrue(confuse(f1756) is F1756);
+ // In checked mode, verifies the type.
+ int Function<A>(core.List<core.int> x) Function() l1756;
+ // The static function f1756 sets `T` to `int`.
+ if (!tIsBool) {
+ x1756 = f1756 as dynamic;
+ l1756 = f1756 as dynamic;
+ x1756 = confuse(f1756);
+ l1756 = confuse(f1756);
+ }
+
+ Expect.isTrue(m1756 is F1756);
+ Expect.isTrue(m1756 is int Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1756) is F1756);
+ // In checked mode, verifies the type.
+ x1756 = m1756;
+ l1756 = m1756;
+ x1756 = confuse(m1756);
+ l1756 = confuse(m1756);
+
+ }
+
+ void testF1856() {
+ // core.List<core.int> Function<A>(List<T> x) Function()
+ Expect.isTrue(f1856 is F1856);
+ Expect.isTrue(confuse(f1856) is F1856);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<T> x) Function() l1856;
+ // The static function f1856 sets `T` to `int`.
+ if (!tIsBool) {
+ x1856 = f1856 as dynamic;
+ l1856 = f1856 as dynamic;
+ x1856 = confuse(f1856);
+ l1856 = confuse(f1856);
+ }
+
+ Expect.isTrue(m1856 is F1856);
+ Expect.isTrue(m1856 is core.List<core.int> Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1856) is F1856);
+ // In checked mode, verifies the type.
+ x1856 = m1856;
+ l1856 = m1856;
+ x1856 = confuse(m1856);
+ l1856 = confuse(m1856);
+ if (!tIsBool) {
+ Expect.isTrue(f1856 is F1856<int>);
+ Expect.isFalse(f1856 is F1856<bool>);
+ Expect.isTrue(confuse(f1856) is F1856<int>);
+ Expect.isFalse(confuse(f1856) is F1856<bool>);
+ Expect.equals(tIsDynamic, m1856 is F1856<bool>);
+ Expect.equals(tIsDynamic, confuse(m1856) is F1856<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1856 = (f1856 as dynamic); });
+ Expect.throws(() { x1856 = confuse(f1856); });
+ core.List<core.int> Function<A>(List<T> x) Function() l1856;
+ Expect.throws(() { l1856 = (f1856 as dynamic); });
+ Expect.throws(() { l1856 = confuse(f1856); });
+ }
+ core.List<core.int> Function<A>(List<T> x) Function() l1856 = m1856;
+ // In checked mode, verifies the type.
+ x1856 = m1856;
+ x1856 = confuse(m1856);
+ }
+ }
+
+ void testF1956() {
+ // A Function<A>() Function()
+ Expect.isTrue(f1956 is F1956);
+ Expect.isTrue(confuse(f1956) is F1956);
+ // In checked mode, verifies the type.
+ A Function<A>() Function() l1956;
+ // The static function f1956 sets `T` to `int`.
+ if (!tIsBool) {
+ x1956 = f1956 as dynamic;
+ l1956 = f1956 as dynamic;
+ x1956 = confuse(f1956);
+ l1956 = confuse(f1956);
+ }
+
+ Expect.isTrue(m1956 is F1956);
+ Expect.isTrue(m1956 is A Function<A>() Function());
+ Expect.isTrue(confuse(m1956) is F1956);
+ // In checked mode, verifies the type.
+ x1956 = m1956;
+ l1956 = m1956;
+ x1956 = confuse(m1956);
+ l1956 = confuse(m1956);
+
+ }
+
+
+}
+
+class C57<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([int x]) x57;
+ List<Function> Function([List<T> x]) x157;
+ List<T> Function(core.List<core.int> x) x257;
+ List<Function> Function<A>() x357;
+ int Function(int y, [Function x]) Function(int x) x457;
+ int Function(int x2, [core.List<core.int> x3]) Function(int x) x557;
+ Function Function({int x}) Function(int x) x657;
+ Function Function(core.List<core.int> x) Function(int x) x757;
+ List<Function> Function(int x1, [int x]) Function(int x) x857;
+ List<Function> Function([List<Function> x1]) Function(int x) x957;
+ List<Function> Function({List<T> x}) Function(int x) x1057;
+ core.List<core.int> Function(int y, {Function x}) Function(int x) x1157;
+ core.List<core.int> Function(int x1, [List<T> x]) Function(int x) x1257;
+ List<T> Function(Function x1) Function(int x) x1357;
+ List<T> Function(int x, [core.List<core.int> x1]) Function(int x) x1457;
+ Function(int x1, {int x}) Function(int x) x1557;
+ Function([core.List<core.int> x]) Function(int x) x1657;
+ int Function<A>(core.List<core.int> x) Function(int x) x1757;
+ core.List<core.int> Function<A>(List<T> x) Function(int x) x1857;
+ A Function<A>() Function(int x) x1957;
+
+
+ C57({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m57([int x]) => null;
+ List<Function> m157([List<T> x]) => null;
+ List<T> m257(core.List<core.int> x) => null;
+ List<Function> m357<A>() => null;
+ int Function(int y, [Function x]) m457(int x) => null;
+ int Function(int x0, [core.List<core.int> x1]) m557(int x) => null;
+ Function Function({int x}) m657(int x) => null;
+ Function Function(core.List<core.int> x) m757(int x) => null;
+ List<Function> Function(int x0, [int x]) m857(int x) => null;
+ List<Function> Function([List<Function> x0]) m957(int x) => null;
+ List<Function> Function({List<T> x}) m1057(int x) => null;
+ core.List<core.int> Function(int y, {Function x}) m1157(int x) => null;
+ core.List<core.int> Function(int x0, [List<T> x]) m1257(int x) => null;
+ List<T> Function(Function x0) m1357(int x) => null;
+ List<T> Function(int x, [core.List<core.int> x0]) m1457(int x) => null;
+ Function(int x0, {int x}) m1557(int x) => null;
+ Function([core.List<core.int> x]) m1657(int x) => null;
+ int Function<A>(core.List<core.int> x) m1757(int x) => null;
+ core.List<core.int> Function<A>(List<T> x) m1857(int x) => null;
+ A Function<A>() m1957(int x) => null;
+
+
+ runTests() {
+ testF57();
+ testF157();
+ testF257();
+ testF357();
+ testF457();
+ testF557();
+ testF657();
+ testF757();
+ testF857();
+ testF957();
+ testF1057();
+ testF1157();
+ testF1257();
+ testF1357();
+ testF1457();
+ testF1557();
+ testF1657();
+ testF1757();
+ testF1857();
+ testF1957();
+ }
+
+ void testF57() {
+ // Function Function([int x])
+ Expect.isTrue(f57 is F57);
+ Expect.isTrue(confuse(f57) is F57);
+ // In checked mode, verifies the type.
+ Function Function([int x]) l57;
+ // The static function f57 sets `T` to `int`.
+ if (!tIsBool) {
+ x57 = f57 as dynamic;
+ l57 = f57 as dynamic;
+ x57 = confuse(f57);
+ l57 = confuse(f57);
+ }
+
+ Expect.isTrue(m57 is F57);
+ Expect.isTrue(m57 is Function Function([int x]));
+ Expect.isTrue(confuse(m57) is F57);
+ // In checked mode, verifies the type.
+ x57 = m57;
+ l57 = m57;
+ x57 = confuse(m57);
+ l57 = confuse(m57);
+
+ }
+
+ void testF157() {
+ // List<Function> Function([List<T> x])
+ Expect.isTrue(f157 is F157);
+ Expect.isTrue(confuse(f157) is F157);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x]) l157;
+ // The static function f157 sets `T` to `int`.
+ if (!tIsBool) {
+ x157 = f157 as dynamic;
+ l157 = f157 as dynamic;
+ x157 = confuse(f157);
+ l157 = confuse(f157);
+ }
+
+ Expect.isTrue(m157 is F157);
+ Expect.isTrue(m157 is List<Function> Function([List<T> x]));
+ Expect.isTrue(confuse(m157) is F157);
+ // In checked mode, verifies the type.
+ x157 = m157;
+ l157 = m157;
+ x157 = confuse(m157);
+ l157 = confuse(m157);
+ if (!tIsBool) {
+ Expect.isTrue(f157 is F157<int>);
+ Expect.isFalse(f157 is F157<bool>);
+ Expect.isTrue(confuse(f157) is F157<int>);
+ Expect.isFalse(confuse(f157) is F157<bool>);
+ Expect.equals(tIsDynamic, m157 is F157<bool>);
+ Expect.equals(tIsDynamic, confuse(m157) is F157<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x157 = (f157 as dynamic); });
+ Expect.throws(() { x157 = confuse(f157); });
+ List<Function> Function([List<T> x]) l157;
+ Expect.throws(() { l157 = (f157 as dynamic); });
+ Expect.throws(() { l157 = confuse(f157); });
+ }
+ List<Function> Function([List<T> x]) l157 = m157;
+ // In checked mode, verifies the type.
+ x157 = m157;
+ x157 = confuse(m157);
+ }
+ }
+
+ void testF257() {
+ // List<T> Function(core.List<core.int> x)
+ Expect.isTrue(f257 is F257);
+ Expect.isTrue(confuse(f257) is F257);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x) l257;
+ // The static function f257 sets `T` to `int`.
+ if (!tIsBool) {
+ x257 = f257 as dynamic;
+ l257 = f257 as dynamic;
+ x257 = confuse(f257);
+ l257 = confuse(f257);
+ }
+
+ Expect.isTrue(m257 is F257);
+ Expect.isTrue(m257 is List<T> Function(core.List<core.int> x));
+ Expect.isTrue(confuse(m257) is F257);
+ // In checked mode, verifies the type.
+ x257 = m257;
+ l257 = m257;
+ x257 = confuse(m257);
+ l257 = confuse(m257);
+ if (!tIsBool) {
+ Expect.isTrue(f257 is F257<int>);
+ Expect.isFalse(f257 is F257<bool>);
+ Expect.isTrue(confuse(f257) is F257<int>);
+ Expect.isFalse(confuse(f257) is F257<bool>);
+ Expect.equals(tIsDynamic, m257 is F257<bool>);
+ Expect.equals(tIsDynamic, confuse(m257) is F257<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x257 = (f257 as dynamic); });
+ Expect.throws(() { x257 = confuse(f257); });
+ List<T> Function(core.List<core.int> x) l257;
+ Expect.throws(() { l257 = (f257 as dynamic); });
+ Expect.throws(() { l257 = confuse(f257); });
+ }
+ List<T> Function(core.List<core.int> x) l257 = m257;
+ // In checked mode, verifies the type.
+ x257 = m257;
+ x257 = confuse(m257);
+ }
+ }
+
+ void testF357() {
+ // List<Function> Function<A>()
+ Expect.isTrue(f357 is F357);
+ Expect.isTrue(confuse(f357) is F357);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>() l357;
+ // The static function f357 sets `T` to `int`.
+ if (!tIsBool) {
+ x357 = f357 as dynamic;
+ l357 = f357 as dynamic;
+ x357 = confuse(f357);
+ l357 = confuse(f357);
+ }
+
+ Expect.isTrue(m357 is F357);
+ Expect.isTrue(m357 is List<Function> Function<A>());
+ Expect.isTrue(confuse(m357) is F357);
+ // In checked mode, verifies the type.
+ x357 = m357;
+ l357 = m357;
+ x357 = confuse(m357);
+ l357 = confuse(m357);
+
+ }
+
+ void testF457() {
+ // int Function(int y, [Function x]) Function(int x)
+ Expect.isTrue(f457 is F457);
+ Expect.isTrue(confuse(f457) is F457);
+ // In checked mode, verifies the type.
+ int Function(int y, [Function x]) Function(int x) l457;
+ // The static function f457 sets `T` to `int`.
+ if (!tIsBool) {
+ x457 = f457 as dynamic;
+ l457 = f457 as dynamic;
+ x457 = confuse(f457);
+ l457 = confuse(f457);
+ }
+
+ Expect.isTrue(m457 is F457);
+ Expect.isTrue(m457 is int Function(int y, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m457) is F457);
+ // In checked mode, verifies the type.
+ x457 = m457;
+ l457 = m457;
+ x457 = confuse(m457);
+ l457 = confuse(m457);
+
+ }
+
+ void testF557() {
+ // int Function(int x2, [core.List<core.int> x3]) Function(int x)
+ Expect.isTrue(f557 is F557);
+ Expect.isTrue(confuse(f557) is F557);
+ // In checked mode, verifies the type.
+ int Function(int x2, [core.List<core.int> x3]) Function(int x) l557;
+ // The static function f557 sets `T` to `int`.
+ if (!tIsBool) {
+ x557 = f557 as dynamic;
+ l557 = f557 as dynamic;
+ x557 = confuse(f557);
+ l557 = confuse(f557);
+ }
+
+ Expect.isTrue(m557 is F557);
+ Expect.isTrue(m557 is int Function(int x2, [core.List<core.int> x3]) Function(int x));
+ Expect.isTrue(confuse(m557) is F557);
+ // In checked mode, verifies the type.
+ x557 = m557;
+ l557 = m557;
+ x557 = confuse(m557);
+ l557 = confuse(m557);
+
+ }
+
+ void testF657() {
+ // Function Function({int x}) Function(int x)
+ Expect.isTrue(f657 is F657);
+ Expect.isTrue(confuse(f657) is F657);
+ // In checked mode, verifies the type.
+ Function Function({int x}) Function(int x) l657;
+ // The static function f657 sets `T` to `int`.
+ if (!tIsBool) {
+ x657 = f657 as dynamic;
+ l657 = f657 as dynamic;
+ x657 = confuse(f657);
+ l657 = confuse(f657);
+ }
+
+ Expect.isTrue(m657 is F657);
+ Expect.isTrue(m657 is Function Function({int x}) Function(int x));
+ Expect.isTrue(confuse(m657) is F657);
+ // In checked mode, verifies the type.
+ x657 = m657;
+ l657 = m657;
+ x657 = confuse(m657);
+ l657 = confuse(m657);
+
+ }
+
+ void testF757() {
+ // Function Function(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f757 is F757);
+ Expect.isTrue(confuse(f757) is F757);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x) Function(int x) l757;
+ // The static function f757 sets `T` to `int`.
+ if (!tIsBool) {
+ x757 = f757 as dynamic;
+ l757 = f757 as dynamic;
+ x757 = confuse(f757);
+ l757 = confuse(f757);
+ }
+
+ Expect.isTrue(m757 is F757);
+ Expect.isTrue(m757 is Function Function(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m757) is F757);
+ // In checked mode, verifies the type.
+ x757 = m757;
+ l757 = m757;
+ x757 = confuse(m757);
+ l757 = confuse(m757);
+
+ }
+
+ void testF857() {
+ // List<Function> Function(int x1, [int x]) Function(int x)
+ Expect.isTrue(f857 is F857);
+ Expect.isTrue(confuse(f857) is F857);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [int x]) Function(int x) l857;
+ // The static function f857 sets `T` to `int`.
+ if (!tIsBool) {
+ x857 = f857 as dynamic;
+ l857 = f857 as dynamic;
+ x857 = confuse(f857);
+ l857 = confuse(f857);
+ }
+
+ Expect.isTrue(m857 is F857);
+ Expect.isTrue(m857 is List<Function> Function(int x1, [int x]) Function(int x));
+ Expect.isTrue(confuse(m857) is F857);
+ // In checked mode, verifies the type.
+ x857 = m857;
+ l857 = m857;
+ x857 = confuse(m857);
+ l857 = confuse(m857);
+
+ }
+
+ void testF957() {
+ // List<Function> Function([List<Function> x1]) Function(int x)
+ Expect.isTrue(f957 is F957);
+ Expect.isTrue(confuse(f957) is F957);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x1]) Function(int x) l957;
+ // The static function f957 sets `T` to `int`.
+ if (!tIsBool) {
+ x957 = f957 as dynamic;
+ l957 = f957 as dynamic;
+ x957 = confuse(f957);
+ l957 = confuse(f957);
+ }
+
+ Expect.isTrue(m957 is F957);
+ Expect.isTrue(m957 is List<Function> Function([List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m957) is F957);
+ // In checked mode, verifies the type.
+ x957 = m957;
+ l957 = m957;
+ x957 = confuse(m957);
+ l957 = confuse(m957);
+
+ }
+
+ void testF1057() {
+ // List<Function> Function({List<T> x}) Function(int x)
+ Expect.isTrue(f1057 is F1057);
+ Expect.isTrue(confuse(f1057) is F1057);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<T> x}) Function(int x) l1057;
+ // The static function f1057 sets `T` to `int`.
+ if (!tIsBool) {
+ x1057 = f1057 as dynamic;
+ l1057 = f1057 as dynamic;
+ x1057 = confuse(f1057);
+ l1057 = confuse(f1057);
+ }
+
+ Expect.isTrue(m1057 is F1057);
+ Expect.isTrue(m1057 is List<Function> Function({List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1057) is F1057);
+ // In checked mode, verifies the type.
+ x1057 = m1057;
+ l1057 = m1057;
+ x1057 = confuse(m1057);
+ l1057 = confuse(m1057);
+ if (!tIsBool) {
+ Expect.isTrue(f1057 is F1057<int>);
+ Expect.isFalse(f1057 is F1057<bool>);
+ Expect.isTrue(confuse(f1057) is F1057<int>);
+ Expect.isFalse(confuse(f1057) is F1057<bool>);
+ Expect.equals(tIsDynamic, m1057 is F1057<bool>);
+ Expect.equals(tIsDynamic, confuse(m1057) is F1057<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1057 = (f1057 as dynamic); });
+ Expect.throws(() { x1057 = confuse(f1057); });
+ List<Function> Function({List<T> x}) Function(int x) l1057;
+ Expect.throws(() { l1057 = (f1057 as dynamic); });
+ Expect.throws(() { l1057 = confuse(f1057); });
+ }
+ List<Function> Function({List<T> x}) Function(int x) l1057 = m1057;
+ // In checked mode, verifies the type.
+ x1057 = m1057;
+ x1057 = confuse(m1057);
+ }
+ }
+
+ void testF1157() {
+ // core.List<core.int> Function(int y, {Function x}) Function(int x)
+ Expect.isTrue(f1157 is F1157);
+ Expect.isTrue(confuse(f1157) is F1157);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {Function x}) Function(int x) l1157;
+ // The static function f1157 sets `T` to `int`.
+ if (!tIsBool) {
+ x1157 = f1157 as dynamic;
+ l1157 = f1157 as dynamic;
+ x1157 = confuse(f1157);
+ l1157 = confuse(f1157);
+ }
+
+ Expect.isTrue(m1157 is F1157);
+ Expect.isTrue(m1157 is core.List<core.int> Function(int y, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m1157) is F1157);
+ // In checked mode, verifies the type.
+ x1157 = m1157;
+ l1157 = m1157;
+ x1157 = confuse(m1157);
+ l1157 = confuse(m1157);
+
+ }
+
+ void testF1257() {
+ // core.List<core.int> Function(int x1, [List<T> x]) Function(int x)
+ Expect.isTrue(f1257 is F1257);
+ Expect.isTrue(confuse(f1257) is F1257);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<T> x]) Function(int x) l1257;
+ // The static function f1257 sets `T` to `int`.
+ if (!tIsBool) {
+ x1257 = f1257 as dynamic;
+ l1257 = f1257 as dynamic;
+ x1257 = confuse(f1257);
+ l1257 = confuse(f1257);
+ }
+
+ Expect.isTrue(m1257 is F1257);
+ Expect.isTrue(m1257 is core.List<core.int> Function(int x1, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1257) is F1257);
+ // In checked mode, verifies the type.
+ x1257 = m1257;
+ l1257 = m1257;
+ x1257 = confuse(m1257);
+ l1257 = confuse(m1257);
+ if (!tIsBool) {
+ Expect.isTrue(f1257 is F1257<int>);
+ Expect.isFalse(f1257 is F1257<bool>);
+ Expect.isTrue(confuse(f1257) is F1257<int>);
+ Expect.isFalse(confuse(f1257) is F1257<bool>);
+ Expect.equals(tIsDynamic, m1257 is F1257<bool>);
+ Expect.equals(tIsDynamic, confuse(m1257) is F1257<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1257 = (f1257 as dynamic); });
+ Expect.throws(() { x1257 = confuse(f1257); });
+ core.List<core.int> Function(int x1, [List<T> x]) Function(int x) l1257;
+ Expect.throws(() { l1257 = (f1257 as dynamic); });
+ Expect.throws(() { l1257 = confuse(f1257); });
+ }
+ core.List<core.int> Function(int x1, [List<T> x]) Function(int x) l1257 = m1257;
+ // In checked mode, verifies the type.
+ x1257 = m1257;
+ x1257 = confuse(m1257);
+ }
+ }
+
+ void testF1357() {
+ // List<T> Function(Function x1) Function(int x)
+ Expect.isTrue(f1357 is F1357);
+ Expect.isTrue(confuse(f1357) is F1357);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x1) Function(int x) l1357;
+ // The static function f1357 sets `T` to `int`.
+ if (!tIsBool) {
+ x1357 = f1357 as dynamic;
+ l1357 = f1357 as dynamic;
+ x1357 = confuse(f1357);
+ l1357 = confuse(f1357);
+ }
+
+ Expect.isTrue(m1357 is F1357);
+ Expect.isTrue(m1357 is List<T> Function(Function x1) Function(int x));
+ Expect.isTrue(confuse(m1357) is F1357);
+ // In checked mode, verifies the type.
+ x1357 = m1357;
+ l1357 = m1357;
+ x1357 = confuse(m1357);
+ l1357 = confuse(m1357);
+ if (!tIsBool) {
+ Expect.isTrue(f1357 is F1357<int>);
+ Expect.isFalse(f1357 is F1357<bool>);
+ Expect.isTrue(confuse(f1357) is F1357<int>);
+ Expect.isFalse(confuse(f1357) is F1357<bool>);
+ Expect.equals(tIsDynamic, m1357 is F1357<bool>);
+ Expect.equals(tIsDynamic, confuse(m1357) is F1357<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1357 = (f1357 as dynamic); });
+ Expect.throws(() { x1357 = confuse(f1357); });
+ List<T> Function(Function x1) Function(int x) l1357;
+ Expect.throws(() { l1357 = (f1357 as dynamic); });
+ Expect.throws(() { l1357 = confuse(f1357); });
+ }
+ List<T> Function(Function x1) Function(int x) l1357 = m1357;
+ // In checked mode, verifies the type.
+ x1357 = m1357;
+ x1357 = confuse(m1357);
+ }
+ }
+
+ void testF1457() {
+ // List<T> Function(int x, [core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1457 is F1457);
+ Expect.isTrue(confuse(f1457) is F1457);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [core.List<core.int> x1]) Function(int x) l1457;
+ // The static function f1457 sets `T` to `int`.
+ if (!tIsBool) {
+ x1457 = f1457 as dynamic;
+ l1457 = f1457 as dynamic;
+ x1457 = confuse(f1457);
+ l1457 = confuse(f1457);
+ }
+
+ Expect.isTrue(m1457 is F1457);
+ Expect.isTrue(m1457 is List<T> Function(int x, [core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1457) is F1457);
+ // In checked mode, verifies the type.
+ x1457 = m1457;
+ l1457 = m1457;
+ x1457 = confuse(m1457);
+ l1457 = confuse(m1457);
+ if (!tIsBool) {
+ Expect.isTrue(f1457 is F1457<int>);
+ Expect.isFalse(f1457 is F1457<bool>);
+ Expect.isTrue(confuse(f1457) is F1457<int>);
+ Expect.isFalse(confuse(f1457) is F1457<bool>);
+ Expect.equals(tIsDynamic, m1457 is F1457<bool>);
+ Expect.equals(tIsDynamic, confuse(m1457) is F1457<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1457 = (f1457 as dynamic); });
+ Expect.throws(() { x1457 = confuse(f1457); });
+ List<T> Function(int x, [core.List<core.int> x1]) Function(int x) l1457;
+ Expect.throws(() { l1457 = (f1457 as dynamic); });
+ Expect.throws(() { l1457 = confuse(f1457); });
+ }
+ List<T> Function(int x, [core.List<core.int> x1]) Function(int x) l1457 = m1457;
+ // In checked mode, verifies the type.
+ x1457 = m1457;
+ x1457 = confuse(m1457);
+ }
+ }
+
+ void testF1557() {
+ // Function(int x1, {int x}) Function(int x)
+ Expect.isTrue(f1557 is F1557);
+ Expect.isTrue(confuse(f1557) is F1557);
+ // In checked mode, verifies the type.
+ Function(int x1, {int x}) Function(int x) l1557;
+ // The static function f1557 sets `T` to `int`.
+ if (!tIsBool) {
+ x1557 = f1557 as dynamic;
+ l1557 = f1557 as dynamic;
+ x1557 = confuse(f1557);
+ l1557 = confuse(f1557);
+ }
+
+ Expect.isTrue(m1557 is F1557);
+ Expect.isTrue(m1557 is Function(int x1, {int x}) Function(int x));
+ Expect.isTrue(confuse(m1557) is F1557);
+ // In checked mode, verifies the type.
+ x1557 = m1557;
+ l1557 = m1557;
+ x1557 = confuse(m1557);
+ l1557 = confuse(m1557);
+
+ }
+
+ void testF1657() {
+ // Function([core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1657 is F1657);
+ Expect.isTrue(confuse(f1657) is F1657);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x]) Function(int x) l1657;
+ // The static function f1657 sets `T` to `int`.
+ if (!tIsBool) {
+ x1657 = f1657 as dynamic;
+ l1657 = f1657 as dynamic;
+ x1657 = confuse(f1657);
+ l1657 = confuse(f1657);
+ }
+
+ Expect.isTrue(m1657 is F1657);
+ Expect.isTrue(m1657 is Function([core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1657) is F1657);
+ // In checked mode, verifies the type.
+ x1657 = m1657;
+ l1657 = m1657;
+ x1657 = confuse(m1657);
+ l1657 = confuse(m1657);
+
+ }
+
+ void testF1757() {
+ // int Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1757 is F1757);
+ Expect.isTrue(confuse(f1757) is F1757);
+ // In checked mode, verifies the type.
+ int Function<A>(core.List<core.int> x) Function(int x) l1757;
+ // The static function f1757 sets `T` to `int`.
+ if (!tIsBool) {
+ x1757 = f1757 as dynamic;
+ l1757 = f1757 as dynamic;
+ x1757 = confuse(f1757);
+ l1757 = confuse(f1757);
+ }
+
+ Expect.isTrue(m1757 is F1757);
+ Expect.isTrue(m1757 is int Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1757) is F1757);
+ // In checked mode, verifies the type.
+ x1757 = m1757;
+ l1757 = m1757;
+ x1757 = confuse(m1757);
+ l1757 = confuse(m1757);
+
+ }
+
+ void testF1857() {
+ // core.List<core.int> Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1857 is F1857);
+ Expect.isTrue(confuse(f1857) is F1857);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<T> x) Function(int x) l1857;
+ // The static function f1857 sets `T` to `int`.
+ if (!tIsBool) {
+ x1857 = f1857 as dynamic;
+ l1857 = f1857 as dynamic;
+ x1857 = confuse(f1857);
+ l1857 = confuse(f1857);
+ }
+
+ Expect.isTrue(m1857 is F1857);
+ Expect.isTrue(m1857 is core.List<core.int> Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1857) is F1857);
+ // In checked mode, verifies the type.
+ x1857 = m1857;
+ l1857 = m1857;
+ x1857 = confuse(m1857);
+ l1857 = confuse(m1857);
+ if (!tIsBool) {
+ Expect.isTrue(f1857 is F1857<int>);
+ Expect.isFalse(f1857 is F1857<bool>);
+ Expect.isTrue(confuse(f1857) is F1857<int>);
+ Expect.isFalse(confuse(f1857) is F1857<bool>);
+ Expect.equals(tIsDynamic, m1857 is F1857<bool>);
+ Expect.equals(tIsDynamic, confuse(m1857) is F1857<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1857 = (f1857 as dynamic); });
+ Expect.throws(() { x1857 = confuse(f1857); });
+ core.List<core.int> Function<A>(List<T> x) Function(int x) l1857;
+ Expect.throws(() { l1857 = (f1857 as dynamic); });
+ Expect.throws(() { l1857 = confuse(f1857); });
+ }
+ core.List<core.int> Function<A>(List<T> x) Function(int x) l1857 = m1857;
+ // In checked mode, verifies the type.
+ x1857 = m1857;
+ x1857 = confuse(m1857);
+ }
+ }
+
+ void testF1957() {
+ // A Function<A>() Function(int x)
+ Expect.isTrue(f1957 is F1957);
+ Expect.isTrue(confuse(f1957) is F1957);
+ // In checked mode, verifies the type.
+ A Function<A>() Function(int x) l1957;
+ // The static function f1957 sets `T` to `int`.
+ if (!tIsBool) {
+ x1957 = f1957 as dynamic;
+ l1957 = f1957 as dynamic;
+ x1957 = confuse(f1957);
+ l1957 = confuse(f1957);
+ }
+
+ Expect.isTrue(m1957 is F1957);
+ Expect.isTrue(m1957 is A Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1957) is F1957);
+ // In checked mode, verifies the type.
+ x1957 = m1957;
+ l1957 = m1957;
+ x1957 = confuse(m1957);
+ l1957 = confuse(m1957);
+
+ }
+
+
+}
+
+class C58<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, [int x]) x58;
+ List<Function> Function(int x0, [List<T> x]) x158;
+ List<T> Function([core.List<core.int> x]) x258;
+ List<Function> Function<A>(A x) x358;
+ int Function(int y, [Function x]) Function<B extends core.int>() x458;
+ int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() x558;
+ Function Function({int x}) Function<B extends core.int>() x658;
+ Function Function(core.List<core.int> x) Function<B extends core.int>() x758;
+ List<Function> Function(int x1, [int x]) Function<B extends core.int>() x858;
+ List<Function> Function([List<Function> x1]) Function<B extends core.int>() x958;
+ List<Function> Function({List<T> x}) Function<B extends core.int>() x1058;
+ core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>() x1158;
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>() x1258;
+ List<T> Function(Function x1) Function<B extends core.int>() x1358;
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() x1458;
+ Function(int x1, {int x}) Function<B extends core.int>() x1558;
+ Function([core.List<core.int> x]) Function<B extends core.int>() x1658;
+ int Function<A>(core.List<core.int> x) Function<B extends core.int>() x1758;
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>() x1858;
+ A Function<A>() Function<B extends core.int>() x1958;
+
+
+ C58({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m58(int x0, [int x]) => null;
+ List<Function> m158(int x0, [List<T> x]) => null;
+ List<T> m258([core.List<core.int> x]) => null;
+ List<Function> m358<A>(A x) => null;
+ int Function(int y, [Function x]) m458<B extends core.int>() => null;
+ int Function(int x0, [core.List<core.int> x1]) m558<B extends core.int>() => null;
+ Function Function({int x}) m658<B extends core.int>() => null;
+ Function Function(core.List<core.int> x) m758<B extends core.int>() => null;
+ List<Function> Function(int x0, [int x]) m858<B extends core.int>() => null;
+ List<Function> Function([List<Function> x0]) m958<B extends core.int>() => null;
+ List<Function> Function({List<T> x}) m1058<B extends core.int>() => null;
+ core.List<core.int> Function(int y, {Function x}) m1158<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [List<T> x]) m1258<B extends core.int>() => null;
+ List<T> Function(Function x0) m1358<B extends core.int>() => null;
+ List<T> Function(int x, [core.List<core.int> x0]) m1458<B extends core.int>() => null;
+ Function(int x0, {int x}) m1558<B extends core.int>() => null;
+ Function([core.List<core.int> x]) m1658<B extends core.int>() => null;
+ int Function<A>(core.List<core.int> x) m1758<B extends core.int>() => null;
+ core.List<core.int> Function<A>(List<T> x) m1858<B extends core.int>() => null;
+ A Function<A>() m1958<B extends core.int>() => null;
+
+
+ runTests() {
+ testF58();
+ testF158();
+ testF258();
+ testF358();
+ testF458();
+ testF558();
+ testF658();
+ testF758();
+ testF858();
+ testF958();
+ testF1058();
+ testF1158();
+ testF1258();
+ testF1358();
+ testF1458();
+ testF1558();
+ testF1658();
+ testF1758();
+ testF1858();
+ testF1958();
+ }
+
+ void testF58() {
+ // Function Function(int x0, [int x])
+ Expect.isTrue(f58 is F58);
+ Expect.isTrue(confuse(f58) is F58);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [int x]) l58;
+ // The static function f58 sets `T` to `int`.
+ if (!tIsBool) {
+ x58 = f58 as dynamic;
+ l58 = f58 as dynamic;
+ x58 = confuse(f58);
+ l58 = confuse(f58);
+ }
+
+ Expect.isTrue(m58 is F58);
+ Expect.isTrue(m58 is Function Function(int x0, [int x]));
+ Expect.isTrue(confuse(m58) is F58);
+ // In checked mode, verifies the type.
+ x58 = m58;
+ l58 = m58;
+ x58 = confuse(m58);
+ l58 = confuse(m58);
+
+ }
+
+ void testF158() {
+ // List<Function> Function(int x0, [List<T> x])
+ Expect.isTrue(f158 is F158);
+ Expect.isTrue(confuse(f158) is F158);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [List<T> x]) l158;
+ // The static function f158 sets `T` to `int`.
+ if (!tIsBool) {
+ x158 = f158 as dynamic;
+ l158 = f158 as dynamic;
+ x158 = confuse(f158);
+ l158 = confuse(f158);
+ }
+
+ Expect.isTrue(m158 is F158);
+ Expect.isTrue(m158 is List<Function> Function(int x0, [List<T> x]));
+ Expect.isTrue(confuse(m158) is F158);
+ // In checked mode, verifies the type.
+ x158 = m158;
+ l158 = m158;
+ x158 = confuse(m158);
+ l158 = confuse(m158);
+ if (!tIsBool) {
+ Expect.isTrue(f158 is F158<int>);
+ Expect.isFalse(f158 is F158<bool>);
+ Expect.isTrue(confuse(f158) is F158<int>);
+ Expect.isFalse(confuse(f158) is F158<bool>);
+ Expect.equals(tIsDynamic, m158 is F158<bool>);
+ Expect.equals(tIsDynamic, confuse(m158) is F158<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x158 = (f158 as dynamic); });
+ Expect.throws(() { x158 = confuse(f158); });
+ List<Function> Function(int x0, [List<T> x]) l158;
+ Expect.throws(() { l158 = (f158 as dynamic); });
+ Expect.throws(() { l158 = confuse(f158); });
+ }
+ List<Function> Function(int x0, [List<T> x]) l158 = m158;
+ // In checked mode, verifies the type.
+ x158 = m158;
+ x158 = confuse(m158);
+ }
+ }
+
+ void testF258() {
+ // List<T> Function([core.List<core.int> x])
+ Expect.isTrue(f258 is F258);
+ Expect.isTrue(confuse(f258) is F258);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x]) l258;
+ // The static function f258 sets `T` to `int`.
+ if (!tIsBool) {
+ x258 = f258 as dynamic;
+ l258 = f258 as dynamic;
+ x258 = confuse(f258);
+ l258 = confuse(f258);
+ }
+
+ Expect.isTrue(m258 is F258);
+ Expect.isTrue(m258 is List<T> Function([core.List<core.int> x]));
+ Expect.isTrue(confuse(m258) is F258);
+ // In checked mode, verifies the type.
+ x258 = m258;
+ l258 = m258;
+ x258 = confuse(m258);
+ l258 = confuse(m258);
+ if (!tIsBool) {
+ Expect.isTrue(f258 is F258<int>);
+ Expect.isFalse(f258 is F258<bool>);
+ Expect.isTrue(confuse(f258) is F258<int>);
+ Expect.isFalse(confuse(f258) is F258<bool>);
+ Expect.equals(tIsDynamic, m258 is F258<bool>);
+ Expect.equals(tIsDynamic, confuse(m258) is F258<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x258 = (f258 as dynamic); });
+ Expect.throws(() { x258 = confuse(f258); });
+ List<T> Function([core.List<core.int> x]) l258;
+ Expect.throws(() { l258 = (f258 as dynamic); });
+ Expect.throws(() { l258 = confuse(f258); });
+ }
+ List<T> Function([core.List<core.int> x]) l258 = m258;
+ // In checked mode, verifies the type.
+ x258 = m258;
+ x258 = confuse(m258);
+ }
+ }
+
+ void testF358() {
+ // List<Function> Function<A>(A x)
+ Expect.isTrue(f358 is F358);
+ Expect.isTrue(confuse(f358) is F358);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(A x) l358;
+ // The static function f358 sets `T` to `int`.
+ if (!tIsBool) {
+ x358 = f358 as dynamic;
+ l358 = f358 as dynamic;
+ x358 = confuse(f358);
+ l358 = confuse(f358);
+ }
+
+ Expect.isTrue(m358 is F358);
+ Expect.isTrue(m358 is List<Function> Function<A>(A x));
+ Expect.isTrue(confuse(m358) is F358);
+ // In checked mode, verifies the type.
+ x358 = m358;
+ l358 = m358;
+ x358 = confuse(m358);
+ l358 = confuse(m358);
+
+ }
+
+ void testF458() {
+ // int Function(int y, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f458 is F458);
+ Expect.isTrue(confuse(f458) is F458);
+ // In checked mode, verifies the type.
+ int Function(int y, [Function x]) Function<B extends core.int>() l458;
+ // The static function f458 sets `T` to `int`.
+ if (!tIsBool) {
+ x458 = f458 as dynamic;
+ l458 = f458 as dynamic;
+ x458 = confuse(f458);
+ l458 = confuse(f458);
+ }
+
+ Expect.isTrue(m458 is F458);
+ Expect.isTrue(m458 is int Function(int y, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m458) is F458);
+ // In checked mode, verifies the type.
+ x458 = m458;
+ l458 = m458;
+ x458 = confuse(m458);
+ l458 = confuse(m458);
+
+ }
+
+ void testF558() {
+ // int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>()
+ Expect.isTrue(f558 is F558);
+ Expect.isTrue(confuse(f558) is F558);
+ // In checked mode, verifies the type.
+ int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l558;
+ // The static function f558 sets `T` to `int`.
+ if (!tIsBool) {
+ x558 = f558 as dynamic;
+ l558 = f558 as dynamic;
+ x558 = confuse(f558);
+ l558 = confuse(f558);
+ }
+
+ Expect.isTrue(m558 is F558);
+ Expect.isTrue(m558 is int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m558) is F558);
+ // In checked mode, verifies the type.
+ x558 = m558;
+ l558 = m558;
+ x558 = confuse(m558);
+ l558 = confuse(m558);
+
+ }
+
+ void testF658() {
+ // Function Function({int x}) Function<B extends core.int>()
+ Expect.isTrue(f658 is F658);
+ Expect.isTrue(confuse(f658) is F658);
+ // In checked mode, verifies the type.
+ Function Function({int x}) Function<B extends core.int>() l658;
+ // The static function f658 sets `T` to `int`.
+ if (!tIsBool) {
+ x658 = f658 as dynamic;
+ l658 = f658 as dynamic;
+ x658 = confuse(f658);
+ l658 = confuse(f658);
+ }
+
+ Expect.isTrue(m658 is F658);
+ Expect.isTrue(m658 is Function Function({int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m658) is F658);
+ // In checked mode, verifies the type.
+ x658 = m658;
+ l658 = m658;
+ x658 = confuse(m658);
+ l658 = confuse(m658);
+
+ }
+
+ void testF758() {
+ // Function Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f758 is F758);
+ Expect.isTrue(confuse(f758) is F758);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x) Function<B extends core.int>() l758;
+ // The static function f758 sets `T` to `int`.
+ if (!tIsBool) {
+ x758 = f758 as dynamic;
+ l758 = f758 as dynamic;
+ x758 = confuse(f758);
+ l758 = confuse(f758);
+ }
+
+ Expect.isTrue(m758 is F758);
+ Expect.isTrue(m758 is Function Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m758) is F758);
+ // In checked mode, verifies the type.
+ x758 = m758;
+ l758 = m758;
+ x758 = confuse(m758);
+ l758 = confuse(m758);
+
+ }
+
+ void testF858() {
+ // List<Function> Function(int x1, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f858 is F858);
+ Expect.isTrue(confuse(f858) is F858);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [int x]) Function<B extends core.int>() l858;
+ // The static function f858 sets `T` to `int`.
+ if (!tIsBool) {
+ x858 = f858 as dynamic;
+ l858 = f858 as dynamic;
+ x858 = confuse(f858);
+ l858 = confuse(f858);
+ }
+
+ Expect.isTrue(m858 is F858);
+ Expect.isTrue(m858 is List<Function> Function(int x1, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m858) is F858);
+ // In checked mode, verifies the type.
+ x858 = m858;
+ l858 = m858;
+ x858 = confuse(m858);
+ l858 = confuse(m858);
+
+ }
+
+ void testF958() {
+ // List<Function> Function([List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f958 is F958);
+ Expect.isTrue(confuse(f958) is F958);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x1]) Function<B extends core.int>() l958;
+ // The static function f958 sets `T` to `int`.
+ if (!tIsBool) {
+ x958 = f958 as dynamic;
+ l958 = f958 as dynamic;
+ x958 = confuse(f958);
+ l958 = confuse(f958);
+ }
+
+ Expect.isTrue(m958 is F958);
+ Expect.isTrue(m958 is List<Function> Function([List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m958) is F958);
+ // In checked mode, verifies the type.
+ x958 = m958;
+ l958 = m958;
+ x958 = confuse(m958);
+ l958 = confuse(m958);
+
+ }
+
+ void testF1058() {
+ // List<Function> Function({List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1058 is F1058);
+ Expect.isTrue(confuse(f1058) is F1058);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<T> x}) Function<B extends core.int>() l1058;
+ // The static function f1058 sets `T` to `int`.
+ if (!tIsBool) {
+ x1058 = f1058 as dynamic;
+ l1058 = f1058 as dynamic;
+ x1058 = confuse(f1058);
+ l1058 = confuse(f1058);
+ }
+
+ Expect.isTrue(m1058 is F1058);
+ Expect.isTrue(m1058 is List<Function> Function({List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1058) is F1058);
+ // In checked mode, verifies the type.
+ x1058 = m1058;
+ l1058 = m1058;
+ x1058 = confuse(m1058);
+ l1058 = confuse(m1058);
+ if (!tIsBool) {
+ Expect.isTrue(f1058 is F1058<int>);
+ Expect.isFalse(f1058 is F1058<bool>);
+ Expect.isTrue(confuse(f1058) is F1058<int>);
+ Expect.isFalse(confuse(f1058) is F1058<bool>);
+ Expect.equals(tIsDynamic, m1058 is F1058<bool>);
+ Expect.equals(tIsDynamic, confuse(m1058) is F1058<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1058 = (f1058 as dynamic); });
+ Expect.throws(() { x1058 = confuse(f1058); });
+ List<Function> Function({List<T> x}) Function<B extends core.int>() l1058;
+ Expect.throws(() { l1058 = (f1058 as dynamic); });
+ Expect.throws(() { l1058 = confuse(f1058); });
+ }
+ List<Function> Function({List<T> x}) Function<B extends core.int>() l1058 = m1058;
+ // In checked mode, verifies the type.
+ x1058 = m1058;
+ x1058 = confuse(m1058);
+ }
+ }
+
+ void testF1158() {
+ // core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1158 is F1158);
+ Expect.isTrue(confuse(f1158) is F1158);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>() l1158;
+ // The static function f1158 sets `T` to `int`.
+ if (!tIsBool) {
+ x1158 = f1158 as dynamic;
+ l1158 = f1158 as dynamic;
+ x1158 = confuse(f1158);
+ l1158 = confuse(f1158);
+ }
+
+ Expect.isTrue(m1158 is F1158);
+ Expect.isTrue(m1158 is core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1158) is F1158);
+ // In checked mode, verifies the type.
+ x1158 = m1158;
+ l1158 = m1158;
+ x1158 = confuse(m1158);
+ l1158 = confuse(m1158);
+
+ }
+
+ void testF1258() {
+ // core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1258 is F1258);
+ Expect.isTrue(confuse(f1258) is F1258);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>() l1258;
+ // The static function f1258 sets `T` to `int`.
+ if (!tIsBool) {
+ x1258 = f1258 as dynamic;
+ l1258 = f1258 as dynamic;
+ x1258 = confuse(f1258);
+ l1258 = confuse(f1258);
+ }
+
+ Expect.isTrue(m1258 is F1258);
+ Expect.isTrue(m1258 is core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1258) is F1258);
+ // In checked mode, verifies the type.
+ x1258 = m1258;
+ l1258 = m1258;
+ x1258 = confuse(m1258);
+ l1258 = confuse(m1258);
+ if (!tIsBool) {
+ Expect.isTrue(f1258 is F1258<int>);
+ Expect.isFalse(f1258 is F1258<bool>);
+ Expect.isTrue(confuse(f1258) is F1258<int>);
+ Expect.isFalse(confuse(f1258) is F1258<bool>);
+ Expect.equals(tIsDynamic, m1258 is F1258<bool>);
+ Expect.equals(tIsDynamic, confuse(m1258) is F1258<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1258 = (f1258 as dynamic); });
+ Expect.throws(() { x1258 = confuse(f1258); });
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>() l1258;
+ Expect.throws(() { l1258 = (f1258 as dynamic); });
+ Expect.throws(() { l1258 = confuse(f1258); });
+ }
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>() l1258 = m1258;
+ // In checked mode, verifies the type.
+ x1258 = m1258;
+ x1258 = confuse(m1258);
+ }
+ }
+
+ void testF1358() {
+ // List<T> Function(Function x1) Function<B extends core.int>()
+ Expect.isTrue(f1358 is F1358);
+ Expect.isTrue(confuse(f1358) is F1358);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x1) Function<B extends core.int>() l1358;
+ // The static function f1358 sets `T` to `int`.
+ if (!tIsBool) {
+ x1358 = f1358 as dynamic;
+ l1358 = f1358 as dynamic;
+ x1358 = confuse(f1358);
+ l1358 = confuse(f1358);
+ }
+
+ Expect.isTrue(m1358 is F1358);
+ Expect.isTrue(m1358 is List<T> Function(Function x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1358) is F1358);
+ // In checked mode, verifies the type.
+ x1358 = m1358;
+ l1358 = m1358;
+ x1358 = confuse(m1358);
+ l1358 = confuse(m1358);
+ if (!tIsBool) {
+ Expect.isTrue(f1358 is F1358<int>);
+ Expect.isFalse(f1358 is F1358<bool>);
+ Expect.isTrue(confuse(f1358) is F1358<int>);
+ Expect.isFalse(confuse(f1358) is F1358<bool>);
+ Expect.equals(tIsDynamic, m1358 is F1358<bool>);
+ Expect.equals(tIsDynamic, confuse(m1358) is F1358<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1358 = (f1358 as dynamic); });
+ Expect.throws(() { x1358 = confuse(f1358); });
+ List<T> Function(Function x1) Function<B extends core.int>() l1358;
+ Expect.throws(() { l1358 = (f1358 as dynamic); });
+ Expect.throws(() { l1358 = confuse(f1358); });
+ }
+ List<T> Function(Function x1) Function<B extends core.int>() l1358 = m1358;
+ // In checked mode, verifies the type.
+ x1358 = m1358;
+ x1358 = confuse(m1358);
+ }
+ }
+
+ void testF1458() {
+ // List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1458 is F1458);
+ Expect.isTrue(confuse(f1458) is F1458);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l1458;
+ // The static function f1458 sets `T` to `int`.
+ if (!tIsBool) {
+ x1458 = f1458 as dynamic;
+ l1458 = f1458 as dynamic;
+ x1458 = confuse(f1458);
+ l1458 = confuse(f1458);
+ }
+
+ Expect.isTrue(m1458 is F1458);
+ Expect.isTrue(m1458 is List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1458) is F1458);
+ // In checked mode, verifies the type.
+ x1458 = m1458;
+ l1458 = m1458;
+ x1458 = confuse(m1458);
+ l1458 = confuse(m1458);
+ if (!tIsBool) {
+ Expect.isTrue(f1458 is F1458<int>);
+ Expect.isFalse(f1458 is F1458<bool>);
+ Expect.isTrue(confuse(f1458) is F1458<int>);
+ Expect.isFalse(confuse(f1458) is F1458<bool>);
+ Expect.equals(tIsDynamic, m1458 is F1458<bool>);
+ Expect.equals(tIsDynamic, confuse(m1458) is F1458<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1458 = (f1458 as dynamic); });
+ Expect.throws(() { x1458 = confuse(f1458); });
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l1458;
+ Expect.throws(() { l1458 = (f1458 as dynamic); });
+ Expect.throws(() { l1458 = confuse(f1458); });
+ }
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l1458 = m1458;
+ // In checked mode, verifies the type.
+ x1458 = m1458;
+ x1458 = confuse(m1458);
+ }
+ }
+
+ void testF1558() {
+ // Function(int x1, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f1558 is F1558);
+ Expect.isTrue(confuse(f1558) is F1558);
+ // In checked mode, verifies the type.
+ Function(int x1, {int x}) Function<B extends core.int>() l1558;
+ // The static function f1558 sets `T` to `int`.
+ if (!tIsBool) {
+ x1558 = f1558 as dynamic;
+ l1558 = f1558 as dynamic;
+ x1558 = confuse(f1558);
+ l1558 = confuse(f1558);
+ }
+
+ Expect.isTrue(m1558 is F1558);
+ Expect.isTrue(m1558 is Function(int x1, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1558) is F1558);
+ // In checked mode, verifies the type.
+ x1558 = m1558;
+ l1558 = m1558;
+ x1558 = confuse(m1558);
+ l1558 = confuse(m1558);
+
+ }
+
+ void testF1658() {
+ // Function([core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1658 is F1658);
+ Expect.isTrue(confuse(f1658) is F1658);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x]) Function<B extends core.int>() l1658;
+ // The static function f1658 sets `T` to `int`.
+ if (!tIsBool) {
+ x1658 = f1658 as dynamic;
+ l1658 = f1658 as dynamic;
+ x1658 = confuse(f1658);
+ l1658 = confuse(f1658);
+ }
+
+ Expect.isTrue(m1658 is F1658);
+ Expect.isTrue(m1658 is Function([core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1658) is F1658);
+ // In checked mode, verifies the type.
+ x1658 = m1658;
+ l1658 = m1658;
+ x1658 = confuse(m1658);
+ l1658 = confuse(m1658);
+
+ }
+
+ void testF1758() {
+ // int Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1758 is F1758);
+ Expect.isTrue(confuse(f1758) is F1758);
+ // In checked mode, verifies the type.
+ int Function<A>(core.List<core.int> x) Function<B extends core.int>() l1758;
+ // The static function f1758 sets `T` to `int`.
+ if (!tIsBool) {
+ x1758 = f1758 as dynamic;
+ l1758 = f1758 as dynamic;
+ x1758 = confuse(f1758);
+ l1758 = confuse(f1758);
+ }
+
+ Expect.isTrue(m1758 is F1758);
+ Expect.isTrue(m1758 is int Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1758) is F1758);
+ // In checked mode, verifies the type.
+ x1758 = m1758;
+ l1758 = m1758;
+ x1758 = confuse(m1758);
+ l1758 = confuse(m1758);
+
+ }
+
+ void testF1858() {
+ // core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1858 is F1858);
+ Expect.isTrue(confuse(f1858) is F1858);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>() l1858;
+ // The static function f1858 sets `T` to `int`.
+ if (!tIsBool) {
+ x1858 = f1858 as dynamic;
+ l1858 = f1858 as dynamic;
+ x1858 = confuse(f1858);
+ l1858 = confuse(f1858);
+ }
+
+ Expect.isTrue(m1858 is F1858);
+ Expect.isTrue(m1858 is core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1858) is F1858);
+ // In checked mode, verifies the type.
+ x1858 = m1858;
+ l1858 = m1858;
+ x1858 = confuse(m1858);
+ l1858 = confuse(m1858);
+ if (!tIsBool) {
+ Expect.isTrue(f1858 is F1858<int>);
+ Expect.isFalse(f1858 is F1858<bool>);
+ Expect.isTrue(confuse(f1858) is F1858<int>);
+ Expect.isFalse(confuse(f1858) is F1858<bool>);
+ Expect.equals(tIsDynamic, m1858 is F1858<bool>);
+ Expect.equals(tIsDynamic, confuse(m1858) is F1858<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1858 = (f1858 as dynamic); });
+ Expect.throws(() { x1858 = confuse(f1858); });
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>() l1858;
+ Expect.throws(() { l1858 = (f1858 as dynamic); });
+ Expect.throws(() { l1858 = confuse(f1858); });
+ }
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>() l1858 = m1858;
+ // In checked mode, verifies the type.
+ x1858 = m1858;
+ x1858 = confuse(m1858);
+ }
+ }
+
+ void testF1958() {
+ // A Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1958 is F1958);
+ Expect.isTrue(confuse(f1958) is F1958);
+ // In checked mode, verifies the type.
+ A Function<A>() Function<B extends core.int>() l1958;
+ // The static function f1958 sets `T` to `int`.
+ if (!tIsBool) {
+ x1958 = f1958 as dynamic;
+ l1958 = f1958 as dynamic;
+ x1958 = confuse(f1958);
+ l1958 = confuse(f1958);
+ }
+
+ Expect.isTrue(m1958 is F1958);
+ Expect.isTrue(m1958 is A Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1958) is F1958);
+ // In checked mode, verifies the type.
+ x1958 = m1958;
+ l1958 = m1958;
+ x1958 = confuse(m1958);
+ l1958 = confuse(m1958);
+
+ }
+
+
+}
+
+class C59<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, [int x]) x59;
+ List<Function> Function(int y, [List<T> x]) x159;
+ List<T> Function(int x0, [core.List<core.int> x]) x259;
+ List<Function> Function<A>(List<A> x) x359;
+ int Function(int y, [Function x]) Function<B extends core.int>(int x) x459;
+ int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) x559;
+ Function Function({int x}) Function<B extends core.int>(int x) x659;
+ Function Function(core.List<core.int> x) Function<B extends core.int>(int x) x759;
+ List<Function> Function(int x1, [int x]) Function<B extends core.int>(int x) x859;
+ List<Function> Function([List<Function> x1]) Function<B extends core.int>(int x) x959;
+ List<Function> Function({List<T> x}) Function<B extends core.int>(int x) x1059;
+ core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>(int x) x1159;
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x1259;
+ List<T> Function(Function x1) Function<B extends core.int>(int x) x1359;
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) x1459;
+ Function(int x1, {int x}) Function<B extends core.int>(int x) x1559;
+ Function([core.List<core.int> x]) Function<B extends core.int>(int x) x1659;
+ int Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1759;
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x) x1859;
+ A Function<A>() Function<B extends core.int>(int x) x1959;
+
+
+ C59({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m59(int y, [int x]) => null;
+ List<Function> m159(int y, [List<T> x]) => null;
+ List<T> m259(int x0, [core.List<core.int> x]) => null;
+ List<Function> m359<A>(List<A> x) => null;
+ int Function(int y, [Function x]) m459<B extends core.int>(int x) => null;
+ int Function(int x0, [core.List<core.int> x1]) m559<B extends core.int>(int x) => null;
+ Function Function({int x}) m659<B extends core.int>(int x) => null;
+ Function Function(core.List<core.int> x) m759<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [int x]) m859<B extends core.int>(int x) => null;
+ List<Function> Function([List<Function> x0]) m959<B extends core.int>(int x) => null;
+ List<Function> Function({List<T> x}) m1059<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, {Function x}) m1159<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [List<T> x]) m1259<B extends core.int>(int x) => null;
+ List<T> Function(Function x0) m1359<B extends core.int>(int x) => null;
+ List<T> Function(int x, [core.List<core.int> x0]) m1459<B extends core.int>(int x) => null;
+ Function(int x0, {int x}) m1559<B extends core.int>(int x) => null;
+ Function([core.List<core.int> x]) m1659<B extends core.int>(int x) => null;
+ int Function<A>(core.List<core.int> x) m1759<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(List<T> x) m1859<B extends core.int>(int x) => null;
+ A Function<A>() m1959<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF59();
+ testF159();
+ testF259();
+ testF359();
+ testF459();
+ testF559();
+ testF659();
+ testF759();
+ testF859();
+ testF959();
+ testF1059();
+ testF1159();
+ testF1259();
+ testF1359();
+ testF1459();
+ testF1559();
+ testF1659();
+ testF1759();
+ testF1859();
+ testF1959();
+ }
+
+ void testF59() {
+ // Function Function(int y, [int x])
+ Expect.isTrue(f59 is F59);
+ Expect.isTrue(confuse(f59) is F59);
+ // In checked mode, verifies the type.
+ Function Function(int y, [int x]) l59;
+ // The static function f59 sets `T` to `int`.
+ if (!tIsBool) {
+ x59 = f59 as dynamic;
+ l59 = f59 as dynamic;
+ x59 = confuse(f59);
+ l59 = confuse(f59);
+ }
+
+ Expect.isTrue(m59 is F59);
+ Expect.isTrue(m59 is Function Function(int y, [int x]));
+ Expect.isTrue(confuse(m59) is F59);
+ // In checked mode, verifies the type.
+ x59 = m59;
+ l59 = m59;
+ x59 = confuse(m59);
+ l59 = confuse(m59);
+
+ }
+
+ void testF159() {
+ // List<Function> Function(int y, [List<T> x])
+ Expect.isTrue(f159 is F159);
+ Expect.isTrue(confuse(f159) is F159);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [List<T> x]) l159;
+ // The static function f159 sets `T` to `int`.
+ if (!tIsBool) {
+ x159 = f159 as dynamic;
+ l159 = f159 as dynamic;
+ x159 = confuse(f159);
+ l159 = confuse(f159);
+ }
+
+ Expect.isTrue(m159 is F159);
+ Expect.isTrue(m159 is List<Function> Function(int y, [List<T> x]));
+ Expect.isTrue(confuse(m159) is F159);
+ // In checked mode, verifies the type.
+ x159 = m159;
+ l159 = m159;
+ x159 = confuse(m159);
+ l159 = confuse(m159);
+ if (!tIsBool) {
+ Expect.isTrue(f159 is F159<int>);
+ Expect.isFalse(f159 is F159<bool>);
+ Expect.isTrue(confuse(f159) is F159<int>);
+ Expect.isFalse(confuse(f159) is F159<bool>);
+ Expect.equals(tIsDynamic, m159 is F159<bool>);
+ Expect.equals(tIsDynamic, confuse(m159) is F159<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x159 = (f159 as dynamic); });
+ Expect.throws(() { x159 = confuse(f159); });
+ List<Function> Function(int y, [List<T> x]) l159;
+ Expect.throws(() { l159 = (f159 as dynamic); });
+ Expect.throws(() { l159 = confuse(f159); });
+ }
+ List<Function> Function(int y, [List<T> x]) l159 = m159;
+ // In checked mode, verifies the type.
+ x159 = m159;
+ x159 = confuse(m159);
+ }
+ }
+
+ void testF259() {
+ // List<T> Function(int x0, [core.List<core.int> x])
+ Expect.isTrue(f259 is F259);
+ Expect.isTrue(confuse(f259) is F259);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [core.List<core.int> x]) l259;
+ // The static function f259 sets `T` to `int`.
+ if (!tIsBool) {
+ x259 = f259 as dynamic;
+ l259 = f259 as dynamic;
+ x259 = confuse(f259);
+ l259 = confuse(f259);
+ }
+
+ Expect.isTrue(m259 is F259);
+ Expect.isTrue(m259 is List<T> Function(int x0, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m259) is F259);
+ // In checked mode, verifies the type.
+ x259 = m259;
+ l259 = m259;
+ x259 = confuse(m259);
+ l259 = confuse(m259);
+ if (!tIsBool) {
+ Expect.isTrue(f259 is F259<int>);
+ Expect.isFalse(f259 is F259<bool>);
+ Expect.isTrue(confuse(f259) is F259<int>);
+ Expect.isFalse(confuse(f259) is F259<bool>);
+ Expect.equals(tIsDynamic, m259 is F259<bool>);
+ Expect.equals(tIsDynamic, confuse(m259) is F259<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x259 = (f259 as dynamic); });
+ Expect.throws(() { x259 = confuse(f259); });
+ List<T> Function(int x0, [core.List<core.int> x]) l259;
+ Expect.throws(() { l259 = (f259 as dynamic); });
+ Expect.throws(() { l259 = confuse(f259); });
+ }
+ List<T> Function(int x0, [core.List<core.int> x]) l259 = m259;
+ // In checked mode, verifies the type.
+ x259 = m259;
+ x259 = confuse(m259);
+ }
+ }
+
+ void testF359() {
+ // List<Function> Function<A>(List<A> x)
+ Expect.isTrue(f359 is F359);
+ Expect.isTrue(confuse(f359) is F359);
+ // In checked mode, verifies the type.
+ List<Function> Function<A>(List<A> x) l359;
+ // The static function f359 sets `T` to `int`.
+ if (!tIsBool) {
+ x359 = f359 as dynamic;
+ l359 = f359 as dynamic;
+ x359 = confuse(f359);
+ l359 = confuse(f359);
+ }
+
+ Expect.isTrue(m359 is F359);
+ Expect.isTrue(m359 is List<Function> Function<A>(List<A> x));
+ Expect.isTrue(confuse(m359) is F359);
+ // In checked mode, verifies the type.
+ x359 = m359;
+ l359 = m359;
+ x359 = confuse(m359);
+ l359 = confuse(m359);
+
+ }
+
+ void testF459() {
+ // int Function(int y, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f459 is F459);
+ Expect.isTrue(confuse(f459) is F459);
+ // In checked mode, verifies the type.
+ int Function(int y, [Function x]) Function<B extends core.int>(int x) l459;
+ // The static function f459 sets `T` to `int`.
+ if (!tIsBool) {
+ x459 = f459 as dynamic;
+ l459 = f459 as dynamic;
+ x459 = confuse(f459);
+ l459 = confuse(f459);
+ }
+
+ Expect.isTrue(m459 is F459);
+ Expect.isTrue(m459 is int Function(int y, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m459) is F459);
+ // In checked mode, verifies the type.
+ x459 = m459;
+ l459 = m459;
+ x459 = confuse(m459);
+ l459 = confuse(m459);
+
+ }
+
+ void testF559() {
+ // int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f559 is F559);
+ Expect.isTrue(confuse(f559) is F559);
+ // In checked mode, verifies the type.
+ int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l559;
+ // The static function f559 sets `T` to `int`.
+ if (!tIsBool) {
+ x559 = f559 as dynamic;
+ l559 = f559 as dynamic;
+ x559 = confuse(f559);
+ l559 = confuse(f559);
+ }
+
+ Expect.isTrue(m559 is F559);
+ Expect.isTrue(m559 is int Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m559) is F559);
+ // In checked mode, verifies the type.
+ x559 = m559;
+ l559 = m559;
+ x559 = confuse(m559);
+ l559 = confuse(m559);
+
+ }
+
+ void testF659() {
+ // Function Function({int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f659 is F659);
+ Expect.isTrue(confuse(f659) is F659);
+ // In checked mode, verifies the type.
+ Function Function({int x}) Function<B extends core.int>(int x) l659;
+ // The static function f659 sets `T` to `int`.
+ if (!tIsBool) {
+ x659 = f659 as dynamic;
+ l659 = f659 as dynamic;
+ x659 = confuse(f659);
+ l659 = confuse(f659);
+ }
+
+ Expect.isTrue(m659 is F659);
+ Expect.isTrue(m659 is Function Function({int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m659) is F659);
+ // In checked mode, verifies the type.
+ x659 = m659;
+ l659 = m659;
+ x659 = confuse(m659);
+ l659 = confuse(m659);
+
+ }
+
+ void testF759() {
+ // Function Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f759 is F759);
+ Expect.isTrue(confuse(f759) is F759);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x) Function<B extends core.int>(int x) l759;
+ // The static function f759 sets `T` to `int`.
+ if (!tIsBool) {
+ x759 = f759 as dynamic;
+ l759 = f759 as dynamic;
+ x759 = confuse(f759);
+ l759 = confuse(f759);
+ }
+
+ Expect.isTrue(m759 is F759);
+ Expect.isTrue(m759 is Function Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m759) is F759);
+ // In checked mode, verifies the type.
+ x759 = m759;
+ l759 = m759;
+ x759 = confuse(m759);
+ l759 = confuse(m759);
+
+ }
+
+ void testF859() {
+ // List<Function> Function(int x1, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f859 is F859);
+ Expect.isTrue(confuse(f859) is F859);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [int x]) Function<B extends core.int>(int x) l859;
+ // The static function f859 sets `T` to `int`.
+ if (!tIsBool) {
+ x859 = f859 as dynamic;
+ l859 = f859 as dynamic;
+ x859 = confuse(f859);
+ l859 = confuse(f859);
+ }
+
+ Expect.isTrue(m859 is F859);
+ Expect.isTrue(m859 is List<Function> Function(int x1, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m859) is F859);
+ // In checked mode, verifies the type.
+ x859 = m859;
+ l859 = m859;
+ x859 = confuse(m859);
+ l859 = confuse(m859);
+
+ }
+
+ void testF959() {
+ // List<Function> Function([List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f959 is F959);
+ Expect.isTrue(confuse(f959) is F959);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<Function> x1]) Function<B extends core.int>(int x) l959;
+ // The static function f959 sets `T` to `int`.
+ if (!tIsBool) {
+ x959 = f959 as dynamic;
+ l959 = f959 as dynamic;
+ x959 = confuse(f959);
+ l959 = confuse(f959);
+ }
+
+ Expect.isTrue(m959 is F959);
+ Expect.isTrue(m959 is List<Function> Function([List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m959) is F959);
+ // In checked mode, verifies the type.
+ x959 = m959;
+ l959 = m959;
+ x959 = confuse(m959);
+ l959 = confuse(m959);
+
+ }
+
+ void testF1059() {
+ // List<Function> Function({List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1059 is F1059);
+ Expect.isTrue(confuse(f1059) is F1059);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<T> x}) Function<B extends core.int>(int x) l1059;
+ // The static function f1059 sets `T` to `int`.
+ if (!tIsBool) {
+ x1059 = f1059 as dynamic;
+ l1059 = f1059 as dynamic;
+ x1059 = confuse(f1059);
+ l1059 = confuse(f1059);
+ }
+
+ Expect.isTrue(m1059 is F1059);
+ Expect.isTrue(m1059 is List<Function> Function({List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1059) is F1059);
+ // In checked mode, verifies the type.
+ x1059 = m1059;
+ l1059 = m1059;
+ x1059 = confuse(m1059);
+ l1059 = confuse(m1059);
+ if (!tIsBool) {
+ Expect.isTrue(f1059 is F1059<int>);
+ Expect.isFalse(f1059 is F1059<bool>);
+ Expect.isTrue(confuse(f1059) is F1059<int>);
+ Expect.isFalse(confuse(f1059) is F1059<bool>);
+ Expect.equals(tIsDynamic, m1059 is F1059<bool>);
+ Expect.equals(tIsDynamic, confuse(m1059) is F1059<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1059 = (f1059 as dynamic); });
+ Expect.throws(() { x1059 = confuse(f1059); });
+ List<Function> Function({List<T> x}) Function<B extends core.int>(int x) l1059;
+ Expect.throws(() { l1059 = (f1059 as dynamic); });
+ Expect.throws(() { l1059 = confuse(f1059); });
+ }
+ List<Function> Function({List<T> x}) Function<B extends core.int>(int x) l1059 = m1059;
+ // In checked mode, verifies the type.
+ x1059 = m1059;
+ x1059 = confuse(m1059);
+ }
+ }
+
+ void testF1159() {
+ // core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1159 is F1159);
+ Expect.isTrue(confuse(f1159) is F1159);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>(int x) l1159;
+ // The static function f1159 sets `T` to `int`.
+ if (!tIsBool) {
+ x1159 = f1159 as dynamic;
+ l1159 = f1159 as dynamic;
+ x1159 = confuse(f1159);
+ l1159 = confuse(f1159);
+ }
+
+ Expect.isTrue(m1159 is F1159);
+ Expect.isTrue(m1159 is core.List<core.int> Function(int y, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1159) is F1159);
+ // In checked mode, verifies the type.
+ x1159 = m1159;
+ l1159 = m1159;
+ x1159 = confuse(m1159);
+ l1159 = confuse(m1159);
+
+ }
+
+ void testF1259() {
+ // core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1259 is F1259);
+ Expect.isTrue(confuse(f1259) is F1259);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1259;
+ // The static function f1259 sets `T` to `int`.
+ if (!tIsBool) {
+ x1259 = f1259 as dynamic;
+ l1259 = f1259 as dynamic;
+ x1259 = confuse(f1259);
+ l1259 = confuse(f1259);
+ }
+
+ Expect.isTrue(m1259 is F1259);
+ Expect.isTrue(m1259 is core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1259) is F1259);
+ // In checked mode, verifies the type.
+ x1259 = m1259;
+ l1259 = m1259;
+ x1259 = confuse(m1259);
+ l1259 = confuse(m1259);
+ if (!tIsBool) {
+ Expect.isTrue(f1259 is F1259<int>);
+ Expect.isFalse(f1259 is F1259<bool>);
+ Expect.isTrue(confuse(f1259) is F1259<int>);
+ Expect.isFalse(confuse(f1259) is F1259<bool>);
+ Expect.equals(tIsDynamic, m1259 is F1259<bool>);
+ Expect.equals(tIsDynamic, confuse(m1259) is F1259<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1259 = (f1259 as dynamic); });
+ Expect.throws(() { x1259 = confuse(f1259); });
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1259;
+ Expect.throws(() { l1259 = (f1259 as dynamic); });
+ Expect.throws(() { l1259 = confuse(f1259); });
+ }
+ core.List<core.int> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1259 = m1259;
+ // In checked mode, verifies the type.
+ x1259 = m1259;
+ x1259 = confuse(m1259);
+ }
+ }
+
+ void testF1359() {
+ // List<T> Function(Function x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1359 is F1359);
+ Expect.isTrue(confuse(f1359) is F1359);
+ // In checked mode, verifies the type.
+ List<T> Function(Function x1) Function<B extends core.int>(int x) l1359;
+ // The static function f1359 sets `T` to `int`.
+ if (!tIsBool) {
+ x1359 = f1359 as dynamic;
+ l1359 = f1359 as dynamic;
+ x1359 = confuse(f1359);
+ l1359 = confuse(f1359);
+ }
+
+ Expect.isTrue(m1359 is F1359);
+ Expect.isTrue(m1359 is List<T> Function(Function x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1359) is F1359);
+ // In checked mode, verifies the type.
+ x1359 = m1359;
+ l1359 = m1359;
+ x1359 = confuse(m1359);
+ l1359 = confuse(m1359);
+ if (!tIsBool) {
+ Expect.isTrue(f1359 is F1359<int>);
+ Expect.isFalse(f1359 is F1359<bool>);
+ Expect.isTrue(confuse(f1359) is F1359<int>);
+ Expect.isFalse(confuse(f1359) is F1359<bool>);
+ Expect.equals(tIsDynamic, m1359 is F1359<bool>);
+ Expect.equals(tIsDynamic, confuse(m1359) is F1359<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1359 = (f1359 as dynamic); });
+ Expect.throws(() { x1359 = confuse(f1359); });
+ List<T> Function(Function x1) Function<B extends core.int>(int x) l1359;
+ Expect.throws(() { l1359 = (f1359 as dynamic); });
+ Expect.throws(() { l1359 = confuse(f1359); });
+ }
+ List<T> Function(Function x1) Function<B extends core.int>(int x) l1359 = m1359;
+ // In checked mode, verifies the type.
+ x1359 = m1359;
+ x1359 = confuse(m1359);
+ }
+ }
+
+ void testF1459() {
+ // List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1459 is F1459);
+ Expect.isTrue(confuse(f1459) is F1459);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l1459;
+ // The static function f1459 sets `T` to `int`.
+ if (!tIsBool) {
+ x1459 = f1459 as dynamic;
+ l1459 = f1459 as dynamic;
+ x1459 = confuse(f1459);
+ l1459 = confuse(f1459);
+ }
+
+ Expect.isTrue(m1459 is F1459);
+ Expect.isTrue(m1459 is List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1459) is F1459);
+ // In checked mode, verifies the type.
+ x1459 = m1459;
+ l1459 = m1459;
+ x1459 = confuse(m1459);
+ l1459 = confuse(m1459);
+ if (!tIsBool) {
+ Expect.isTrue(f1459 is F1459<int>);
+ Expect.isFalse(f1459 is F1459<bool>);
+ Expect.isTrue(confuse(f1459) is F1459<int>);
+ Expect.isFalse(confuse(f1459) is F1459<bool>);
+ Expect.equals(tIsDynamic, m1459 is F1459<bool>);
+ Expect.equals(tIsDynamic, confuse(m1459) is F1459<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1459 = (f1459 as dynamic); });
+ Expect.throws(() { x1459 = confuse(f1459); });
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l1459;
+ Expect.throws(() { l1459 = (f1459 as dynamic); });
+ Expect.throws(() { l1459 = confuse(f1459); });
+ }
+ List<T> Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l1459 = m1459;
+ // In checked mode, verifies the type.
+ x1459 = m1459;
+ x1459 = confuse(m1459);
+ }
+ }
+
+ void testF1559() {
+ // Function(int x1, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1559 is F1559);
+ Expect.isTrue(confuse(f1559) is F1559);
+ // In checked mode, verifies the type.
+ Function(int x1, {int x}) Function<B extends core.int>(int x) l1559;
+ // The static function f1559 sets `T` to `int`.
+ if (!tIsBool) {
+ x1559 = f1559 as dynamic;
+ l1559 = f1559 as dynamic;
+ x1559 = confuse(f1559);
+ l1559 = confuse(f1559);
+ }
+
+ Expect.isTrue(m1559 is F1559);
+ Expect.isTrue(m1559 is Function(int x1, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1559) is F1559);
+ // In checked mode, verifies the type.
+ x1559 = m1559;
+ l1559 = m1559;
+ x1559 = confuse(m1559);
+ l1559 = confuse(m1559);
+
+ }
+
+ void testF1659() {
+ // Function([core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1659 is F1659);
+ Expect.isTrue(confuse(f1659) is F1659);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x]) Function<B extends core.int>(int x) l1659;
+ // The static function f1659 sets `T` to `int`.
+ if (!tIsBool) {
+ x1659 = f1659 as dynamic;
+ l1659 = f1659 as dynamic;
+ x1659 = confuse(f1659);
+ l1659 = confuse(f1659);
+ }
+
+ Expect.isTrue(m1659 is F1659);
+ Expect.isTrue(m1659 is Function([core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1659) is F1659);
+ // In checked mode, verifies the type.
+ x1659 = m1659;
+ l1659 = m1659;
+ x1659 = confuse(m1659);
+ l1659 = confuse(m1659);
+
+ }
+
+ void testF1759() {
+ // int Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1759 is F1759);
+ Expect.isTrue(confuse(f1759) is F1759);
+ // In checked mode, verifies the type.
+ int Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1759;
+ // The static function f1759 sets `T` to `int`.
+ if (!tIsBool) {
+ x1759 = f1759 as dynamic;
+ l1759 = f1759 as dynamic;
+ x1759 = confuse(f1759);
+ l1759 = confuse(f1759);
+ }
+
+ Expect.isTrue(m1759 is F1759);
+ Expect.isTrue(m1759 is int Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1759) is F1759);
+ // In checked mode, verifies the type.
+ x1759 = m1759;
+ l1759 = m1759;
+ x1759 = confuse(m1759);
+ l1759 = confuse(m1759);
+
+ }
+
+ void testF1859() {
+ // core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1859 is F1859);
+ Expect.isTrue(confuse(f1859) is F1859);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x) l1859;
+ // The static function f1859 sets `T` to `int`.
+ if (!tIsBool) {
+ x1859 = f1859 as dynamic;
+ l1859 = f1859 as dynamic;
+ x1859 = confuse(f1859);
+ l1859 = confuse(f1859);
+ }
+
+ Expect.isTrue(m1859 is F1859);
+ Expect.isTrue(m1859 is core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1859) is F1859);
+ // In checked mode, verifies the type.
+ x1859 = m1859;
+ l1859 = m1859;
+ x1859 = confuse(m1859);
+ l1859 = confuse(m1859);
+ if (!tIsBool) {
+ Expect.isTrue(f1859 is F1859<int>);
+ Expect.isFalse(f1859 is F1859<bool>);
+ Expect.isTrue(confuse(f1859) is F1859<int>);
+ Expect.isFalse(confuse(f1859) is F1859<bool>);
+ Expect.equals(tIsDynamic, m1859 is F1859<bool>);
+ Expect.equals(tIsDynamic, confuse(m1859) is F1859<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1859 = (f1859 as dynamic); });
+ Expect.throws(() { x1859 = confuse(f1859); });
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x) l1859;
+ Expect.throws(() { l1859 = (f1859 as dynamic); });
+ Expect.throws(() { l1859 = confuse(f1859); });
+ }
+ core.List<core.int> Function<A>(List<T> x) Function<B extends core.int>(int x) l1859 = m1859;
+ // In checked mode, verifies the type.
+ x1859 = m1859;
+ x1859 = confuse(m1859);
+ }
+ }
+
+ void testF1959() {
+ // A Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1959 is F1959);
+ Expect.isTrue(confuse(f1959) is F1959);
+ // In checked mode, verifies the type.
+ A Function<A>() Function<B extends core.int>(int x) l1959;
+ // The static function f1959 sets `T` to `int`.
+ if (!tIsBool) {
+ x1959 = f1959 as dynamic;
+ l1959 = f1959 as dynamic;
+ x1959 = confuse(f1959);
+ l1959 = confuse(f1959);
+ }
+
+ Expect.isTrue(m1959 is F1959);
+ Expect.isTrue(m1959 is A Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1959) is F1959);
+ // In checked mode, verifies the type.
+ x1959 = m1959;
+ l1959 = m1959;
+ x1959 = confuse(m1959);
+ l1959 = confuse(m1959);
+
+ }
+
+
+}
+
+class C60<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0) x60;
+ List<Function> Function(List<T> x0) x160;
+ List<T> Function(int y, [core.List<core.int> x]) x260;
+ core.List<core.int> Function<A>(int x) x360;
+ int Function(Function x0) Function() x460;
+ int Function(int x, [core.List<core.int> x2]) Function() x560;
+ Function Function(int x0, {int x}) Function() x660;
+ Function Function([core.List<core.int> x]) Function() x760;
+ List<Function> Function(int y, [int x]) Function() x860;
+ List<Function> Function(int x1, [List<Function> x2]) Function() x960;
+ List<Function> Function(int x0, {List<T> x}) Function() x1060;
+ core.List<core.int> Function(List<Function> x) Function() x1160;
+ core.List<core.int> Function(int y, [List<T> x]) Function() x1260;
+ List<T> Function([Function x1]) Function() x1360;
+ List<T> Function({core.List<core.int> x}) Function() x1460;
+ Function(int y, {int x}) Function() x1560;
+ Function(int x0, [core.List<core.int> x]) Function() x1660;
+ int Function<A>(List<T> x) Function() x1760;
+ core.List<core.int> Function<A>() Function() x1860;
+ A Function<A>(A x) Function() x1960;
+
+
+ C60({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m60(int x0) => null;
+ List<Function> m160(List<T> x0) => null;
+ List<T> m260(int y, [core.List<core.int> x]) => null;
+ core.List<core.int> m360<A>(int x) => null;
+ int Function(Function x0) m460() => null;
+ int Function(int x, [core.List<core.int> x0]) m560() => null;
+ Function Function(int x0, {int x}) m660() => null;
+ Function Function([core.List<core.int> x]) m760() => null;
+ List<Function> Function(int y, [int x]) m860() => null;
+ List<Function> Function(int x0, [List<Function> x1]) m960() => null;
+ List<Function> Function(int x0, {List<T> x}) m1060() => null;
+ core.List<core.int> Function(List<Function> x) m1160() => null;
+ core.List<core.int> Function(int y, [List<T> x]) m1260() => null;
+ List<T> Function([Function x0]) m1360() => null;
+ List<T> Function({core.List<core.int> x}) m1460() => null;
+ Function(int y, {int x}) m1560() => null;
+ Function(int x0, [core.List<core.int> x]) m1660() => null;
+ int Function<A>(List<T> x) m1760() => null;
+ core.List<core.int> Function<A>() m1860() => null;
+ A Function<A>(A x) m1960() => null;
+
+
+ runTests() {
+ testF60();
+ testF160();
+ testF260();
+ testF360();
+ testF460();
+ testF560();
+ testF660();
+ testF760();
+ testF860();
+ testF960();
+ testF1060();
+ testF1160();
+ testF1260();
+ testF1360();
+ testF1460();
+ testF1560();
+ testF1660();
+ testF1760();
+ testF1860();
+ testF1960();
+ }
+
+ void testF60() {
+ // Function Function(int x0)
+ Expect.isTrue(f60 is F60);
+ Expect.isTrue(confuse(f60) is F60);
+ // In checked mode, verifies the type.
+ Function Function(int x0) l60;
+ // The static function f60 sets `T` to `int`.
+ if (!tIsBool) {
+ x60 = f60 as dynamic;
+ l60 = f60 as dynamic;
+ x60 = confuse(f60);
+ l60 = confuse(f60);
+ }
+
+ Expect.isTrue(m60 is F60);
+ Expect.isTrue(m60 is Function Function(int x0));
+ Expect.isTrue(confuse(m60) is F60);
+ // In checked mode, verifies the type.
+ x60 = m60;
+ l60 = m60;
+ x60 = confuse(m60);
+ l60 = confuse(m60);
+
+ }
+
+ void testF160() {
+ // List<Function> Function(List<T> x0)
+ Expect.isTrue(f160 is F160);
+ Expect.isTrue(confuse(f160) is F160);
+ // In checked mode, verifies the type.
+ List<Function> Function(List<T> x0) l160;
+ // The static function f160 sets `T` to `int`.
+ if (!tIsBool) {
+ x160 = f160 as dynamic;
+ l160 = f160 as dynamic;
+ x160 = confuse(f160);
+ l160 = confuse(f160);
+ }
+
+ Expect.isTrue(m160 is F160);
+ Expect.isTrue(m160 is List<Function> Function(List<T> x0));
+ Expect.isTrue(confuse(m160) is F160);
+ // In checked mode, verifies the type.
+ x160 = m160;
+ l160 = m160;
+ x160 = confuse(m160);
+ l160 = confuse(m160);
+ if (!tIsBool) {
+ Expect.isTrue(f160 is F160<int>);
+ Expect.isFalse(f160 is F160<bool>);
+ Expect.isTrue(confuse(f160) is F160<int>);
+ Expect.isFalse(confuse(f160) is F160<bool>);
+ Expect.equals(tIsDynamic, m160 is F160<bool>);
+ Expect.equals(tIsDynamic, confuse(m160) is F160<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x160 = (f160 as dynamic); });
+ Expect.throws(() { x160 = confuse(f160); });
+ List<Function> Function(List<T> x0) l160;
+ Expect.throws(() { l160 = (f160 as dynamic); });
+ Expect.throws(() { l160 = confuse(f160); });
+ }
+ List<Function> Function(List<T> x0) l160 = m160;
+ // In checked mode, verifies the type.
+ x160 = m160;
+ x160 = confuse(m160);
+ }
+ }
+
+ void testF260() {
+ // List<T> Function(int y, [core.List<core.int> x])
+ Expect.isTrue(f260 is F260);
+ Expect.isTrue(confuse(f260) is F260);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [core.List<core.int> x]) l260;
+ // The static function f260 sets `T` to `int`.
+ if (!tIsBool) {
+ x260 = f260 as dynamic;
+ l260 = f260 as dynamic;
+ x260 = confuse(f260);
+ l260 = confuse(f260);
+ }
+
+ Expect.isTrue(m260 is F260);
+ Expect.isTrue(m260 is List<T> Function(int y, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m260) is F260);
+ // In checked mode, verifies the type.
+ x260 = m260;
+ l260 = m260;
+ x260 = confuse(m260);
+ l260 = confuse(m260);
+ if (!tIsBool) {
+ Expect.isTrue(f260 is F260<int>);
+ Expect.isFalse(f260 is F260<bool>);
+ Expect.isTrue(confuse(f260) is F260<int>);
+ Expect.isFalse(confuse(f260) is F260<bool>);
+ Expect.equals(tIsDynamic, m260 is F260<bool>);
+ Expect.equals(tIsDynamic, confuse(m260) is F260<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x260 = (f260 as dynamic); });
+ Expect.throws(() { x260 = confuse(f260); });
+ List<T> Function(int y, [core.List<core.int> x]) l260;
+ Expect.throws(() { l260 = (f260 as dynamic); });
+ Expect.throws(() { l260 = confuse(f260); });
+ }
+ List<T> Function(int y, [core.List<core.int> x]) l260 = m260;
+ // In checked mode, verifies the type.
+ x260 = m260;
+ x260 = confuse(m260);
+ }
+ }
+
+ void testF360() {
+ // core.List<core.int> Function<A>(int x)
+ Expect.isTrue(f360 is F360);
+ Expect.isTrue(confuse(f360) is F360);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(int x) l360;
+ // The static function f360 sets `T` to `int`.
+ if (!tIsBool) {
+ x360 = f360 as dynamic;
+ l360 = f360 as dynamic;
+ x360 = confuse(f360);
+ l360 = confuse(f360);
+ }
+
+ Expect.isTrue(m360 is F360);
+ Expect.isTrue(m360 is core.List<core.int> Function<A>(int x));
+ Expect.isTrue(confuse(m360) is F360);
+ // In checked mode, verifies the type.
+ x360 = m360;
+ l360 = m360;
+ x360 = confuse(m360);
+ l360 = confuse(m360);
+
+ }
+
+ void testF460() {
+ // int Function(Function x0) Function()
+ Expect.isTrue(f460 is F460);
+ Expect.isTrue(confuse(f460) is F460);
+ // In checked mode, verifies the type.
+ int Function(Function x0) Function() l460;
+ // The static function f460 sets `T` to `int`.
+ if (!tIsBool) {
+ x460 = f460 as dynamic;
+ l460 = f460 as dynamic;
+ x460 = confuse(f460);
+ l460 = confuse(f460);
+ }
+
+ Expect.isTrue(m460 is F460);
+ Expect.isTrue(m460 is int Function(Function x0) Function());
+ Expect.isTrue(confuse(m460) is F460);
+ // In checked mode, verifies the type.
+ x460 = m460;
+ l460 = m460;
+ x460 = confuse(m460);
+ l460 = confuse(m460);
+
+ }
+
+ void testF560() {
+ // int Function(int x, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f560 is F560);
+ Expect.isTrue(confuse(f560) is F560);
+ // In checked mode, verifies the type.
+ int Function(int x, [core.List<core.int> x2]) Function() l560;
+ // The static function f560 sets `T` to `int`.
+ if (!tIsBool) {
+ x560 = f560 as dynamic;
+ l560 = f560 as dynamic;
+ x560 = confuse(f560);
+ l560 = confuse(f560);
+ }
+
+ Expect.isTrue(m560 is F560);
+ Expect.isTrue(m560 is int Function(int x, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m560) is F560);
+ // In checked mode, verifies the type.
+ x560 = m560;
+ l560 = m560;
+ x560 = confuse(m560);
+ l560 = confuse(m560);
+
+ }
+
+ void testF660() {
+ // Function Function(int x0, {int x}) Function()
+ Expect.isTrue(f660 is F660);
+ Expect.isTrue(confuse(f660) is F660);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {int x}) Function() l660;
+ // The static function f660 sets `T` to `int`.
+ if (!tIsBool) {
+ x660 = f660 as dynamic;
+ l660 = f660 as dynamic;
+ x660 = confuse(f660);
+ l660 = confuse(f660);
+ }
+
+ Expect.isTrue(m660 is F660);
+ Expect.isTrue(m660 is Function Function(int x0, {int x}) Function());
+ Expect.isTrue(confuse(m660) is F660);
+ // In checked mode, verifies the type.
+ x660 = m660;
+ l660 = m660;
+ x660 = confuse(m660);
+ l660 = confuse(m660);
+
+ }
+
+ void testF760() {
+ // Function Function([core.List<core.int> x]) Function()
+ Expect.isTrue(f760 is F760);
+ Expect.isTrue(confuse(f760) is F760);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x]) Function() l760;
+ // The static function f760 sets `T` to `int`.
+ if (!tIsBool) {
+ x760 = f760 as dynamic;
+ l760 = f760 as dynamic;
+ x760 = confuse(f760);
+ l760 = confuse(f760);
+ }
+
+ Expect.isTrue(m760 is F760);
+ Expect.isTrue(m760 is Function Function([core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m760) is F760);
+ // In checked mode, verifies the type.
+ x760 = m760;
+ l760 = m760;
+ x760 = confuse(m760);
+ l760 = confuse(m760);
+
+ }
+
+ void testF860() {
+ // List<Function> Function(int y, [int x]) Function()
+ Expect.isTrue(f860 is F860);
+ Expect.isTrue(confuse(f860) is F860);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [int x]) Function() l860;
+ // The static function f860 sets `T` to `int`.
+ if (!tIsBool) {
+ x860 = f860 as dynamic;
+ l860 = f860 as dynamic;
+ x860 = confuse(f860);
+ l860 = confuse(f860);
+ }
+
+ Expect.isTrue(m860 is F860);
+ Expect.isTrue(m860 is List<Function> Function(int y, [int x]) Function());
+ Expect.isTrue(confuse(m860) is F860);
+ // In checked mode, verifies the type.
+ x860 = m860;
+ l860 = m860;
+ x860 = confuse(m860);
+ l860 = confuse(m860);
+
+ }
+
+ void testF960() {
+ // List<Function> Function(int x1, [List<Function> x2]) Function()
+ Expect.isTrue(f960 is F960);
+ Expect.isTrue(confuse(f960) is F960);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<Function> x2]) Function() l960;
+ // The static function f960 sets `T` to `int`.
+ if (!tIsBool) {
+ x960 = f960 as dynamic;
+ l960 = f960 as dynamic;
+ x960 = confuse(f960);
+ l960 = confuse(f960);
+ }
+
+ Expect.isTrue(m960 is F960);
+ Expect.isTrue(m960 is List<Function> Function(int x1, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m960) is F960);
+ // In checked mode, verifies the type.
+ x960 = m960;
+ l960 = m960;
+ x960 = confuse(m960);
+ l960 = confuse(m960);
+
+ }
+
+ void testF1060() {
+ // List<Function> Function(int x0, {List<T> x}) Function()
+ Expect.isTrue(f1060 is F1060);
+ Expect.isTrue(confuse(f1060) is F1060);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {List<T> x}) Function() l1060;
+ // The static function f1060 sets `T` to `int`.
+ if (!tIsBool) {
+ x1060 = f1060 as dynamic;
+ l1060 = f1060 as dynamic;
+ x1060 = confuse(f1060);
+ l1060 = confuse(f1060);
+ }
+
+ Expect.isTrue(m1060 is F1060);
+ Expect.isTrue(m1060 is List<Function> Function(int x0, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1060) is F1060);
+ // In checked mode, verifies the type.
+ x1060 = m1060;
+ l1060 = m1060;
+ x1060 = confuse(m1060);
+ l1060 = confuse(m1060);
+ if (!tIsBool) {
+ Expect.isTrue(f1060 is F1060<int>);
+ Expect.isFalse(f1060 is F1060<bool>);
+ Expect.isTrue(confuse(f1060) is F1060<int>);
+ Expect.isFalse(confuse(f1060) is F1060<bool>);
+ Expect.equals(tIsDynamic, m1060 is F1060<bool>);
+ Expect.equals(tIsDynamic, confuse(m1060) is F1060<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1060 = (f1060 as dynamic); });
+ Expect.throws(() { x1060 = confuse(f1060); });
+ List<Function> Function(int x0, {List<T> x}) Function() l1060;
+ Expect.throws(() { l1060 = (f1060 as dynamic); });
+ Expect.throws(() { l1060 = confuse(f1060); });
+ }
+ List<Function> Function(int x0, {List<T> x}) Function() l1060 = m1060;
+ // In checked mode, verifies the type.
+ x1060 = m1060;
+ x1060 = confuse(m1060);
+ }
+ }
+
+ void testF1160() {
+ // core.List<core.int> Function(List<Function> x) Function()
+ Expect.isTrue(f1160 is F1160);
+ Expect.isTrue(confuse(f1160) is F1160);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x) Function() l1160;
+ // The static function f1160 sets `T` to `int`.
+ if (!tIsBool) {
+ x1160 = f1160 as dynamic;
+ l1160 = f1160 as dynamic;
+ x1160 = confuse(f1160);
+ l1160 = confuse(f1160);
+ }
+
+ Expect.isTrue(m1160 is F1160);
+ Expect.isTrue(m1160 is core.List<core.int> Function(List<Function> x) Function());
+ Expect.isTrue(confuse(m1160) is F1160);
+ // In checked mode, verifies the type.
+ x1160 = m1160;
+ l1160 = m1160;
+ x1160 = confuse(m1160);
+ l1160 = confuse(m1160);
+
+ }
+
+ void testF1260() {
+ // core.List<core.int> Function(int y, [List<T> x]) Function()
+ Expect.isTrue(f1260 is F1260);
+ Expect.isTrue(confuse(f1260) is F1260);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<T> x]) Function() l1260;
+ // The static function f1260 sets `T` to `int`.
+ if (!tIsBool) {
+ x1260 = f1260 as dynamic;
+ l1260 = f1260 as dynamic;
+ x1260 = confuse(f1260);
+ l1260 = confuse(f1260);
+ }
+
+ Expect.isTrue(m1260 is F1260);
+ Expect.isTrue(m1260 is core.List<core.int> Function(int y, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1260) is F1260);
+ // In checked mode, verifies the type.
+ x1260 = m1260;
+ l1260 = m1260;
+ x1260 = confuse(m1260);
+ l1260 = confuse(m1260);
+ if (!tIsBool) {
+ Expect.isTrue(f1260 is F1260<int>);
+ Expect.isFalse(f1260 is F1260<bool>);
+ Expect.isTrue(confuse(f1260) is F1260<int>);
+ Expect.isFalse(confuse(f1260) is F1260<bool>);
+ Expect.equals(tIsDynamic, m1260 is F1260<bool>);
+ Expect.equals(tIsDynamic, confuse(m1260) is F1260<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1260 = (f1260 as dynamic); });
+ Expect.throws(() { x1260 = confuse(f1260); });
+ core.List<core.int> Function(int y, [List<T> x]) Function() l1260;
+ Expect.throws(() { l1260 = (f1260 as dynamic); });
+ Expect.throws(() { l1260 = confuse(f1260); });
+ }
+ core.List<core.int> Function(int y, [List<T> x]) Function() l1260 = m1260;
+ // In checked mode, verifies the type.
+ x1260 = m1260;
+ x1260 = confuse(m1260);
+ }
+ }
+
+ void testF1360() {
+ // List<T> Function([Function x1]) Function()
+ Expect.isTrue(f1360 is F1360);
+ Expect.isTrue(confuse(f1360) is F1360);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x1]) Function() l1360;
+ // The static function f1360 sets `T` to `int`.
+ if (!tIsBool) {
+ x1360 = f1360 as dynamic;
+ l1360 = f1360 as dynamic;
+ x1360 = confuse(f1360);
+ l1360 = confuse(f1360);
+ }
+
+ Expect.isTrue(m1360 is F1360);
+ Expect.isTrue(m1360 is List<T> Function([Function x1]) Function());
+ Expect.isTrue(confuse(m1360) is F1360);
+ // In checked mode, verifies the type.
+ x1360 = m1360;
+ l1360 = m1360;
+ x1360 = confuse(m1360);
+ l1360 = confuse(m1360);
+ if (!tIsBool) {
+ Expect.isTrue(f1360 is F1360<int>);
+ Expect.isFalse(f1360 is F1360<bool>);
+ Expect.isTrue(confuse(f1360) is F1360<int>);
+ Expect.isFalse(confuse(f1360) is F1360<bool>);
+ Expect.equals(tIsDynamic, m1360 is F1360<bool>);
+ Expect.equals(tIsDynamic, confuse(m1360) is F1360<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1360 = (f1360 as dynamic); });
+ Expect.throws(() { x1360 = confuse(f1360); });
+ List<T> Function([Function x1]) Function() l1360;
+ Expect.throws(() { l1360 = (f1360 as dynamic); });
+ Expect.throws(() { l1360 = confuse(f1360); });
+ }
+ List<T> Function([Function x1]) Function() l1360 = m1360;
+ // In checked mode, verifies the type.
+ x1360 = m1360;
+ x1360 = confuse(m1360);
+ }
+ }
+
+ void testF1460() {
+ // List<T> Function({core.List<core.int> x}) Function()
+ Expect.isTrue(f1460 is F1460);
+ Expect.isTrue(confuse(f1460) is F1460);
+ // In checked mode, verifies the type.
+ List<T> Function({core.List<core.int> x}) Function() l1460;
+ // The static function f1460 sets `T` to `int`.
+ if (!tIsBool) {
+ x1460 = f1460 as dynamic;
+ l1460 = f1460 as dynamic;
+ x1460 = confuse(f1460);
+ l1460 = confuse(f1460);
+ }
+
+ Expect.isTrue(m1460 is F1460);
+ Expect.isTrue(m1460 is List<T> Function({core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1460) is F1460);
+ // In checked mode, verifies the type.
+ x1460 = m1460;
+ l1460 = m1460;
+ x1460 = confuse(m1460);
+ l1460 = confuse(m1460);
+ if (!tIsBool) {
+ Expect.isTrue(f1460 is F1460<int>);
+ Expect.isFalse(f1460 is F1460<bool>);
+ Expect.isTrue(confuse(f1460) is F1460<int>);
+ Expect.isFalse(confuse(f1460) is F1460<bool>);
+ Expect.equals(tIsDynamic, m1460 is F1460<bool>);
+ Expect.equals(tIsDynamic, confuse(m1460) is F1460<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1460 = (f1460 as dynamic); });
+ Expect.throws(() { x1460 = confuse(f1460); });
+ List<T> Function({core.List<core.int> x}) Function() l1460;
+ Expect.throws(() { l1460 = (f1460 as dynamic); });
+ Expect.throws(() { l1460 = confuse(f1460); });
+ }
+ List<T> Function({core.List<core.int> x}) Function() l1460 = m1460;
+ // In checked mode, verifies the type.
+ x1460 = m1460;
+ x1460 = confuse(m1460);
+ }
+ }
+
+ void testF1560() {
+ // Function(int y, {int x}) Function()
+ Expect.isTrue(f1560 is F1560);
+ Expect.isTrue(confuse(f1560) is F1560);
+ // In checked mode, verifies the type.
+ Function(int y, {int x}) Function() l1560;
+ // The static function f1560 sets `T` to `int`.
+ if (!tIsBool) {
+ x1560 = f1560 as dynamic;
+ l1560 = f1560 as dynamic;
+ x1560 = confuse(f1560);
+ l1560 = confuse(f1560);
+ }
+
+ Expect.isTrue(m1560 is F1560);
+ Expect.isTrue(m1560 is Function(int y, {int x}) Function());
+ Expect.isTrue(confuse(m1560) is F1560);
+ // In checked mode, verifies the type.
+ x1560 = m1560;
+ l1560 = m1560;
+ x1560 = confuse(m1560);
+ l1560 = confuse(m1560);
+
+ }
+
+ void testF1660() {
+ // Function(int x0, [core.List<core.int> x]) Function()
+ Expect.isTrue(f1660 is F1660);
+ Expect.isTrue(confuse(f1660) is F1660);
+ // In checked mode, verifies the type.
+ Function(int x0, [core.List<core.int> x]) Function() l1660;
+ // The static function f1660 sets `T` to `int`.
+ if (!tIsBool) {
+ x1660 = f1660 as dynamic;
+ l1660 = f1660 as dynamic;
+ x1660 = confuse(f1660);
+ l1660 = confuse(f1660);
+ }
+
+ Expect.isTrue(m1660 is F1660);
+ Expect.isTrue(m1660 is Function(int x0, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1660) is F1660);
+ // In checked mode, verifies the type.
+ x1660 = m1660;
+ l1660 = m1660;
+ x1660 = confuse(m1660);
+ l1660 = confuse(m1660);
+
+ }
+
+ void testF1760() {
+ // int Function<A>(List<T> x) Function()
+ Expect.isTrue(f1760 is F1760);
+ Expect.isTrue(confuse(f1760) is F1760);
+ // In checked mode, verifies the type.
+ int Function<A>(List<T> x) Function() l1760;
+ // The static function f1760 sets `T` to `int`.
+ if (!tIsBool) {
+ x1760 = f1760 as dynamic;
+ l1760 = f1760 as dynamic;
+ x1760 = confuse(f1760);
+ l1760 = confuse(f1760);
+ }
+
+ Expect.isTrue(m1760 is F1760);
+ Expect.isTrue(m1760 is int Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1760) is F1760);
+ // In checked mode, verifies the type.
+ x1760 = m1760;
+ l1760 = m1760;
+ x1760 = confuse(m1760);
+ l1760 = confuse(m1760);
+ if (!tIsBool) {
+ Expect.isTrue(f1760 is F1760<int>);
+ Expect.isFalse(f1760 is F1760<bool>);
+ Expect.isTrue(confuse(f1760) is F1760<int>);
+ Expect.isFalse(confuse(f1760) is F1760<bool>);
+ Expect.equals(tIsDynamic, m1760 is F1760<bool>);
+ Expect.equals(tIsDynamic, confuse(m1760) is F1760<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1760 = (f1760 as dynamic); });
+ Expect.throws(() { x1760 = confuse(f1760); });
+ int Function<A>(List<T> x) Function() l1760;
+ Expect.throws(() { l1760 = (f1760 as dynamic); });
+ Expect.throws(() { l1760 = confuse(f1760); });
+ }
+ int Function<A>(List<T> x) Function() l1760 = m1760;
+ // In checked mode, verifies the type.
+ x1760 = m1760;
+ x1760 = confuse(m1760);
+ }
+ }
+
+ void testF1860() {
+ // core.List<core.int> Function<A>() Function()
+ Expect.isTrue(f1860 is F1860);
+ Expect.isTrue(confuse(f1860) is F1860);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>() Function() l1860;
+ // The static function f1860 sets `T` to `int`.
+ if (!tIsBool) {
+ x1860 = f1860 as dynamic;
+ l1860 = f1860 as dynamic;
+ x1860 = confuse(f1860);
+ l1860 = confuse(f1860);
+ }
+
+ Expect.isTrue(m1860 is F1860);
+ Expect.isTrue(m1860 is core.List<core.int> Function<A>() Function());
+ Expect.isTrue(confuse(m1860) is F1860);
+ // In checked mode, verifies the type.
+ x1860 = m1860;
+ l1860 = m1860;
+ x1860 = confuse(m1860);
+ l1860 = confuse(m1860);
+
+ }
+
+ void testF1960() {
+ // A Function<A>(A x) Function()
+ Expect.isTrue(f1960 is F1960);
+ Expect.isTrue(confuse(f1960) is F1960);
+ // In checked mode, verifies the type.
+ A Function<A>(A x) Function() l1960;
+ // The static function f1960 sets `T` to `int`.
+ if (!tIsBool) {
+ x1960 = f1960 as dynamic;
+ l1960 = f1960 as dynamic;
+ x1960 = confuse(f1960);
+ l1960 = confuse(f1960);
+ }
+
+ Expect.isTrue(m1960 is F1960);
+ Expect.isTrue(m1960 is A Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1960) is F1960);
+ // In checked mode, verifies the type.
+ x1960 = m1960;
+ l1960 = m1960;
+ x1960 = confuse(m1960);
+ l1960 = confuse(m1960);
+
+ }
+
+
+}
+
+class C61<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([int x1]) x61;
+ List<Function> Function([List<T> x1]) x161;
+ List<T> Function(core.List<core.int> x0) x261;
+ core.List<core.int> Function<A>(Function x) x361;
+ int Function(Function x1) Function(int x) x461;
+ int Function(int x, [core.List<core.int> x1]) Function(int x) x561;
+ Function Function(int x1, {int x}) Function(int x) x661;
+ Function Function([core.List<core.int> x]) Function(int x) x761;
+ List<Function> Function(int y, [int x]) Function(int x) x861;
+ List<Function> Function(int x2, [List<Function> x3]) Function(int x) x961;
+ List<Function> Function(int x1, {List<T> x}) Function(int x) x1061;
+ core.List<core.int> Function(List<Function> x) Function(int x) x1161;
+ core.List<core.int> Function(int y, [List<T> x]) Function(int x) x1261;
+ List<T> Function([Function x1]) Function(int x) x1361;
+ List<T> Function({core.List<core.int> x}) Function(int x) x1461;
+ Function(int y, {int x}) Function(int x) x1561;
+ Function(int x1, [core.List<core.int> x]) Function(int x) x1661;
+ int Function<A>(List<T> x) Function(int x) x1761;
+ core.List<core.int> Function<A>() Function(int x) x1861;
+ A Function<A>(A x) Function(int x) x1961;
+
+
+ C61({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m61([int x0]) => null;
+ List<Function> m161([List<T> x0]) => null;
+ List<T> m261(core.List<core.int> x0) => null;
+ core.List<core.int> m361<A>(Function x) => null;
+ int Function(Function x0) m461(int x) => null;
+ int Function(int x, [core.List<core.int> x0]) m561(int x) => null;
+ Function Function(int x0, {int x}) m661(int x) => null;
+ Function Function([core.List<core.int> x]) m761(int x) => null;
+ List<Function> Function(int y, [int x]) m861(int x) => null;
+ List<Function> Function(int x0, [List<Function> x1]) m961(int x) => null;
+ List<Function> Function(int x0, {List<T> x}) m1061(int x) => null;
+ core.List<core.int> Function(List<Function> x) m1161(int x) => null;
+ core.List<core.int> Function(int y, [List<T> x]) m1261(int x) => null;
+ List<T> Function([Function x0]) m1361(int x) => null;
+ List<T> Function({core.List<core.int> x}) m1461(int x) => null;
+ Function(int y, {int x}) m1561(int x) => null;
+ Function(int x0, [core.List<core.int> x]) m1661(int x) => null;
+ int Function<A>(List<T> x) m1761(int x) => null;
+ core.List<core.int> Function<A>() m1861(int x) => null;
+ A Function<A>(A x) m1961(int x) => null;
+
+
+ runTests() {
+ testF61();
+ testF161();
+ testF261();
+ testF361();
+ testF461();
+ testF561();
+ testF661();
+ testF761();
+ testF861();
+ testF961();
+ testF1061();
+ testF1161();
+ testF1261();
+ testF1361();
+ testF1461();
+ testF1561();
+ testF1661();
+ testF1761();
+ testF1861();
+ testF1961();
+ }
+
+ void testF61() {
+ // Function Function([int x1])
+ Expect.isTrue(f61 is F61);
+ Expect.isTrue(confuse(f61) is F61);
+ // In checked mode, verifies the type.
+ Function Function([int x1]) l61;
+ // The static function f61 sets `T` to `int`.
+ if (!tIsBool) {
+ x61 = f61 as dynamic;
+ l61 = f61 as dynamic;
+ x61 = confuse(f61);
+ l61 = confuse(f61);
+ }
+
+ Expect.isTrue(m61 is F61);
+ Expect.isTrue(m61 is Function Function([int x1]));
+ Expect.isTrue(confuse(m61) is F61);
+ // In checked mode, verifies the type.
+ x61 = m61;
+ l61 = m61;
+ x61 = confuse(m61);
+ l61 = confuse(m61);
+
+ }
+
+ void testF161() {
+ // List<Function> Function([List<T> x1])
+ Expect.isTrue(f161 is F161);
+ Expect.isTrue(confuse(f161) is F161);
+ // In checked mode, verifies the type.
+ List<Function> Function([List<T> x1]) l161;
+ // The static function f161 sets `T` to `int`.
+ if (!tIsBool) {
+ x161 = f161 as dynamic;
+ l161 = f161 as dynamic;
+ x161 = confuse(f161);
+ l161 = confuse(f161);
+ }
+
+ Expect.isTrue(m161 is F161);
+ Expect.isTrue(m161 is List<Function> Function([List<T> x1]));
+ Expect.isTrue(confuse(m161) is F161);
+ // In checked mode, verifies the type.
+ x161 = m161;
+ l161 = m161;
+ x161 = confuse(m161);
+ l161 = confuse(m161);
+ if (!tIsBool) {
+ Expect.isTrue(f161 is F161<int>);
+ Expect.isFalse(f161 is F161<bool>);
+ Expect.isTrue(confuse(f161) is F161<int>);
+ Expect.isFalse(confuse(f161) is F161<bool>);
+ Expect.equals(tIsDynamic, m161 is F161<bool>);
+ Expect.equals(tIsDynamic, confuse(m161) is F161<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x161 = (f161 as dynamic); });
+ Expect.throws(() { x161 = confuse(f161); });
+ List<Function> Function([List<T> x1]) l161;
+ Expect.throws(() { l161 = (f161 as dynamic); });
+ Expect.throws(() { l161 = confuse(f161); });
+ }
+ List<Function> Function([List<T> x1]) l161 = m161;
+ // In checked mode, verifies the type.
+ x161 = m161;
+ x161 = confuse(m161);
+ }
+ }
+
+ void testF261() {
+ // List<T> Function(core.List<core.int> x0)
+ Expect.isTrue(f261 is F261);
+ Expect.isTrue(confuse(f261) is F261);
+ // In checked mode, verifies the type.
+ List<T> Function(core.List<core.int> x0) l261;
+ // The static function f261 sets `T` to `int`.
+ if (!tIsBool) {
+ x261 = f261 as dynamic;
+ l261 = f261 as dynamic;
+ x261 = confuse(f261);
+ l261 = confuse(f261);
+ }
+
+ Expect.isTrue(m261 is F261);
+ Expect.isTrue(m261 is List<T> Function(core.List<core.int> x0));
+ Expect.isTrue(confuse(m261) is F261);
+ // In checked mode, verifies the type.
+ x261 = m261;
+ l261 = m261;
+ x261 = confuse(m261);
+ l261 = confuse(m261);
+ if (!tIsBool) {
+ Expect.isTrue(f261 is F261<int>);
+ Expect.isFalse(f261 is F261<bool>);
+ Expect.isTrue(confuse(f261) is F261<int>);
+ Expect.isFalse(confuse(f261) is F261<bool>);
+ Expect.equals(tIsDynamic, m261 is F261<bool>);
+ Expect.equals(tIsDynamic, confuse(m261) is F261<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x261 = (f261 as dynamic); });
+ Expect.throws(() { x261 = confuse(f261); });
+ List<T> Function(core.List<core.int> x0) l261;
+ Expect.throws(() { l261 = (f261 as dynamic); });
+ Expect.throws(() { l261 = confuse(f261); });
+ }
+ List<T> Function(core.List<core.int> x0) l261 = m261;
+ // In checked mode, verifies the type.
+ x261 = m261;
+ x261 = confuse(m261);
+ }
+ }
+
+ void testF361() {
+ // core.List<core.int> Function<A>(Function x)
+ Expect.isTrue(f361 is F361);
+ Expect.isTrue(confuse(f361) is F361);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(Function x) l361;
+ // The static function f361 sets `T` to `int`.
+ if (!tIsBool) {
+ x361 = f361 as dynamic;
+ l361 = f361 as dynamic;
+ x361 = confuse(f361);
+ l361 = confuse(f361);
+ }
+
+ Expect.isTrue(m361 is F361);
+ Expect.isTrue(m361 is core.List<core.int> Function<A>(Function x));
+ Expect.isTrue(confuse(m361) is F361);
+ // In checked mode, verifies the type.
+ x361 = m361;
+ l361 = m361;
+ x361 = confuse(m361);
+ l361 = confuse(m361);
+
+ }
+
+ void testF461() {
+ // int Function(Function x1) Function(int x)
+ Expect.isTrue(f461 is F461);
+ Expect.isTrue(confuse(f461) is F461);
+ // In checked mode, verifies the type.
+ int Function(Function x1) Function(int x) l461;
+ // The static function f461 sets `T` to `int`.
+ if (!tIsBool) {
+ x461 = f461 as dynamic;
+ l461 = f461 as dynamic;
+ x461 = confuse(f461);
+ l461 = confuse(f461);
+ }
+
+ Expect.isTrue(m461 is F461);
+ Expect.isTrue(m461 is int Function(Function x1) Function(int x));
+ Expect.isTrue(confuse(m461) is F461);
+ // In checked mode, verifies the type.
+ x461 = m461;
+ l461 = m461;
+ x461 = confuse(m461);
+ l461 = confuse(m461);
+
+ }
+
+ void testF561() {
+ // int Function(int x, [core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f561 is F561);
+ Expect.isTrue(confuse(f561) is F561);
+ // In checked mode, verifies the type.
+ int Function(int x, [core.List<core.int> x1]) Function(int x) l561;
+ // The static function f561 sets `T` to `int`.
+ if (!tIsBool) {
+ x561 = f561 as dynamic;
+ l561 = f561 as dynamic;
+ x561 = confuse(f561);
+ l561 = confuse(f561);
+ }
+
+ Expect.isTrue(m561 is F561);
+ Expect.isTrue(m561 is int Function(int x, [core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m561) is F561);
+ // In checked mode, verifies the type.
+ x561 = m561;
+ l561 = m561;
+ x561 = confuse(m561);
+ l561 = confuse(m561);
+
+ }
+
+ void testF661() {
+ // Function Function(int x1, {int x}) Function(int x)
+ Expect.isTrue(f661 is F661);
+ Expect.isTrue(confuse(f661) is F661);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {int x}) Function(int x) l661;
+ // The static function f661 sets `T` to `int`.
+ if (!tIsBool) {
+ x661 = f661 as dynamic;
+ l661 = f661 as dynamic;
+ x661 = confuse(f661);
+ l661 = confuse(f661);
+ }
+
+ Expect.isTrue(m661 is F661);
+ Expect.isTrue(m661 is Function Function(int x1, {int x}) Function(int x));
+ Expect.isTrue(confuse(m661) is F661);
+ // In checked mode, verifies the type.
+ x661 = m661;
+ l661 = m661;
+ x661 = confuse(m661);
+ l661 = confuse(m661);
+
+ }
+
+ void testF761() {
+ // Function Function([core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f761 is F761);
+ Expect.isTrue(confuse(f761) is F761);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x]) Function(int x) l761;
+ // The static function f761 sets `T` to `int`.
+ if (!tIsBool) {
+ x761 = f761 as dynamic;
+ l761 = f761 as dynamic;
+ x761 = confuse(f761);
+ l761 = confuse(f761);
+ }
+
+ Expect.isTrue(m761 is F761);
+ Expect.isTrue(m761 is Function Function([core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m761) is F761);
+ // In checked mode, verifies the type.
+ x761 = m761;
+ l761 = m761;
+ x761 = confuse(m761);
+ l761 = confuse(m761);
+
+ }
+
+ void testF861() {
+ // List<Function> Function(int y, [int x]) Function(int x)
+ Expect.isTrue(f861 is F861);
+ Expect.isTrue(confuse(f861) is F861);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [int x]) Function(int x) l861;
+ // The static function f861 sets `T` to `int`.
+ if (!tIsBool) {
+ x861 = f861 as dynamic;
+ l861 = f861 as dynamic;
+ x861 = confuse(f861);
+ l861 = confuse(f861);
+ }
+
+ Expect.isTrue(m861 is F861);
+ Expect.isTrue(m861 is List<Function> Function(int y, [int x]) Function(int x));
+ Expect.isTrue(confuse(m861) is F861);
+ // In checked mode, verifies the type.
+ x861 = m861;
+ l861 = m861;
+ x861 = confuse(m861);
+ l861 = confuse(m861);
+
+ }
+
+ void testF961() {
+ // List<Function> Function(int x2, [List<Function> x3]) Function(int x)
+ Expect.isTrue(f961 is F961);
+ Expect.isTrue(confuse(f961) is F961);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [List<Function> x3]) Function(int x) l961;
+ // The static function f961 sets `T` to `int`.
+ if (!tIsBool) {
+ x961 = f961 as dynamic;
+ l961 = f961 as dynamic;
+ x961 = confuse(f961);
+ l961 = confuse(f961);
+ }
+
+ Expect.isTrue(m961 is F961);
+ Expect.isTrue(m961 is List<Function> Function(int x2, [List<Function> x3]) Function(int x));
+ Expect.isTrue(confuse(m961) is F961);
+ // In checked mode, verifies the type.
+ x961 = m961;
+ l961 = m961;
+ x961 = confuse(m961);
+ l961 = confuse(m961);
+
+ }
+
+ void testF1061() {
+ // List<Function> Function(int x1, {List<T> x}) Function(int x)
+ Expect.isTrue(f1061 is F1061);
+ Expect.isTrue(confuse(f1061) is F1061);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {List<T> x}) Function(int x) l1061;
+ // The static function f1061 sets `T` to `int`.
+ if (!tIsBool) {
+ x1061 = f1061 as dynamic;
+ l1061 = f1061 as dynamic;
+ x1061 = confuse(f1061);
+ l1061 = confuse(f1061);
+ }
+
+ Expect.isTrue(m1061 is F1061);
+ Expect.isTrue(m1061 is List<Function> Function(int x1, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1061) is F1061);
+ // In checked mode, verifies the type.
+ x1061 = m1061;
+ l1061 = m1061;
+ x1061 = confuse(m1061);
+ l1061 = confuse(m1061);
+ if (!tIsBool) {
+ Expect.isTrue(f1061 is F1061<int>);
+ Expect.isFalse(f1061 is F1061<bool>);
+ Expect.isTrue(confuse(f1061) is F1061<int>);
+ Expect.isFalse(confuse(f1061) is F1061<bool>);
+ Expect.equals(tIsDynamic, m1061 is F1061<bool>);
+ Expect.equals(tIsDynamic, confuse(m1061) is F1061<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1061 = (f1061 as dynamic); });
+ Expect.throws(() { x1061 = confuse(f1061); });
+ List<Function> Function(int x1, {List<T> x}) Function(int x) l1061;
+ Expect.throws(() { l1061 = (f1061 as dynamic); });
+ Expect.throws(() { l1061 = confuse(f1061); });
+ }
+ List<Function> Function(int x1, {List<T> x}) Function(int x) l1061 = m1061;
+ // In checked mode, verifies the type.
+ x1061 = m1061;
+ x1061 = confuse(m1061);
+ }
+ }
+
+ void testF1161() {
+ // core.List<core.int> Function(List<Function> x) Function(int x)
+ Expect.isTrue(f1161 is F1161);
+ Expect.isTrue(confuse(f1161) is F1161);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x) Function(int x) l1161;
+ // The static function f1161 sets `T` to `int`.
+ if (!tIsBool) {
+ x1161 = f1161 as dynamic;
+ l1161 = f1161 as dynamic;
+ x1161 = confuse(f1161);
+ l1161 = confuse(f1161);
+ }
+
+ Expect.isTrue(m1161 is F1161);
+ Expect.isTrue(m1161 is core.List<core.int> Function(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1161) is F1161);
+ // In checked mode, verifies the type.
+ x1161 = m1161;
+ l1161 = m1161;
+ x1161 = confuse(m1161);
+ l1161 = confuse(m1161);
+
+ }
+
+ void testF1261() {
+ // core.List<core.int> Function(int y, [List<T> x]) Function(int x)
+ Expect.isTrue(f1261 is F1261);
+ Expect.isTrue(confuse(f1261) is F1261);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<T> x]) Function(int x) l1261;
+ // The static function f1261 sets `T` to `int`.
+ if (!tIsBool) {
+ x1261 = f1261 as dynamic;
+ l1261 = f1261 as dynamic;
+ x1261 = confuse(f1261);
+ l1261 = confuse(f1261);
+ }
+
+ Expect.isTrue(m1261 is F1261);
+ Expect.isTrue(m1261 is core.List<core.int> Function(int y, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1261) is F1261);
+ // In checked mode, verifies the type.
+ x1261 = m1261;
+ l1261 = m1261;
+ x1261 = confuse(m1261);
+ l1261 = confuse(m1261);
+ if (!tIsBool) {
+ Expect.isTrue(f1261 is F1261<int>);
+ Expect.isFalse(f1261 is F1261<bool>);
+ Expect.isTrue(confuse(f1261) is F1261<int>);
+ Expect.isFalse(confuse(f1261) is F1261<bool>);
+ Expect.equals(tIsDynamic, m1261 is F1261<bool>);
+ Expect.equals(tIsDynamic, confuse(m1261) is F1261<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1261 = (f1261 as dynamic); });
+ Expect.throws(() { x1261 = confuse(f1261); });
+ core.List<core.int> Function(int y, [List<T> x]) Function(int x) l1261;
+ Expect.throws(() { l1261 = (f1261 as dynamic); });
+ Expect.throws(() { l1261 = confuse(f1261); });
+ }
+ core.List<core.int> Function(int y, [List<T> x]) Function(int x) l1261 = m1261;
+ // In checked mode, verifies the type.
+ x1261 = m1261;
+ x1261 = confuse(m1261);
+ }
+ }
+
+ void testF1361() {
+ // List<T> Function([Function x1]) Function(int x)
+ Expect.isTrue(f1361 is F1361);
+ Expect.isTrue(confuse(f1361) is F1361);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x1]) Function(int x) l1361;
+ // The static function f1361 sets `T` to `int`.
+ if (!tIsBool) {
+ x1361 = f1361 as dynamic;
+ l1361 = f1361 as dynamic;
+ x1361 = confuse(f1361);
+ l1361 = confuse(f1361);
+ }
+
+ Expect.isTrue(m1361 is F1361);
+ Expect.isTrue(m1361 is List<T> Function([Function x1]) Function(int x));
+ Expect.isTrue(confuse(m1361) is F1361);
+ // In checked mode, verifies the type.
+ x1361 = m1361;
+ l1361 = m1361;
+ x1361 = confuse(m1361);
+ l1361 = confuse(m1361);
+ if (!tIsBool) {
+ Expect.isTrue(f1361 is F1361<int>);
+ Expect.isFalse(f1361 is F1361<bool>);
+ Expect.isTrue(confuse(f1361) is F1361<int>);
+ Expect.isFalse(confuse(f1361) is F1361<bool>);
+ Expect.equals(tIsDynamic, m1361 is F1361<bool>);
+ Expect.equals(tIsDynamic, confuse(m1361) is F1361<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1361 = (f1361 as dynamic); });
+ Expect.throws(() { x1361 = confuse(f1361); });
+ List<T> Function([Function x1]) Function(int x) l1361;
+ Expect.throws(() { l1361 = (f1361 as dynamic); });
+ Expect.throws(() { l1361 = confuse(f1361); });
+ }
+ List<T> Function([Function x1]) Function(int x) l1361 = m1361;
+ // In checked mode, verifies the type.
+ x1361 = m1361;
+ x1361 = confuse(m1361);
+ }
+ }
+
+ void testF1461() {
+ // List<T> Function({core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1461 is F1461);
+ Expect.isTrue(confuse(f1461) is F1461);
+ // In checked mode, verifies the type.
+ List<T> Function({core.List<core.int> x}) Function(int x) l1461;
+ // The static function f1461 sets `T` to `int`.
+ if (!tIsBool) {
+ x1461 = f1461 as dynamic;
+ l1461 = f1461 as dynamic;
+ x1461 = confuse(f1461);
+ l1461 = confuse(f1461);
+ }
+
+ Expect.isTrue(m1461 is F1461);
+ Expect.isTrue(m1461 is List<T> Function({core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1461) is F1461);
+ // In checked mode, verifies the type.
+ x1461 = m1461;
+ l1461 = m1461;
+ x1461 = confuse(m1461);
+ l1461 = confuse(m1461);
+ if (!tIsBool) {
+ Expect.isTrue(f1461 is F1461<int>);
+ Expect.isFalse(f1461 is F1461<bool>);
+ Expect.isTrue(confuse(f1461) is F1461<int>);
+ Expect.isFalse(confuse(f1461) is F1461<bool>);
+ Expect.equals(tIsDynamic, m1461 is F1461<bool>);
+ Expect.equals(tIsDynamic, confuse(m1461) is F1461<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1461 = (f1461 as dynamic); });
+ Expect.throws(() { x1461 = confuse(f1461); });
+ List<T> Function({core.List<core.int> x}) Function(int x) l1461;
+ Expect.throws(() { l1461 = (f1461 as dynamic); });
+ Expect.throws(() { l1461 = confuse(f1461); });
+ }
+ List<T> Function({core.List<core.int> x}) Function(int x) l1461 = m1461;
+ // In checked mode, verifies the type.
+ x1461 = m1461;
+ x1461 = confuse(m1461);
+ }
+ }
+
+ void testF1561() {
+ // Function(int y, {int x}) Function(int x)
+ Expect.isTrue(f1561 is F1561);
+ Expect.isTrue(confuse(f1561) is F1561);
+ // In checked mode, verifies the type.
+ Function(int y, {int x}) Function(int x) l1561;
+ // The static function f1561 sets `T` to `int`.
+ if (!tIsBool) {
+ x1561 = f1561 as dynamic;
+ l1561 = f1561 as dynamic;
+ x1561 = confuse(f1561);
+ l1561 = confuse(f1561);
+ }
+
+ Expect.isTrue(m1561 is F1561);
+ Expect.isTrue(m1561 is Function(int y, {int x}) Function(int x));
+ Expect.isTrue(confuse(m1561) is F1561);
+ // In checked mode, verifies the type.
+ x1561 = m1561;
+ l1561 = m1561;
+ x1561 = confuse(m1561);
+ l1561 = confuse(m1561);
+
+ }
+
+ void testF1661() {
+ // Function(int x1, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1661 is F1661);
+ Expect.isTrue(confuse(f1661) is F1661);
+ // In checked mode, verifies the type.
+ Function(int x1, [core.List<core.int> x]) Function(int x) l1661;
+ // The static function f1661 sets `T` to `int`.
+ if (!tIsBool) {
+ x1661 = f1661 as dynamic;
+ l1661 = f1661 as dynamic;
+ x1661 = confuse(f1661);
+ l1661 = confuse(f1661);
+ }
+
+ Expect.isTrue(m1661 is F1661);
+ Expect.isTrue(m1661 is Function(int x1, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1661) is F1661);
+ // In checked mode, verifies the type.
+ x1661 = m1661;
+ l1661 = m1661;
+ x1661 = confuse(m1661);
+ l1661 = confuse(m1661);
+
+ }
+
+ void testF1761() {
+ // int Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1761 is F1761);
+ Expect.isTrue(confuse(f1761) is F1761);
+ // In checked mode, verifies the type.
+ int Function<A>(List<T> x) Function(int x) l1761;
+ // The static function f1761 sets `T` to `int`.
+ if (!tIsBool) {
+ x1761 = f1761 as dynamic;
+ l1761 = f1761 as dynamic;
+ x1761 = confuse(f1761);
+ l1761 = confuse(f1761);
+ }
+
+ Expect.isTrue(m1761 is F1761);
+ Expect.isTrue(m1761 is int Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1761) is F1761);
+ // In checked mode, verifies the type.
+ x1761 = m1761;
+ l1761 = m1761;
+ x1761 = confuse(m1761);
+ l1761 = confuse(m1761);
+ if (!tIsBool) {
+ Expect.isTrue(f1761 is F1761<int>);
+ Expect.isFalse(f1761 is F1761<bool>);
+ Expect.isTrue(confuse(f1761) is F1761<int>);
+ Expect.isFalse(confuse(f1761) is F1761<bool>);
+ Expect.equals(tIsDynamic, m1761 is F1761<bool>);
+ Expect.equals(tIsDynamic, confuse(m1761) is F1761<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1761 = (f1761 as dynamic); });
+ Expect.throws(() { x1761 = confuse(f1761); });
+ int Function<A>(List<T> x) Function(int x) l1761;
+ Expect.throws(() { l1761 = (f1761 as dynamic); });
+ Expect.throws(() { l1761 = confuse(f1761); });
+ }
+ int Function<A>(List<T> x) Function(int x) l1761 = m1761;
+ // In checked mode, verifies the type.
+ x1761 = m1761;
+ x1761 = confuse(m1761);
+ }
+ }
+
+ void testF1861() {
+ // core.List<core.int> Function<A>() Function(int x)
+ Expect.isTrue(f1861 is F1861);
+ Expect.isTrue(confuse(f1861) is F1861);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>() Function(int x) l1861;
+ // The static function f1861 sets `T` to `int`.
+ if (!tIsBool) {
+ x1861 = f1861 as dynamic;
+ l1861 = f1861 as dynamic;
+ x1861 = confuse(f1861);
+ l1861 = confuse(f1861);
+ }
+
+ Expect.isTrue(m1861 is F1861);
+ Expect.isTrue(m1861 is core.List<core.int> Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1861) is F1861);
+ // In checked mode, verifies the type.
+ x1861 = m1861;
+ l1861 = m1861;
+ x1861 = confuse(m1861);
+ l1861 = confuse(m1861);
+
+ }
+
+ void testF1961() {
+ // A Function<A>(A x) Function(int x)
+ Expect.isTrue(f1961 is F1961);
+ Expect.isTrue(confuse(f1961) is F1961);
+ // In checked mode, verifies the type.
+ A Function<A>(A x) Function(int x) l1961;
+ // The static function f1961 sets `T` to `int`.
+ if (!tIsBool) {
+ x1961 = f1961 as dynamic;
+ l1961 = f1961 as dynamic;
+ x1961 = confuse(f1961);
+ l1961 = confuse(f1961);
+ }
+
+ Expect.isTrue(m1961 is F1961);
+ Expect.isTrue(m1961 is A Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1961) is F1961);
+ // In checked mode, verifies the type.
+ x1961 = m1961;
+ l1961 = m1961;
+ x1961 = confuse(m1961);
+ l1961 = confuse(m1961);
+
+ }
+
+
+}
+
+class C62<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x1, [int x2]) x62;
+ List<Function> Function(int x1, [List<T> x2]) x162;
+ List<T> Function([core.List<core.int> x1]) x262;
+ core.List<core.int> Function<A>(List<Function> x) x362;
+ int Function(Function x1) Function<B extends core.int>() x462;
+ int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() x562;
+ Function Function(int x1, {int x}) Function<B extends core.int>() x662;
+ Function Function([core.List<core.int> x]) Function<B extends core.int>() x762;
+ List<Function> Function(int y, [int x]) Function<B extends core.int>() x862;
+ List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>() x962;
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>() x1062;
+ core.List<core.int> Function(List<Function> x) Function<B extends core.int>() x1162;
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>() x1262;
+ List<T> Function([Function x1]) Function<B extends core.int>() x1362;
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>() x1462;
+ Function(int y, {int x}) Function<B extends core.int>() x1562;
+ Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() x1662;
+ int Function<A>(List<T> x) Function<B extends core.int>() x1762;
+ core.List<core.int> Function<A>() Function<B extends core.int>() x1862;
+ A Function<A>(A x) Function<B extends core.int>() x1962;
+
+
+ C62({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m62(int x0, [int x1]) => null;
+ List<Function> m162(int x0, [List<T> x1]) => null;
+ List<T> m262([core.List<core.int> x0]) => null;
+ core.List<core.int> m362<A>(List<Function> x) => null;
+ int Function(Function x0) m462<B extends core.int>() => null;
+ int Function(int x, [core.List<core.int> x0]) m562<B extends core.int>() => null;
+ Function Function(int x0, {int x}) m662<B extends core.int>() => null;
+ Function Function([core.List<core.int> x]) m762<B extends core.int>() => null;
+ List<Function> Function(int y, [int x]) m862<B extends core.int>() => null;
+ List<Function> Function(int x0, [List<Function> x1]) m962<B extends core.int>() => null;
+ List<Function> Function(int x0, {List<T> x}) m1062<B extends core.int>() => null;
+ core.List<core.int> Function(List<Function> x) m1162<B extends core.int>() => null;
+ core.List<core.int> Function(int y, [List<T> x]) m1262<B extends core.int>() => null;
+ List<T> Function([Function x0]) m1362<B extends core.int>() => null;
+ List<T> Function({core.List<core.int> x}) m1462<B extends core.int>() => null;
+ Function(int y, {int x}) m1562<B extends core.int>() => null;
+ Function(int x0, [core.List<core.int> x]) m1662<B extends core.int>() => null;
+ int Function<A>(List<T> x) m1762<B extends core.int>() => null;
+ core.List<core.int> Function<A>() m1862<B extends core.int>() => null;
+ A Function<A>(A x) m1962<B extends core.int>() => null;
+
+
+ runTests() {
+ testF62();
+ testF162();
+ testF262();
+ testF362();
+ testF462();
+ testF562();
+ testF662();
+ testF762();
+ testF862();
+ testF962();
+ testF1062();
+ testF1162();
+ testF1262();
+ testF1362();
+ testF1462();
+ testF1562();
+ testF1662();
+ testF1762();
+ testF1862();
+ testF1962();
+ }
+
+ void testF62() {
+ // Function Function(int x1, [int x2])
+ Expect.isTrue(f62 is F62);
+ Expect.isTrue(confuse(f62) is F62);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [int x2]) l62;
+ // The static function f62 sets `T` to `int`.
+ if (!tIsBool) {
+ x62 = f62 as dynamic;
+ l62 = f62 as dynamic;
+ x62 = confuse(f62);
+ l62 = confuse(f62);
+ }
+
+ Expect.isTrue(m62 is F62);
+ Expect.isTrue(m62 is Function Function(int x1, [int x2]));
+ Expect.isTrue(confuse(m62) is F62);
+ // In checked mode, verifies the type.
+ x62 = m62;
+ l62 = m62;
+ x62 = confuse(m62);
+ l62 = confuse(m62);
+
+ }
+
+ void testF162() {
+ // List<Function> Function(int x1, [List<T> x2])
+ Expect.isTrue(f162 is F162);
+ Expect.isTrue(confuse(f162) is F162);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [List<T> x2]) l162;
+ // The static function f162 sets `T` to `int`.
+ if (!tIsBool) {
+ x162 = f162 as dynamic;
+ l162 = f162 as dynamic;
+ x162 = confuse(f162);
+ l162 = confuse(f162);
+ }
+
+ Expect.isTrue(m162 is F162);
+ Expect.isTrue(m162 is List<Function> Function(int x1, [List<T> x2]));
+ Expect.isTrue(confuse(m162) is F162);
+ // In checked mode, verifies the type.
+ x162 = m162;
+ l162 = m162;
+ x162 = confuse(m162);
+ l162 = confuse(m162);
+ if (!tIsBool) {
+ Expect.isTrue(f162 is F162<int>);
+ Expect.isFalse(f162 is F162<bool>);
+ Expect.isTrue(confuse(f162) is F162<int>);
+ Expect.isFalse(confuse(f162) is F162<bool>);
+ Expect.equals(tIsDynamic, m162 is F162<bool>);
+ Expect.equals(tIsDynamic, confuse(m162) is F162<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x162 = (f162 as dynamic); });
+ Expect.throws(() { x162 = confuse(f162); });
+ List<Function> Function(int x1, [List<T> x2]) l162;
+ Expect.throws(() { l162 = (f162 as dynamic); });
+ Expect.throws(() { l162 = confuse(f162); });
+ }
+ List<Function> Function(int x1, [List<T> x2]) l162 = m162;
+ // In checked mode, verifies the type.
+ x162 = m162;
+ x162 = confuse(m162);
+ }
+ }
+
+ void testF262() {
+ // List<T> Function([core.List<core.int> x1])
+ Expect.isTrue(f262 is F262);
+ Expect.isTrue(confuse(f262) is F262);
+ // In checked mode, verifies the type.
+ List<T> Function([core.List<core.int> x1]) l262;
+ // The static function f262 sets `T` to `int`.
+ if (!tIsBool) {
+ x262 = f262 as dynamic;
+ l262 = f262 as dynamic;
+ x262 = confuse(f262);
+ l262 = confuse(f262);
+ }
+
+ Expect.isTrue(m262 is F262);
+ Expect.isTrue(m262 is List<T> Function([core.List<core.int> x1]));
+ Expect.isTrue(confuse(m262) is F262);
+ // In checked mode, verifies the type.
+ x262 = m262;
+ l262 = m262;
+ x262 = confuse(m262);
+ l262 = confuse(m262);
+ if (!tIsBool) {
+ Expect.isTrue(f262 is F262<int>);
+ Expect.isFalse(f262 is F262<bool>);
+ Expect.isTrue(confuse(f262) is F262<int>);
+ Expect.isFalse(confuse(f262) is F262<bool>);
+ Expect.equals(tIsDynamic, m262 is F262<bool>);
+ Expect.equals(tIsDynamic, confuse(m262) is F262<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x262 = (f262 as dynamic); });
+ Expect.throws(() { x262 = confuse(f262); });
+ List<T> Function([core.List<core.int> x1]) l262;
+ Expect.throws(() { l262 = (f262 as dynamic); });
+ Expect.throws(() { l262 = confuse(f262); });
+ }
+ List<T> Function([core.List<core.int> x1]) l262 = m262;
+ // In checked mode, verifies the type.
+ x262 = m262;
+ x262 = confuse(m262);
+ }
+ }
+
+ void testF362() {
+ // core.List<core.int> Function<A>(List<Function> x)
+ Expect.isTrue(f362 is F362);
+ Expect.isTrue(confuse(f362) is F362);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<Function> x) l362;
+ // The static function f362 sets `T` to `int`.
+ if (!tIsBool) {
+ x362 = f362 as dynamic;
+ l362 = f362 as dynamic;
+ x362 = confuse(f362);
+ l362 = confuse(f362);
+ }
+
+ Expect.isTrue(m362 is F362);
+ Expect.isTrue(m362 is core.List<core.int> Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m362) is F362);
+ // In checked mode, verifies the type.
+ x362 = m362;
+ l362 = m362;
+ x362 = confuse(m362);
+ l362 = confuse(m362);
+
+ }
+
+ void testF462() {
+ // int Function(Function x1) Function<B extends core.int>()
+ Expect.isTrue(f462 is F462);
+ Expect.isTrue(confuse(f462) is F462);
+ // In checked mode, verifies the type.
+ int Function(Function x1) Function<B extends core.int>() l462;
+ // The static function f462 sets `T` to `int`.
+ if (!tIsBool) {
+ x462 = f462 as dynamic;
+ l462 = f462 as dynamic;
+ x462 = confuse(f462);
+ l462 = confuse(f462);
+ }
+
+ Expect.isTrue(m462 is F462);
+ Expect.isTrue(m462 is int Function(Function x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m462) is F462);
+ // In checked mode, verifies the type.
+ x462 = m462;
+ l462 = m462;
+ x462 = confuse(m462);
+ l462 = confuse(m462);
+
+ }
+
+ void testF562() {
+ // int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f562 is F562);
+ Expect.isTrue(confuse(f562) is F562);
+ // In checked mode, verifies the type.
+ int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l562;
+ // The static function f562 sets `T` to `int`.
+ if (!tIsBool) {
+ x562 = f562 as dynamic;
+ l562 = f562 as dynamic;
+ x562 = confuse(f562);
+ l562 = confuse(f562);
+ }
+
+ Expect.isTrue(m562 is F562);
+ Expect.isTrue(m562 is int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m562) is F562);
+ // In checked mode, verifies the type.
+ x562 = m562;
+ l562 = m562;
+ x562 = confuse(m562);
+ l562 = confuse(m562);
+
+ }
+
+ void testF662() {
+ // Function Function(int x1, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f662 is F662);
+ Expect.isTrue(confuse(f662) is F662);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {int x}) Function<B extends core.int>() l662;
+ // The static function f662 sets `T` to `int`.
+ if (!tIsBool) {
+ x662 = f662 as dynamic;
+ l662 = f662 as dynamic;
+ x662 = confuse(f662);
+ l662 = confuse(f662);
+ }
+
+ Expect.isTrue(m662 is F662);
+ Expect.isTrue(m662 is Function Function(int x1, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m662) is F662);
+ // In checked mode, verifies the type.
+ x662 = m662;
+ l662 = m662;
+ x662 = confuse(m662);
+ l662 = confuse(m662);
+
+ }
+
+ void testF762() {
+ // Function Function([core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f762 is F762);
+ Expect.isTrue(confuse(f762) is F762);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x]) Function<B extends core.int>() l762;
+ // The static function f762 sets `T` to `int`.
+ if (!tIsBool) {
+ x762 = f762 as dynamic;
+ l762 = f762 as dynamic;
+ x762 = confuse(f762);
+ l762 = confuse(f762);
+ }
+
+ Expect.isTrue(m762 is F762);
+ Expect.isTrue(m762 is Function Function([core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m762) is F762);
+ // In checked mode, verifies the type.
+ x762 = m762;
+ l762 = m762;
+ x762 = confuse(m762);
+ l762 = confuse(m762);
+
+ }
+
+ void testF862() {
+ // List<Function> Function(int y, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f862 is F862);
+ Expect.isTrue(confuse(f862) is F862);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [int x]) Function<B extends core.int>() l862;
+ // The static function f862 sets `T` to `int`.
+ if (!tIsBool) {
+ x862 = f862 as dynamic;
+ l862 = f862 as dynamic;
+ x862 = confuse(f862);
+ l862 = confuse(f862);
+ }
+
+ Expect.isTrue(m862 is F862);
+ Expect.isTrue(m862 is List<Function> Function(int y, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m862) is F862);
+ // In checked mode, verifies the type.
+ x862 = m862;
+ l862 = m862;
+ x862 = confuse(m862);
+ l862 = confuse(m862);
+
+ }
+
+ void testF962() {
+ // List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>()
+ Expect.isTrue(f962 is F962);
+ Expect.isTrue(confuse(f962) is F962);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>() l962;
+ // The static function f962 sets `T` to `int`.
+ if (!tIsBool) {
+ x962 = f962 as dynamic;
+ l962 = f962 as dynamic;
+ x962 = confuse(f962);
+ l962 = confuse(f962);
+ }
+
+ Expect.isTrue(m962 is F962);
+ Expect.isTrue(m962 is List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m962) is F962);
+ // In checked mode, verifies the type.
+ x962 = m962;
+ l962 = m962;
+ x962 = confuse(m962);
+ l962 = confuse(m962);
+
+ }
+
+ void testF1062() {
+ // List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1062 is F1062);
+ Expect.isTrue(confuse(f1062) is F1062);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>() l1062;
+ // The static function f1062 sets `T` to `int`.
+ if (!tIsBool) {
+ x1062 = f1062 as dynamic;
+ l1062 = f1062 as dynamic;
+ x1062 = confuse(f1062);
+ l1062 = confuse(f1062);
+ }
+
+ Expect.isTrue(m1062 is F1062);
+ Expect.isTrue(m1062 is List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1062) is F1062);
+ // In checked mode, verifies the type.
+ x1062 = m1062;
+ l1062 = m1062;
+ x1062 = confuse(m1062);
+ l1062 = confuse(m1062);
+ if (!tIsBool) {
+ Expect.isTrue(f1062 is F1062<int>);
+ Expect.isFalse(f1062 is F1062<bool>);
+ Expect.isTrue(confuse(f1062) is F1062<int>);
+ Expect.isFalse(confuse(f1062) is F1062<bool>);
+ Expect.equals(tIsDynamic, m1062 is F1062<bool>);
+ Expect.equals(tIsDynamic, confuse(m1062) is F1062<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1062 = (f1062 as dynamic); });
+ Expect.throws(() { x1062 = confuse(f1062); });
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>() l1062;
+ Expect.throws(() { l1062 = (f1062 as dynamic); });
+ Expect.throws(() { l1062 = confuse(f1062); });
+ }
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>() l1062 = m1062;
+ // In checked mode, verifies the type.
+ x1062 = m1062;
+ x1062 = confuse(m1062);
+ }
+ }
+
+ void testF1162() {
+ // core.List<core.int> Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1162 is F1162);
+ Expect.isTrue(confuse(f1162) is F1162);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x) Function<B extends core.int>() l1162;
+ // The static function f1162 sets `T` to `int`.
+ if (!tIsBool) {
+ x1162 = f1162 as dynamic;
+ l1162 = f1162 as dynamic;
+ x1162 = confuse(f1162);
+ l1162 = confuse(f1162);
+ }
+
+ Expect.isTrue(m1162 is F1162);
+ Expect.isTrue(m1162 is core.List<core.int> Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1162) is F1162);
+ // In checked mode, verifies the type.
+ x1162 = m1162;
+ l1162 = m1162;
+ x1162 = confuse(m1162);
+ l1162 = confuse(m1162);
+
+ }
+
+ void testF1262() {
+ // core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1262 is F1262);
+ Expect.isTrue(confuse(f1262) is F1262);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>() l1262;
+ // The static function f1262 sets `T` to `int`.
+ if (!tIsBool) {
+ x1262 = f1262 as dynamic;
+ l1262 = f1262 as dynamic;
+ x1262 = confuse(f1262);
+ l1262 = confuse(f1262);
+ }
+
+ Expect.isTrue(m1262 is F1262);
+ Expect.isTrue(m1262 is core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1262) is F1262);
+ // In checked mode, verifies the type.
+ x1262 = m1262;
+ l1262 = m1262;
+ x1262 = confuse(m1262);
+ l1262 = confuse(m1262);
+ if (!tIsBool) {
+ Expect.isTrue(f1262 is F1262<int>);
+ Expect.isFalse(f1262 is F1262<bool>);
+ Expect.isTrue(confuse(f1262) is F1262<int>);
+ Expect.isFalse(confuse(f1262) is F1262<bool>);
+ Expect.equals(tIsDynamic, m1262 is F1262<bool>);
+ Expect.equals(tIsDynamic, confuse(m1262) is F1262<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1262 = (f1262 as dynamic); });
+ Expect.throws(() { x1262 = confuse(f1262); });
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>() l1262;
+ Expect.throws(() { l1262 = (f1262 as dynamic); });
+ Expect.throws(() { l1262 = confuse(f1262); });
+ }
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>() l1262 = m1262;
+ // In checked mode, verifies the type.
+ x1262 = m1262;
+ x1262 = confuse(m1262);
+ }
+ }
+
+ void testF1362() {
+ // List<T> Function([Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f1362 is F1362);
+ Expect.isTrue(confuse(f1362) is F1362);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x1]) Function<B extends core.int>() l1362;
+ // The static function f1362 sets `T` to `int`.
+ if (!tIsBool) {
+ x1362 = f1362 as dynamic;
+ l1362 = f1362 as dynamic;
+ x1362 = confuse(f1362);
+ l1362 = confuse(f1362);
+ }
+
+ Expect.isTrue(m1362 is F1362);
+ Expect.isTrue(m1362 is List<T> Function([Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1362) is F1362);
+ // In checked mode, verifies the type.
+ x1362 = m1362;
+ l1362 = m1362;
+ x1362 = confuse(m1362);
+ l1362 = confuse(m1362);
+ if (!tIsBool) {
+ Expect.isTrue(f1362 is F1362<int>);
+ Expect.isFalse(f1362 is F1362<bool>);
+ Expect.isTrue(confuse(f1362) is F1362<int>);
+ Expect.isFalse(confuse(f1362) is F1362<bool>);
+ Expect.equals(tIsDynamic, m1362 is F1362<bool>);
+ Expect.equals(tIsDynamic, confuse(m1362) is F1362<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1362 = (f1362 as dynamic); });
+ Expect.throws(() { x1362 = confuse(f1362); });
+ List<T> Function([Function x1]) Function<B extends core.int>() l1362;
+ Expect.throws(() { l1362 = (f1362 as dynamic); });
+ Expect.throws(() { l1362 = confuse(f1362); });
+ }
+ List<T> Function([Function x1]) Function<B extends core.int>() l1362 = m1362;
+ // In checked mode, verifies the type.
+ x1362 = m1362;
+ x1362 = confuse(m1362);
+ }
+ }
+
+ void testF1462() {
+ // List<T> Function({core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1462 is F1462);
+ Expect.isTrue(confuse(f1462) is F1462);
+ // In checked mode, verifies the type.
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>() l1462;
+ // The static function f1462 sets `T` to `int`.
+ if (!tIsBool) {
+ x1462 = f1462 as dynamic;
+ l1462 = f1462 as dynamic;
+ x1462 = confuse(f1462);
+ l1462 = confuse(f1462);
+ }
+
+ Expect.isTrue(m1462 is F1462);
+ Expect.isTrue(m1462 is List<T> Function({core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1462) is F1462);
+ // In checked mode, verifies the type.
+ x1462 = m1462;
+ l1462 = m1462;
+ x1462 = confuse(m1462);
+ l1462 = confuse(m1462);
+ if (!tIsBool) {
+ Expect.isTrue(f1462 is F1462<int>);
+ Expect.isFalse(f1462 is F1462<bool>);
+ Expect.isTrue(confuse(f1462) is F1462<int>);
+ Expect.isFalse(confuse(f1462) is F1462<bool>);
+ Expect.equals(tIsDynamic, m1462 is F1462<bool>);
+ Expect.equals(tIsDynamic, confuse(m1462) is F1462<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1462 = (f1462 as dynamic); });
+ Expect.throws(() { x1462 = confuse(f1462); });
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>() l1462;
+ Expect.throws(() { l1462 = (f1462 as dynamic); });
+ Expect.throws(() { l1462 = confuse(f1462); });
+ }
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>() l1462 = m1462;
+ // In checked mode, verifies the type.
+ x1462 = m1462;
+ x1462 = confuse(m1462);
+ }
+ }
+
+ void testF1562() {
+ // Function(int y, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f1562 is F1562);
+ Expect.isTrue(confuse(f1562) is F1562);
+ // In checked mode, verifies the type.
+ Function(int y, {int x}) Function<B extends core.int>() l1562;
+ // The static function f1562 sets `T` to `int`.
+ if (!tIsBool) {
+ x1562 = f1562 as dynamic;
+ l1562 = f1562 as dynamic;
+ x1562 = confuse(f1562);
+ l1562 = confuse(f1562);
+ }
+
+ Expect.isTrue(m1562 is F1562);
+ Expect.isTrue(m1562 is Function(int y, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1562) is F1562);
+ // In checked mode, verifies the type.
+ x1562 = m1562;
+ l1562 = m1562;
+ x1562 = confuse(m1562);
+ l1562 = confuse(m1562);
+
+ }
+
+ void testF1662() {
+ // Function(int x1, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1662 is F1662);
+ Expect.isTrue(confuse(f1662) is F1662);
+ // In checked mode, verifies the type.
+ Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l1662;
+ // The static function f1662 sets `T` to `int`.
+ if (!tIsBool) {
+ x1662 = f1662 as dynamic;
+ l1662 = f1662 as dynamic;
+ x1662 = confuse(f1662);
+ l1662 = confuse(f1662);
+ }
+
+ Expect.isTrue(m1662 is F1662);
+ Expect.isTrue(m1662 is Function(int x1, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1662) is F1662);
+ // In checked mode, verifies the type.
+ x1662 = m1662;
+ l1662 = m1662;
+ x1662 = confuse(m1662);
+ l1662 = confuse(m1662);
+
+ }
+
+ void testF1762() {
+ // int Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1762 is F1762);
+ Expect.isTrue(confuse(f1762) is F1762);
+ // In checked mode, verifies the type.
+ int Function<A>(List<T> x) Function<B extends core.int>() l1762;
+ // The static function f1762 sets `T` to `int`.
+ if (!tIsBool) {
+ x1762 = f1762 as dynamic;
+ l1762 = f1762 as dynamic;
+ x1762 = confuse(f1762);
+ l1762 = confuse(f1762);
+ }
+
+ Expect.isTrue(m1762 is F1762);
+ Expect.isTrue(m1762 is int Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1762) is F1762);
+ // In checked mode, verifies the type.
+ x1762 = m1762;
+ l1762 = m1762;
+ x1762 = confuse(m1762);
+ l1762 = confuse(m1762);
+ if (!tIsBool) {
+ Expect.isTrue(f1762 is F1762<int>);
+ Expect.isFalse(f1762 is F1762<bool>);
+ Expect.isTrue(confuse(f1762) is F1762<int>);
+ Expect.isFalse(confuse(f1762) is F1762<bool>);
+ Expect.equals(tIsDynamic, m1762 is F1762<bool>);
+ Expect.equals(tIsDynamic, confuse(m1762) is F1762<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1762 = (f1762 as dynamic); });
+ Expect.throws(() { x1762 = confuse(f1762); });
+ int Function<A>(List<T> x) Function<B extends core.int>() l1762;
+ Expect.throws(() { l1762 = (f1762 as dynamic); });
+ Expect.throws(() { l1762 = confuse(f1762); });
+ }
+ int Function<A>(List<T> x) Function<B extends core.int>() l1762 = m1762;
+ // In checked mode, verifies the type.
+ x1762 = m1762;
+ x1762 = confuse(m1762);
+ }
+ }
+
+ void testF1862() {
+ // core.List<core.int> Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1862 is F1862);
+ Expect.isTrue(confuse(f1862) is F1862);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>() Function<B extends core.int>() l1862;
+ // The static function f1862 sets `T` to `int`.
+ if (!tIsBool) {
+ x1862 = f1862 as dynamic;
+ l1862 = f1862 as dynamic;
+ x1862 = confuse(f1862);
+ l1862 = confuse(f1862);
+ }
+
+ Expect.isTrue(m1862 is F1862);
+ Expect.isTrue(m1862 is core.List<core.int> Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1862) is F1862);
+ // In checked mode, verifies the type.
+ x1862 = m1862;
+ l1862 = m1862;
+ x1862 = confuse(m1862);
+ l1862 = confuse(m1862);
+
+ }
+
+ void testF1962() {
+ // A Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1962 is F1962);
+ Expect.isTrue(confuse(f1962) is F1962);
+ // In checked mode, verifies the type.
+ A Function<A>(A x) Function<B extends core.int>() l1962;
+ // The static function f1962 sets `T` to `int`.
+ if (!tIsBool) {
+ x1962 = f1962 as dynamic;
+ l1962 = f1962 as dynamic;
+ x1962 = confuse(f1962);
+ l1962 = confuse(f1962);
+ }
+
+ Expect.isTrue(m1962 is F1962);
+ Expect.isTrue(m1962 is A Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1962) is F1962);
+ // In checked mode, verifies the type.
+ x1962 = m1962;
+ l1962 = m1962;
+ x1962 = confuse(m1962);
+ l1962 = confuse(m1962);
+
+ }
+
+
+}
+
+class C63<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x, [int x2]) x63;
+ List<Function> Function(int x, [List<T> x2]) x163;
+ List<T> Function(int x1, [core.List<core.int> x2]) x263;
+ core.List<core.int> Function<A>(core.List<core.int> x) x363;
+ int Function(Function x1) Function<B extends core.int>(int x) x463;
+ int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) x563;
+ Function Function(int x1, {int x}) Function<B extends core.int>(int x) x663;
+ Function Function([core.List<core.int> x]) Function<B extends core.int>(int x) x763;
+ List<Function> Function(int y, [int x]) Function<B extends core.int>(int x) x863;
+ List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) x963;
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) x1063;
+ core.List<core.int> Function(List<Function> x) Function<B extends core.int>(int x) x1163;
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x) x1263;
+ List<T> Function([Function x1]) Function<B extends core.int>(int x) x1363;
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x) x1463;
+ Function(int y, {int x}) Function<B extends core.int>(int x) x1563;
+ Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) x1663;
+ int Function<A>(List<T> x) Function<B extends core.int>(int x) x1763;
+ core.List<core.int> Function<A>() Function<B extends core.int>(int x) x1863;
+ A Function<A>(A x) Function<B extends core.int>(int x) x1963;
+
+
+ C63({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m63(int x, [int x0]) => null;
+ List<Function> m163(int x, [List<T> x0]) => null;
+ List<T> m263(int x0, [core.List<core.int> x1]) => null;
+ core.List<core.int> m363<A>(core.List<core.int> x) => null;
+ int Function(Function x0) m463<B extends core.int>(int x) => null;
+ int Function(int x, [core.List<core.int> x0]) m563<B extends core.int>(int x) => null;
+ Function Function(int x0, {int x}) m663<B extends core.int>(int x) => null;
+ Function Function([core.List<core.int> x]) m763<B extends core.int>(int x) => null;
+ List<Function> Function(int y, [int x]) m863<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [List<Function> x1]) m963<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, {List<T> x}) m1063<B extends core.int>(int x) => null;
+ core.List<core.int> Function(List<Function> x) m1163<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, [List<T> x]) m1263<B extends core.int>(int x) => null;
+ List<T> Function([Function x0]) m1363<B extends core.int>(int x) => null;
+ List<T> Function({core.List<core.int> x}) m1463<B extends core.int>(int x) => null;
+ Function(int y, {int x}) m1563<B extends core.int>(int x) => null;
+ Function(int x0, [core.List<core.int> x]) m1663<B extends core.int>(int x) => null;
+ int Function<A>(List<T> x) m1763<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>() m1863<B extends core.int>(int x) => null;
+ A Function<A>(A x) m1963<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF63();
+ testF163();
+ testF263();
+ testF363();
+ testF463();
+ testF563();
+ testF663();
+ testF763();
+ testF863();
+ testF963();
+ testF1063();
+ testF1163();
+ testF1263();
+ testF1363();
+ testF1463();
+ testF1563();
+ testF1663();
+ testF1763();
+ testF1863();
+ testF1963();
+ }
+
+ void testF63() {
+ // Function Function(int x, [int x2])
+ Expect.isTrue(f63 is F63);
+ Expect.isTrue(confuse(f63) is F63);
+ // In checked mode, verifies the type.
+ Function Function(int x, [int x2]) l63;
+ // The static function f63 sets `T` to `int`.
+ if (!tIsBool) {
+ x63 = f63 as dynamic;
+ l63 = f63 as dynamic;
+ x63 = confuse(f63);
+ l63 = confuse(f63);
+ }
+
+ Expect.isTrue(m63 is F63);
+ Expect.isTrue(m63 is Function Function(int x, [int x2]));
+ Expect.isTrue(confuse(m63) is F63);
+ // In checked mode, verifies the type.
+ x63 = m63;
+ l63 = m63;
+ x63 = confuse(m63);
+ l63 = confuse(m63);
+
+ }
+
+ void testF163() {
+ // List<Function> Function(int x, [List<T> x2])
+ Expect.isTrue(f163 is F163);
+ Expect.isTrue(confuse(f163) is F163);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<T> x2]) l163;
+ // The static function f163 sets `T` to `int`.
+ if (!tIsBool) {
+ x163 = f163 as dynamic;
+ l163 = f163 as dynamic;
+ x163 = confuse(f163);
+ l163 = confuse(f163);
+ }
+
+ Expect.isTrue(m163 is F163);
+ Expect.isTrue(m163 is List<Function> Function(int x, [List<T> x2]));
+ Expect.isTrue(confuse(m163) is F163);
+ // In checked mode, verifies the type.
+ x163 = m163;
+ l163 = m163;
+ x163 = confuse(m163);
+ l163 = confuse(m163);
+ if (!tIsBool) {
+ Expect.isTrue(f163 is F163<int>);
+ Expect.isFalse(f163 is F163<bool>);
+ Expect.isTrue(confuse(f163) is F163<int>);
+ Expect.isFalse(confuse(f163) is F163<bool>);
+ Expect.equals(tIsDynamic, m163 is F163<bool>);
+ Expect.equals(tIsDynamic, confuse(m163) is F163<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x163 = (f163 as dynamic); });
+ Expect.throws(() { x163 = confuse(f163); });
+ List<Function> Function(int x, [List<T> x2]) l163;
+ Expect.throws(() { l163 = (f163 as dynamic); });
+ Expect.throws(() { l163 = confuse(f163); });
+ }
+ List<Function> Function(int x, [List<T> x2]) l163 = m163;
+ // In checked mode, verifies the type.
+ x163 = m163;
+ x163 = confuse(m163);
+ }
+ }
+
+ void testF263() {
+ // List<T> Function(int x1, [core.List<core.int> x2])
+ Expect.isTrue(f263 is F263);
+ Expect.isTrue(confuse(f263) is F263);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [core.List<core.int> x2]) l263;
+ // The static function f263 sets `T` to `int`.
+ if (!tIsBool) {
+ x263 = f263 as dynamic;
+ l263 = f263 as dynamic;
+ x263 = confuse(f263);
+ l263 = confuse(f263);
+ }
+
+ Expect.isTrue(m263 is F263);
+ Expect.isTrue(m263 is List<T> Function(int x1, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m263) is F263);
+ // In checked mode, verifies the type.
+ x263 = m263;
+ l263 = m263;
+ x263 = confuse(m263);
+ l263 = confuse(m263);
+ if (!tIsBool) {
+ Expect.isTrue(f263 is F263<int>);
+ Expect.isFalse(f263 is F263<bool>);
+ Expect.isTrue(confuse(f263) is F263<int>);
+ Expect.isFalse(confuse(f263) is F263<bool>);
+ Expect.equals(tIsDynamic, m263 is F263<bool>);
+ Expect.equals(tIsDynamic, confuse(m263) is F263<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x263 = (f263 as dynamic); });
+ Expect.throws(() { x263 = confuse(f263); });
+ List<T> Function(int x1, [core.List<core.int> x2]) l263;
+ Expect.throws(() { l263 = (f263 as dynamic); });
+ Expect.throws(() { l263 = confuse(f263); });
+ }
+ List<T> Function(int x1, [core.List<core.int> x2]) l263 = m263;
+ // In checked mode, verifies the type.
+ x263 = m263;
+ x263 = confuse(m263);
+ }
+ }
+
+ void testF363() {
+ // core.List<core.int> Function<A>(core.List<core.int> x)
+ Expect.isTrue(f363 is F363);
+ Expect.isTrue(confuse(f363) is F363);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(core.List<core.int> x) l363;
+ // The static function f363 sets `T` to `int`.
+ if (!tIsBool) {
+ x363 = f363 as dynamic;
+ l363 = f363 as dynamic;
+ x363 = confuse(f363);
+ l363 = confuse(f363);
+ }
+
+ Expect.isTrue(m363 is F363);
+ Expect.isTrue(m363 is core.List<core.int> Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m363) is F363);
+ // In checked mode, verifies the type.
+ x363 = m363;
+ l363 = m363;
+ x363 = confuse(m363);
+ l363 = confuse(m363);
+
+ }
+
+ void testF463() {
+ // int Function(Function x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f463 is F463);
+ Expect.isTrue(confuse(f463) is F463);
+ // In checked mode, verifies the type.
+ int Function(Function x1) Function<B extends core.int>(int x) l463;
+ // The static function f463 sets `T` to `int`.
+ if (!tIsBool) {
+ x463 = f463 as dynamic;
+ l463 = f463 as dynamic;
+ x463 = confuse(f463);
+ l463 = confuse(f463);
+ }
+
+ Expect.isTrue(m463 is F463);
+ Expect.isTrue(m463 is int Function(Function x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m463) is F463);
+ // In checked mode, verifies the type.
+ x463 = m463;
+ l463 = m463;
+ x463 = confuse(m463);
+ l463 = confuse(m463);
+
+ }
+
+ void testF563() {
+ // int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f563 is F563);
+ Expect.isTrue(confuse(f563) is F563);
+ // In checked mode, verifies the type.
+ int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l563;
+ // The static function f563 sets `T` to `int`.
+ if (!tIsBool) {
+ x563 = f563 as dynamic;
+ l563 = f563 as dynamic;
+ x563 = confuse(f563);
+ l563 = confuse(f563);
+ }
+
+ Expect.isTrue(m563 is F563);
+ Expect.isTrue(m563 is int Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m563) is F563);
+ // In checked mode, verifies the type.
+ x563 = m563;
+ l563 = m563;
+ x563 = confuse(m563);
+ l563 = confuse(m563);
+
+ }
+
+ void testF663() {
+ // Function Function(int x1, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f663 is F663);
+ Expect.isTrue(confuse(f663) is F663);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {int x}) Function<B extends core.int>(int x) l663;
+ // The static function f663 sets `T` to `int`.
+ if (!tIsBool) {
+ x663 = f663 as dynamic;
+ l663 = f663 as dynamic;
+ x663 = confuse(f663);
+ l663 = confuse(f663);
+ }
+
+ Expect.isTrue(m663 is F663);
+ Expect.isTrue(m663 is Function Function(int x1, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m663) is F663);
+ // In checked mode, verifies the type.
+ x663 = m663;
+ l663 = m663;
+ x663 = confuse(m663);
+ l663 = confuse(m663);
+
+ }
+
+ void testF763() {
+ // Function Function([core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f763 is F763);
+ Expect.isTrue(confuse(f763) is F763);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x]) Function<B extends core.int>(int x) l763;
+ // The static function f763 sets `T` to `int`.
+ if (!tIsBool) {
+ x763 = f763 as dynamic;
+ l763 = f763 as dynamic;
+ x763 = confuse(f763);
+ l763 = confuse(f763);
+ }
+
+ Expect.isTrue(m763 is F763);
+ Expect.isTrue(m763 is Function Function([core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m763) is F763);
+ // In checked mode, verifies the type.
+ x763 = m763;
+ l763 = m763;
+ x763 = confuse(m763);
+ l763 = confuse(m763);
+
+ }
+
+ void testF863() {
+ // List<Function> Function(int y, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f863 is F863);
+ Expect.isTrue(confuse(f863) is F863);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [int x]) Function<B extends core.int>(int x) l863;
+ // The static function f863 sets `T` to `int`.
+ if (!tIsBool) {
+ x863 = f863 as dynamic;
+ l863 = f863 as dynamic;
+ x863 = confuse(f863);
+ l863 = confuse(f863);
+ }
+
+ Expect.isTrue(m863 is F863);
+ Expect.isTrue(m863 is List<Function> Function(int y, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m863) is F863);
+ // In checked mode, verifies the type.
+ x863 = m863;
+ l863 = m863;
+ x863 = confuse(m863);
+ l863 = confuse(m863);
+
+ }
+
+ void testF963() {
+ // List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f963 is F963);
+ Expect.isTrue(confuse(f963) is F963);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l963;
+ // The static function f963 sets `T` to `int`.
+ if (!tIsBool) {
+ x963 = f963 as dynamic;
+ l963 = f963 as dynamic;
+ x963 = confuse(f963);
+ l963 = confuse(f963);
+ }
+
+ Expect.isTrue(m963 is F963);
+ Expect.isTrue(m963 is List<Function> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m963) is F963);
+ // In checked mode, verifies the type.
+ x963 = m963;
+ l963 = m963;
+ x963 = confuse(m963);
+ l963 = confuse(m963);
+
+ }
+
+ void testF1063() {
+ // List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1063 is F1063);
+ Expect.isTrue(confuse(f1063) is F1063);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1063;
+ // The static function f1063 sets `T` to `int`.
+ if (!tIsBool) {
+ x1063 = f1063 as dynamic;
+ l1063 = f1063 as dynamic;
+ x1063 = confuse(f1063);
+ l1063 = confuse(f1063);
+ }
+
+ Expect.isTrue(m1063 is F1063);
+ Expect.isTrue(m1063 is List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1063) is F1063);
+ // In checked mode, verifies the type.
+ x1063 = m1063;
+ l1063 = m1063;
+ x1063 = confuse(m1063);
+ l1063 = confuse(m1063);
+ if (!tIsBool) {
+ Expect.isTrue(f1063 is F1063<int>);
+ Expect.isFalse(f1063 is F1063<bool>);
+ Expect.isTrue(confuse(f1063) is F1063<int>);
+ Expect.isFalse(confuse(f1063) is F1063<bool>);
+ Expect.equals(tIsDynamic, m1063 is F1063<bool>);
+ Expect.equals(tIsDynamic, confuse(m1063) is F1063<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1063 = (f1063 as dynamic); });
+ Expect.throws(() { x1063 = confuse(f1063); });
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1063;
+ Expect.throws(() { l1063 = (f1063 as dynamic); });
+ Expect.throws(() { l1063 = confuse(f1063); });
+ }
+ List<Function> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1063 = m1063;
+ // In checked mode, verifies the type.
+ x1063 = m1063;
+ x1063 = confuse(m1063);
+ }
+ }
+
+ void testF1163() {
+ // core.List<core.int> Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1163 is F1163);
+ Expect.isTrue(confuse(f1163) is F1163);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x) Function<B extends core.int>(int x) l1163;
+ // The static function f1163 sets `T` to `int`.
+ if (!tIsBool) {
+ x1163 = f1163 as dynamic;
+ l1163 = f1163 as dynamic;
+ x1163 = confuse(f1163);
+ l1163 = confuse(f1163);
+ }
+
+ Expect.isTrue(m1163 is F1163);
+ Expect.isTrue(m1163 is core.List<core.int> Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1163) is F1163);
+ // In checked mode, verifies the type.
+ x1163 = m1163;
+ l1163 = m1163;
+ x1163 = confuse(m1163);
+ l1163 = confuse(m1163);
+
+ }
+
+ void testF1263() {
+ // core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1263 is F1263);
+ Expect.isTrue(confuse(f1263) is F1263);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1263;
+ // The static function f1263 sets `T` to `int`.
+ if (!tIsBool) {
+ x1263 = f1263 as dynamic;
+ l1263 = f1263 as dynamic;
+ x1263 = confuse(f1263);
+ l1263 = confuse(f1263);
+ }
+
+ Expect.isTrue(m1263 is F1263);
+ Expect.isTrue(m1263 is core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1263) is F1263);
+ // In checked mode, verifies the type.
+ x1263 = m1263;
+ l1263 = m1263;
+ x1263 = confuse(m1263);
+ l1263 = confuse(m1263);
+ if (!tIsBool) {
+ Expect.isTrue(f1263 is F1263<int>);
+ Expect.isFalse(f1263 is F1263<bool>);
+ Expect.isTrue(confuse(f1263) is F1263<int>);
+ Expect.isFalse(confuse(f1263) is F1263<bool>);
+ Expect.equals(tIsDynamic, m1263 is F1263<bool>);
+ Expect.equals(tIsDynamic, confuse(m1263) is F1263<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1263 = (f1263 as dynamic); });
+ Expect.throws(() { x1263 = confuse(f1263); });
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1263;
+ Expect.throws(() { l1263 = (f1263 as dynamic); });
+ Expect.throws(() { l1263 = confuse(f1263); });
+ }
+ core.List<core.int> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1263 = m1263;
+ // In checked mode, verifies the type.
+ x1263 = m1263;
+ x1263 = confuse(m1263);
+ }
+ }
+
+ void testF1363() {
+ // List<T> Function([Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1363 is F1363);
+ Expect.isTrue(confuse(f1363) is F1363);
+ // In checked mode, verifies the type.
+ List<T> Function([Function x1]) Function<B extends core.int>(int x) l1363;
+ // The static function f1363 sets `T` to `int`.
+ if (!tIsBool) {
+ x1363 = f1363 as dynamic;
+ l1363 = f1363 as dynamic;
+ x1363 = confuse(f1363);
+ l1363 = confuse(f1363);
+ }
+
+ Expect.isTrue(m1363 is F1363);
+ Expect.isTrue(m1363 is List<T> Function([Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1363) is F1363);
+ // In checked mode, verifies the type.
+ x1363 = m1363;
+ l1363 = m1363;
+ x1363 = confuse(m1363);
+ l1363 = confuse(m1363);
+ if (!tIsBool) {
+ Expect.isTrue(f1363 is F1363<int>);
+ Expect.isFalse(f1363 is F1363<bool>);
+ Expect.isTrue(confuse(f1363) is F1363<int>);
+ Expect.isFalse(confuse(f1363) is F1363<bool>);
+ Expect.equals(tIsDynamic, m1363 is F1363<bool>);
+ Expect.equals(tIsDynamic, confuse(m1363) is F1363<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1363 = (f1363 as dynamic); });
+ Expect.throws(() { x1363 = confuse(f1363); });
+ List<T> Function([Function x1]) Function<B extends core.int>(int x) l1363;
+ Expect.throws(() { l1363 = (f1363 as dynamic); });
+ Expect.throws(() { l1363 = confuse(f1363); });
+ }
+ List<T> Function([Function x1]) Function<B extends core.int>(int x) l1363 = m1363;
+ // In checked mode, verifies the type.
+ x1363 = m1363;
+ x1363 = confuse(m1363);
+ }
+ }
+
+ void testF1463() {
+ // List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1463 is F1463);
+ Expect.isTrue(confuse(f1463) is F1463);
+ // In checked mode, verifies the type.
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x) l1463;
+ // The static function f1463 sets `T` to `int`.
+ if (!tIsBool) {
+ x1463 = f1463 as dynamic;
+ l1463 = f1463 as dynamic;
+ x1463 = confuse(f1463);
+ l1463 = confuse(f1463);
+ }
+
+ Expect.isTrue(m1463 is F1463);
+ Expect.isTrue(m1463 is List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1463) is F1463);
+ // In checked mode, verifies the type.
+ x1463 = m1463;
+ l1463 = m1463;
+ x1463 = confuse(m1463);
+ l1463 = confuse(m1463);
+ if (!tIsBool) {
+ Expect.isTrue(f1463 is F1463<int>);
+ Expect.isFalse(f1463 is F1463<bool>);
+ Expect.isTrue(confuse(f1463) is F1463<int>);
+ Expect.isFalse(confuse(f1463) is F1463<bool>);
+ Expect.equals(tIsDynamic, m1463 is F1463<bool>);
+ Expect.equals(tIsDynamic, confuse(m1463) is F1463<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1463 = (f1463 as dynamic); });
+ Expect.throws(() { x1463 = confuse(f1463); });
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x) l1463;
+ Expect.throws(() { l1463 = (f1463 as dynamic); });
+ Expect.throws(() { l1463 = confuse(f1463); });
+ }
+ List<T> Function({core.List<core.int> x}) Function<B extends core.int>(int x) l1463 = m1463;
+ // In checked mode, verifies the type.
+ x1463 = m1463;
+ x1463 = confuse(m1463);
+ }
+ }
+
+ void testF1563() {
+ // Function(int y, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1563 is F1563);
+ Expect.isTrue(confuse(f1563) is F1563);
+ // In checked mode, verifies the type.
+ Function(int y, {int x}) Function<B extends core.int>(int x) l1563;
+ // The static function f1563 sets `T` to `int`.
+ if (!tIsBool) {
+ x1563 = f1563 as dynamic;
+ l1563 = f1563 as dynamic;
+ x1563 = confuse(f1563);
+ l1563 = confuse(f1563);
+ }
+
+ Expect.isTrue(m1563 is F1563);
+ Expect.isTrue(m1563 is Function(int y, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1563) is F1563);
+ // In checked mode, verifies the type.
+ x1563 = m1563;
+ l1563 = m1563;
+ x1563 = confuse(m1563);
+ l1563 = confuse(m1563);
+
+ }
+
+ void testF1663() {
+ // Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1663 is F1663);
+ Expect.isTrue(confuse(f1663) is F1663);
+ // In checked mode, verifies the type.
+ Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l1663;
+ // The static function f1663 sets `T` to `int`.
+ if (!tIsBool) {
+ x1663 = f1663 as dynamic;
+ l1663 = f1663 as dynamic;
+ x1663 = confuse(f1663);
+ l1663 = confuse(f1663);
+ }
+
+ Expect.isTrue(m1663 is F1663);
+ Expect.isTrue(m1663 is Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1663) is F1663);
+ // In checked mode, verifies the type.
+ x1663 = m1663;
+ l1663 = m1663;
+ x1663 = confuse(m1663);
+ l1663 = confuse(m1663);
+
+ }
+
+ void testF1763() {
+ // int Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1763 is F1763);
+ Expect.isTrue(confuse(f1763) is F1763);
+ // In checked mode, verifies the type.
+ int Function<A>(List<T> x) Function<B extends core.int>(int x) l1763;
+ // The static function f1763 sets `T` to `int`.
+ if (!tIsBool) {
+ x1763 = f1763 as dynamic;
+ l1763 = f1763 as dynamic;
+ x1763 = confuse(f1763);
+ l1763 = confuse(f1763);
+ }
+
+ Expect.isTrue(m1763 is F1763);
+ Expect.isTrue(m1763 is int Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1763) is F1763);
+ // In checked mode, verifies the type.
+ x1763 = m1763;
+ l1763 = m1763;
+ x1763 = confuse(m1763);
+ l1763 = confuse(m1763);
+ if (!tIsBool) {
+ Expect.isTrue(f1763 is F1763<int>);
+ Expect.isFalse(f1763 is F1763<bool>);
+ Expect.isTrue(confuse(f1763) is F1763<int>);
+ Expect.isFalse(confuse(f1763) is F1763<bool>);
+ Expect.equals(tIsDynamic, m1763 is F1763<bool>);
+ Expect.equals(tIsDynamic, confuse(m1763) is F1763<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1763 = (f1763 as dynamic); });
+ Expect.throws(() { x1763 = confuse(f1763); });
+ int Function<A>(List<T> x) Function<B extends core.int>(int x) l1763;
+ Expect.throws(() { l1763 = (f1763 as dynamic); });
+ Expect.throws(() { l1763 = confuse(f1763); });
+ }
+ int Function<A>(List<T> x) Function<B extends core.int>(int x) l1763 = m1763;
+ // In checked mode, verifies the type.
+ x1763 = m1763;
+ x1763 = confuse(m1763);
+ }
+ }
+
+ void testF1863() {
+ // core.List<core.int> Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1863 is F1863);
+ Expect.isTrue(confuse(f1863) is F1863);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>() Function<B extends core.int>(int x) l1863;
+ // The static function f1863 sets `T` to `int`.
+ if (!tIsBool) {
+ x1863 = f1863 as dynamic;
+ l1863 = f1863 as dynamic;
+ x1863 = confuse(f1863);
+ l1863 = confuse(f1863);
+ }
+
+ Expect.isTrue(m1863 is F1863);
+ Expect.isTrue(m1863 is core.List<core.int> Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1863) is F1863);
+ // In checked mode, verifies the type.
+ x1863 = m1863;
+ l1863 = m1863;
+ x1863 = confuse(m1863);
+ l1863 = confuse(m1863);
+
+ }
+
+ void testF1963() {
+ // A Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1963 is F1963);
+ Expect.isTrue(confuse(f1963) is F1963);
+ // In checked mode, verifies the type.
+ A Function<A>(A x) Function<B extends core.int>(int x) l1963;
+ // The static function f1963 sets `T` to `int`.
+ if (!tIsBool) {
+ x1963 = f1963 as dynamic;
+ l1963 = f1963 as dynamic;
+ x1963 = confuse(f1963);
+ l1963 = confuse(f1963);
+ }
+
+ Expect.isTrue(m1963 is F1963);
+ Expect.isTrue(m1963 is A Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1963) is F1963);
+ // In checked mode, verifies the type.
+ x1963 = m1963;
+ l1963 = m1963;
+ x1963 = confuse(m1963);
+ l1963 = confuse(m1963);
+
+ }
+
+
+}
+
+class C64<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function({int x}) x64;
+ List<Function> Function({List<T> x}) x164;
+ List<T> Function(int x, [core.List<core.int> x2]) x264;
+ core.List<core.int> Function<A>(List<T> x) x364;
+ int Function([Function x1]) Function() x464;
+ int Function({core.List<core.int> x}) Function() x564;
+ Function Function(int y, {int x}) Function() x664;
+ Function Function(int x0, [core.List<core.int> x]) Function() x764;
+ List<Function> Function(int x0) Function() x864;
+ List<Function> Function(int x, [List<Function> x2]) Function() x964;
+ List<Function> Function(int y, {List<T> x}) Function() x1064;
+ core.List<core.int> Function([List<Function> x]) Function() x1164;
+ core.List<core.int> Function(List<T> x0) Function() x1264;
+ List<T> Function(int x1, [Function x2]) Function() x1364;
+ List<T> Function(int x0, {core.List<core.int> x}) Function() x1464;
+ Function(Function x) Function() x1564;
+ Function(int y, [core.List<core.int> x]) Function() x1664;
+ int Function<A>() Function() x1764;
+ core.List<core.int> Function<A>(A x) Function() x1864;
+ A Function<A>(List<A> x) Function() x1964;
+
+
+ C64({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m64({int x}) => null;
+ List<Function> m164({List<T> x}) => null;
+ List<T> m264(int x, [core.List<core.int> x0]) => null;
+ core.List<core.int> m364<A>(List<T> x) => null;
+ int Function([Function x0]) m464() => null;
+ int Function({core.List<core.int> x}) m564() => null;
+ Function Function(int y, {int x}) m664() => null;
+ Function Function(int x0, [core.List<core.int> x]) m764() => null;
+ List<Function> Function(int x0) m864() => null;
+ List<Function> Function(int x, [List<Function> x0]) m964() => null;
+ List<Function> Function(int y, {List<T> x}) m1064() => null;
+ core.List<core.int> Function([List<Function> x]) m1164() => null;
+ core.List<core.int> Function(List<T> x0) m1264() => null;
+ List<T> Function(int x0, [Function x1]) m1364() => null;
+ List<T> Function(int x0, {core.List<core.int> x}) m1464() => null;
+ Function(Function x) m1564() => null;
+ Function(int y, [core.List<core.int> x]) m1664() => null;
+ int Function<A>() m1764() => null;
+ core.List<core.int> Function<A>(A x) m1864() => null;
+ A Function<A>(List<A> x) m1964() => null;
+
+
+ runTests() {
+ testF64();
+ testF164();
+ testF264();
+ testF364();
+ testF464();
+ testF564();
+ testF664();
+ testF764();
+ testF864();
+ testF964();
+ testF1064();
+ testF1164();
+ testF1264();
+ testF1364();
+ testF1464();
+ testF1564();
+ testF1664();
+ testF1764();
+ testF1864();
+ testF1964();
+ }
+
+ void testF64() {
+ // Function Function({int x})
+ Expect.isTrue(f64 is F64);
+ Expect.isTrue(confuse(f64) is F64);
+ // In checked mode, verifies the type.
+ Function Function({int x}) l64;
+ // The static function f64 sets `T` to `int`.
+ if (!tIsBool) {
+ x64 = f64 as dynamic;
+ l64 = f64 as dynamic;
+ x64 = confuse(f64);
+ l64 = confuse(f64);
+ }
+
+ Expect.isTrue(m64 is F64);
+ Expect.isTrue(m64 is Function Function({int x}));
+ Expect.isTrue(confuse(m64) is F64);
+ // In checked mode, verifies the type.
+ x64 = m64;
+ l64 = m64;
+ x64 = confuse(m64);
+ l64 = confuse(m64);
+
+ }
+
+ void testF164() {
+ // List<Function> Function({List<T> x})
+ Expect.isTrue(f164 is F164);
+ Expect.isTrue(confuse(f164) is F164);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<T> x}) l164;
+ // The static function f164 sets `T` to `int`.
+ if (!tIsBool) {
+ x164 = f164 as dynamic;
+ l164 = f164 as dynamic;
+ x164 = confuse(f164);
+ l164 = confuse(f164);
+ }
+
+ Expect.isTrue(m164 is F164);
+ Expect.isTrue(m164 is List<Function> Function({List<T> x}));
+ Expect.isTrue(confuse(m164) is F164);
+ // In checked mode, verifies the type.
+ x164 = m164;
+ l164 = m164;
+ x164 = confuse(m164);
+ l164 = confuse(m164);
+ if (!tIsBool) {
+ Expect.isTrue(f164 is F164<int>);
+ Expect.isFalse(f164 is F164<bool>);
+ Expect.isTrue(confuse(f164) is F164<int>);
+ Expect.isFalse(confuse(f164) is F164<bool>);
+ Expect.equals(tIsDynamic, m164 is F164<bool>);
+ Expect.equals(tIsDynamic, confuse(m164) is F164<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x164 = (f164 as dynamic); });
+ Expect.throws(() { x164 = confuse(f164); });
+ List<Function> Function({List<T> x}) l164;
+ Expect.throws(() { l164 = (f164 as dynamic); });
+ Expect.throws(() { l164 = confuse(f164); });
+ }
+ List<Function> Function({List<T> x}) l164 = m164;
+ // In checked mode, verifies the type.
+ x164 = m164;
+ x164 = confuse(m164);
+ }
+ }
+
+ void testF264() {
+ // List<T> Function(int x, [core.List<core.int> x2])
+ Expect.isTrue(f264 is F264);
+ Expect.isTrue(confuse(f264) is F264);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [core.List<core.int> x2]) l264;
+ // The static function f264 sets `T` to `int`.
+ if (!tIsBool) {
+ x264 = f264 as dynamic;
+ l264 = f264 as dynamic;
+ x264 = confuse(f264);
+ l264 = confuse(f264);
+ }
+
+ Expect.isTrue(m264 is F264);
+ Expect.isTrue(m264 is List<T> Function(int x, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m264) is F264);
+ // In checked mode, verifies the type.
+ x264 = m264;
+ l264 = m264;
+ x264 = confuse(m264);
+ l264 = confuse(m264);
+ if (!tIsBool) {
+ Expect.isTrue(f264 is F264<int>);
+ Expect.isFalse(f264 is F264<bool>);
+ Expect.isTrue(confuse(f264) is F264<int>);
+ Expect.isFalse(confuse(f264) is F264<bool>);
+ Expect.equals(tIsDynamic, m264 is F264<bool>);
+ Expect.equals(tIsDynamic, confuse(m264) is F264<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x264 = (f264 as dynamic); });
+ Expect.throws(() { x264 = confuse(f264); });
+ List<T> Function(int x, [core.List<core.int> x2]) l264;
+ Expect.throws(() { l264 = (f264 as dynamic); });
+ Expect.throws(() { l264 = confuse(f264); });
+ }
+ List<T> Function(int x, [core.List<core.int> x2]) l264 = m264;
+ // In checked mode, verifies the type.
+ x264 = m264;
+ x264 = confuse(m264);
+ }
+ }
+
+ void testF364() {
+ // core.List<core.int> Function<A>(List<T> x)
+ Expect.isTrue(f364 is F364);
+ Expect.isTrue(confuse(f364) is F364);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<T> x) l364;
+ // The static function f364 sets `T` to `int`.
+ if (!tIsBool) {
+ x364 = f364 as dynamic;
+ l364 = f364 as dynamic;
+ x364 = confuse(f364);
+ l364 = confuse(f364);
+ }
+
+ Expect.isTrue(m364 is F364);
+ Expect.isTrue(m364 is core.List<core.int> Function<A>(List<T> x));
+ Expect.isTrue(confuse(m364) is F364);
+ // In checked mode, verifies the type.
+ x364 = m364;
+ l364 = m364;
+ x364 = confuse(m364);
+ l364 = confuse(m364);
+ if (!tIsBool) {
+ Expect.isTrue(f364 is F364<int>);
+ Expect.isFalse(f364 is F364<bool>);
+ Expect.isTrue(confuse(f364) is F364<int>);
+ Expect.isFalse(confuse(f364) is F364<bool>);
+ Expect.equals(tIsDynamic, m364 is F364<bool>);
+ Expect.equals(tIsDynamic, confuse(m364) is F364<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x364 = (f364 as dynamic); });
+ Expect.throws(() { x364 = confuse(f364); });
+ core.List<core.int> Function<A>(List<T> x) l364;
+ Expect.throws(() { l364 = (f364 as dynamic); });
+ Expect.throws(() { l364 = confuse(f364); });
+ }
+ core.List<core.int> Function<A>(List<T> x) l364 = m364;
+ // In checked mode, verifies the type.
+ x364 = m364;
+ x364 = confuse(m364);
+ }
+ }
+
+ void testF464() {
+ // int Function([Function x1]) Function()
+ Expect.isTrue(f464 is F464);
+ Expect.isTrue(confuse(f464) is F464);
+ // In checked mode, verifies the type.
+ int Function([Function x1]) Function() l464;
+ // The static function f464 sets `T` to `int`.
+ if (!tIsBool) {
+ x464 = f464 as dynamic;
+ l464 = f464 as dynamic;
+ x464 = confuse(f464);
+ l464 = confuse(f464);
+ }
+
+ Expect.isTrue(m464 is F464);
+ Expect.isTrue(m464 is int Function([Function x1]) Function());
+ Expect.isTrue(confuse(m464) is F464);
+ // In checked mode, verifies the type.
+ x464 = m464;
+ l464 = m464;
+ x464 = confuse(m464);
+ l464 = confuse(m464);
+
+ }
+
+ void testF564() {
+ // int Function({core.List<core.int> x}) Function()
+ Expect.isTrue(f564 is F564);
+ Expect.isTrue(confuse(f564) is F564);
+ // In checked mode, verifies the type.
+ int Function({core.List<core.int> x}) Function() l564;
+ // The static function f564 sets `T` to `int`.
+ if (!tIsBool) {
+ x564 = f564 as dynamic;
+ l564 = f564 as dynamic;
+ x564 = confuse(f564);
+ l564 = confuse(f564);
+ }
+
+ Expect.isTrue(m564 is F564);
+ Expect.isTrue(m564 is int Function({core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m564) is F564);
+ // In checked mode, verifies the type.
+ x564 = m564;
+ l564 = m564;
+ x564 = confuse(m564);
+ l564 = confuse(m564);
+
+ }
+
+ void testF664() {
+ // Function Function(int y, {int x}) Function()
+ Expect.isTrue(f664 is F664);
+ Expect.isTrue(confuse(f664) is F664);
+ // In checked mode, verifies the type.
+ Function Function(int y, {int x}) Function() l664;
+ // The static function f664 sets `T` to `int`.
+ if (!tIsBool) {
+ x664 = f664 as dynamic;
+ l664 = f664 as dynamic;
+ x664 = confuse(f664);
+ l664 = confuse(f664);
+ }
+
+ Expect.isTrue(m664 is F664);
+ Expect.isTrue(m664 is Function Function(int y, {int x}) Function());
+ Expect.isTrue(confuse(m664) is F664);
+ // In checked mode, verifies the type.
+ x664 = m664;
+ l664 = m664;
+ x664 = confuse(m664);
+ l664 = confuse(m664);
+
+ }
+
+ void testF764() {
+ // Function Function(int x0, [core.List<core.int> x]) Function()
+ Expect.isTrue(f764 is F764);
+ Expect.isTrue(confuse(f764) is F764);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [core.List<core.int> x]) Function() l764;
+ // The static function f764 sets `T` to `int`.
+ if (!tIsBool) {
+ x764 = f764 as dynamic;
+ l764 = f764 as dynamic;
+ x764 = confuse(f764);
+ l764 = confuse(f764);
+ }
+
+ Expect.isTrue(m764 is F764);
+ Expect.isTrue(m764 is Function Function(int x0, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m764) is F764);
+ // In checked mode, verifies the type.
+ x764 = m764;
+ l764 = m764;
+ x764 = confuse(m764);
+ l764 = confuse(m764);
+
+ }
+
+ void testF864() {
+ // List<Function> Function(int x0) Function()
+ Expect.isTrue(f864 is F864);
+ Expect.isTrue(confuse(f864) is F864);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0) Function() l864;
+ // The static function f864 sets `T` to `int`.
+ if (!tIsBool) {
+ x864 = f864 as dynamic;
+ l864 = f864 as dynamic;
+ x864 = confuse(f864);
+ l864 = confuse(f864);
+ }
+
+ Expect.isTrue(m864 is F864);
+ Expect.isTrue(m864 is List<Function> Function(int x0) Function());
+ Expect.isTrue(confuse(m864) is F864);
+ // In checked mode, verifies the type.
+ x864 = m864;
+ l864 = m864;
+ x864 = confuse(m864);
+ l864 = confuse(m864);
+
+ }
+
+ void testF964() {
+ // List<Function> Function(int x, [List<Function> x2]) Function()
+ Expect.isTrue(f964 is F964);
+ Expect.isTrue(confuse(f964) is F964);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<Function> x2]) Function() l964;
+ // The static function f964 sets `T` to `int`.
+ if (!tIsBool) {
+ x964 = f964 as dynamic;
+ l964 = f964 as dynamic;
+ x964 = confuse(f964);
+ l964 = confuse(f964);
+ }
+
+ Expect.isTrue(m964 is F964);
+ Expect.isTrue(m964 is List<Function> Function(int x, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m964) is F964);
+ // In checked mode, verifies the type.
+ x964 = m964;
+ l964 = m964;
+ x964 = confuse(m964);
+ l964 = confuse(m964);
+
+ }
+
+ void testF1064() {
+ // List<Function> Function(int y, {List<T> x}) Function()
+ Expect.isTrue(f1064 is F1064);
+ Expect.isTrue(confuse(f1064) is F1064);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<T> x}) Function() l1064;
+ // The static function f1064 sets `T` to `int`.
+ if (!tIsBool) {
+ x1064 = f1064 as dynamic;
+ l1064 = f1064 as dynamic;
+ x1064 = confuse(f1064);
+ l1064 = confuse(f1064);
+ }
+
+ Expect.isTrue(m1064 is F1064);
+ Expect.isTrue(m1064 is List<Function> Function(int y, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1064) is F1064);
+ // In checked mode, verifies the type.
+ x1064 = m1064;
+ l1064 = m1064;
+ x1064 = confuse(m1064);
+ l1064 = confuse(m1064);
+ if (!tIsBool) {
+ Expect.isTrue(f1064 is F1064<int>);
+ Expect.isFalse(f1064 is F1064<bool>);
+ Expect.isTrue(confuse(f1064) is F1064<int>);
+ Expect.isFalse(confuse(f1064) is F1064<bool>);
+ Expect.equals(tIsDynamic, m1064 is F1064<bool>);
+ Expect.equals(tIsDynamic, confuse(m1064) is F1064<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1064 = (f1064 as dynamic); });
+ Expect.throws(() { x1064 = confuse(f1064); });
+ List<Function> Function(int y, {List<T> x}) Function() l1064;
+ Expect.throws(() { l1064 = (f1064 as dynamic); });
+ Expect.throws(() { l1064 = confuse(f1064); });
+ }
+ List<Function> Function(int y, {List<T> x}) Function() l1064 = m1064;
+ // In checked mode, verifies the type.
+ x1064 = m1064;
+ x1064 = confuse(m1064);
+ }
+ }
+
+ void testF1164() {
+ // core.List<core.int> Function([List<Function> x]) Function()
+ Expect.isTrue(f1164 is F1164);
+ Expect.isTrue(confuse(f1164) is F1164);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x]) Function() l1164;
+ // The static function f1164 sets `T` to `int`.
+ if (!tIsBool) {
+ x1164 = f1164 as dynamic;
+ l1164 = f1164 as dynamic;
+ x1164 = confuse(f1164);
+ l1164 = confuse(f1164);
+ }
+
+ Expect.isTrue(m1164 is F1164);
+ Expect.isTrue(m1164 is core.List<core.int> Function([List<Function> x]) Function());
+ Expect.isTrue(confuse(m1164) is F1164);
+ // In checked mode, verifies the type.
+ x1164 = m1164;
+ l1164 = m1164;
+ x1164 = confuse(m1164);
+ l1164 = confuse(m1164);
+
+ }
+
+ void testF1264() {
+ // core.List<core.int> Function(List<T> x0) Function()
+ Expect.isTrue(f1264 is F1264);
+ Expect.isTrue(confuse(f1264) is F1264);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x0) Function() l1264;
+ // The static function f1264 sets `T` to `int`.
+ if (!tIsBool) {
+ x1264 = f1264 as dynamic;
+ l1264 = f1264 as dynamic;
+ x1264 = confuse(f1264);
+ l1264 = confuse(f1264);
+ }
+
+ Expect.isTrue(m1264 is F1264);
+ Expect.isTrue(m1264 is core.List<core.int> Function(List<T> x0) Function());
+ Expect.isTrue(confuse(m1264) is F1264);
+ // In checked mode, verifies the type.
+ x1264 = m1264;
+ l1264 = m1264;
+ x1264 = confuse(m1264);
+ l1264 = confuse(m1264);
+ if (!tIsBool) {
+ Expect.isTrue(f1264 is F1264<int>);
+ Expect.isFalse(f1264 is F1264<bool>);
+ Expect.isTrue(confuse(f1264) is F1264<int>);
+ Expect.isFalse(confuse(f1264) is F1264<bool>);
+ Expect.equals(tIsDynamic, m1264 is F1264<bool>);
+ Expect.equals(tIsDynamic, confuse(m1264) is F1264<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1264 = (f1264 as dynamic); });
+ Expect.throws(() { x1264 = confuse(f1264); });
+ core.List<core.int> Function(List<T> x0) Function() l1264;
+ Expect.throws(() { l1264 = (f1264 as dynamic); });
+ Expect.throws(() { l1264 = confuse(f1264); });
+ }
+ core.List<core.int> Function(List<T> x0) Function() l1264 = m1264;
+ // In checked mode, verifies the type.
+ x1264 = m1264;
+ x1264 = confuse(m1264);
+ }
+ }
+
+ void testF1364() {
+ // List<T> Function(int x1, [Function x2]) Function()
+ Expect.isTrue(f1364 is F1364);
+ Expect.isTrue(confuse(f1364) is F1364);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [Function x2]) Function() l1364;
+ // The static function f1364 sets `T` to `int`.
+ if (!tIsBool) {
+ x1364 = f1364 as dynamic;
+ l1364 = f1364 as dynamic;
+ x1364 = confuse(f1364);
+ l1364 = confuse(f1364);
+ }
+
+ Expect.isTrue(m1364 is F1364);
+ Expect.isTrue(m1364 is List<T> Function(int x1, [Function x2]) Function());
+ Expect.isTrue(confuse(m1364) is F1364);
+ // In checked mode, verifies the type.
+ x1364 = m1364;
+ l1364 = m1364;
+ x1364 = confuse(m1364);
+ l1364 = confuse(m1364);
+ if (!tIsBool) {
+ Expect.isTrue(f1364 is F1364<int>);
+ Expect.isFalse(f1364 is F1364<bool>);
+ Expect.isTrue(confuse(f1364) is F1364<int>);
+ Expect.isFalse(confuse(f1364) is F1364<bool>);
+ Expect.equals(tIsDynamic, m1364 is F1364<bool>);
+ Expect.equals(tIsDynamic, confuse(m1364) is F1364<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1364 = (f1364 as dynamic); });
+ Expect.throws(() { x1364 = confuse(f1364); });
+ List<T> Function(int x1, [Function x2]) Function() l1364;
+ Expect.throws(() { l1364 = (f1364 as dynamic); });
+ Expect.throws(() { l1364 = confuse(f1364); });
+ }
+ List<T> Function(int x1, [Function x2]) Function() l1364 = m1364;
+ // In checked mode, verifies the type.
+ x1364 = m1364;
+ x1364 = confuse(m1364);
+ }
+ }
+
+ void testF1464() {
+ // List<T> Function(int x0, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1464 is F1464);
+ Expect.isTrue(confuse(f1464) is F1464);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {core.List<core.int> x}) Function() l1464;
+ // The static function f1464 sets `T` to `int`.
+ if (!tIsBool) {
+ x1464 = f1464 as dynamic;
+ l1464 = f1464 as dynamic;
+ x1464 = confuse(f1464);
+ l1464 = confuse(f1464);
+ }
+
+ Expect.isTrue(m1464 is F1464);
+ Expect.isTrue(m1464 is List<T> Function(int x0, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1464) is F1464);
+ // In checked mode, verifies the type.
+ x1464 = m1464;
+ l1464 = m1464;
+ x1464 = confuse(m1464);
+ l1464 = confuse(m1464);
+ if (!tIsBool) {
+ Expect.isTrue(f1464 is F1464<int>);
+ Expect.isFalse(f1464 is F1464<bool>);
+ Expect.isTrue(confuse(f1464) is F1464<int>);
+ Expect.isFalse(confuse(f1464) is F1464<bool>);
+ Expect.equals(tIsDynamic, m1464 is F1464<bool>);
+ Expect.equals(tIsDynamic, confuse(m1464) is F1464<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1464 = (f1464 as dynamic); });
+ Expect.throws(() { x1464 = confuse(f1464); });
+ List<T> Function(int x0, {core.List<core.int> x}) Function() l1464;
+ Expect.throws(() { l1464 = (f1464 as dynamic); });
+ Expect.throws(() { l1464 = confuse(f1464); });
+ }
+ List<T> Function(int x0, {core.List<core.int> x}) Function() l1464 = m1464;
+ // In checked mode, verifies the type.
+ x1464 = m1464;
+ x1464 = confuse(m1464);
+ }
+ }
+
+ void testF1564() {
+ // Function(Function x) Function()
+ Expect.isTrue(f1564 is F1564);
+ Expect.isTrue(confuse(f1564) is F1564);
+ // In checked mode, verifies the type.
+ Function(Function x) Function() l1564;
+ // The static function f1564 sets `T` to `int`.
+ if (!tIsBool) {
+ x1564 = f1564 as dynamic;
+ l1564 = f1564 as dynamic;
+ x1564 = confuse(f1564);
+ l1564 = confuse(f1564);
+ }
+
+ Expect.isTrue(m1564 is F1564);
+ Expect.isTrue(m1564 is Function(Function x) Function());
+ Expect.isTrue(confuse(m1564) is F1564);
+ // In checked mode, verifies the type.
+ x1564 = m1564;
+ l1564 = m1564;
+ x1564 = confuse(m1564);
+ l1564 = confuse(m1564);
+
+ }
+
+ void testF1664() {
+ // Function(int y, [core.List<core.int> x]) Function()
+ Expect.isTrue(f1664 is F1664);
+ Expect.isTrue(confuse(f1664) is F1664);
+ // In checked mode, verifies the type.
+ Function(int y, [core.List<core.int> x]) Function() l1664;
+ // The static function f1664 sets `T` to `int`.
+ if (!tIsBool) {
+ x1664 = f1664 as dynamic;
+ l1664 = f1664 as dynamic;
+ x1664 = confuse(f1664);
+ l1664 = confuse(f1664);
+ }
+
+ Expect.isTrue(m1664 is F1664);
+ Expect.isTrue(m1664 is Function(int y, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m1664) is F1664);
+ // In checked mode, verifies the type.
+ x1664 = m1664;
+ l1664 = m1664;
+ x1664 = confuse(m1664);
+ l1664 = confuse(m1664);
+
+ }
+
+ void testF1764() {
+ // int Function<A>() Function()
+ Expect.isTrue(f1764 is F1764);
+ Expect.isTrue(confuse(f1764) is F1764);
+ // In checked mode, verifies the type.
+ int Function<A>() Function() l1764;
+ // The static function f1764 sets `T` to `int`.
+ if (!tIsBool) {
+ x1764 = f1764 as dynamic;
+ l1764 = f1764 as dynamic;
+ x1764 = confuse(f1764);
+ l1764 = confuse(f1764);
+ }
+
+ Expect.isTrue(m1764 is F1764);
+ Expect.isTrue(m1764 is int Function<A>() Function());
+ Expect.isTrue(confuse(m1764) is F1764);
+ // In checked mode, verifies the type.
+ x1764 = m1764;
+ l1764 = m1764;
+ x1764 = confuse(m1764);
+ l1764 = confuse(m1764);
+
+ }
+
+ void testF1864() {
+ // core.List<core.int> Function<A>(A x) Function()
+ Expect.isTrue(f1864 is F1864);
+ Expect.isTrue(confuse(f1864) is F1864);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(A x) Function() l1864;
+ // The static function f1864 sets `T` to `int`.
+ if (!tIsBool) {
+ x1864 = f1864 as dynamic;
+ l1864 = f1864 as dynamic;
+ x1864 = confuse(f1864);
+ l1864 = confuse(f1864);
+ }
+
+ Expect.isTrue(m1864 is F1864);
+ Expect.isTrue(m1864 is core.List<core.int> Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1864) is F1864);
+ // In checked mode, verifies the type.
+ x1864 = m1864;
+ l1864 = m1864;
+ x1864 = confuse(m1864);
+ l1864 = confuse(m1864);
+
+ }
+
+ void testF1964() {
+ // A Function<A>(List<A> x) Function()
+ Expect.isTrue(f1964 is F1964);
+ Expect.isTrue(confuse(f1964) is F1964);
+ // In checked mode, verifies the type.
+ A Function<A>(List<A> x) Function() l1964;
+ // The static function f1964 sets `T` to `int`.
+ if (!tIsBool) {
+ x1964 = f1964 as dynamic;
+ l1964 = f1964 as dynamic;
+ x1964 = confuse(f1964);
+ l1964 = confuse(f1964);
+ }
+
+ Expect.isTrue(m1964 is F1964);
+ Expect.isTrue(m1964 is A Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1964) is F1964);
+ // In checked mode, verifies the type.
+ x1964 = m1964;
+ l1964 = m1964;
+ x1964 = confuse(m1964);
+ l1964 = confuse(m1964);
+
+ }
+
+
+}
+
+class C65<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, {int x}) x65;
+ List<Function> Function(int x0, {List<T> x}) x165;
+ List<T> Function({core.List<core.int> x}) x265;
+ core.List<core.int> Function<A>() x365;
+ int Function([Function x1]) Function(int x) x465;
+ int Function({core.List<core.int> x}) Function(int x) x565;
+ Function Function(int y, {int x}) Function(int x) x665;
+ Function Function(int x1, [core.List<core.int> x]) Function(int x) x765;
+ List<Function> Function(int x1) Function(int x) x865;
+ List<Function> Function(int x, [List<Function> x1]) Function(int x) x965;
+ List<Function> Function(int y, {List<T> x}) Function(int x) x1065;
+ core.List<core.int> Function([List<Function> x]) Function(int x) x1165;
+ core.List<core.int> Function(List<T> x1) Function(int x) x1265;
+ List<T> Function(int x2, [Function x3]) Function(int x) x1365;
+ List<T> Function(int x1, {core.List<core.int> x}) Function(int x) x1465;
+ Function(Function x) Function(int x) x1565;
+ Function(int y, [core.List<core.int> x]) Function(int x) x1665;
+ int Function<A>() Function(int x) x1765;
+ core.List<core.int> Function<A>(A x) Function(int x) x1865;
+ A Function<A>(List<A> x) Function(int x) x1965;
+
+
+ C65({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m65(int x0, {int x}) => null;
+ List<Function> m165(int x0, {List<T> x}) => null;
+ List<T> m265({core.List<core.int> x}) => null;
+ core.List<core.int> m365<A>() => null;
+ int Function([Function x0]) m465(int x) => null;
+ int Function({core.List<core.int> x}) m565(int x) => null;
+ Function Function(int y, {int x}) m665(int x) => null;
+ Function Function(int x0, [core.List<core.int> x]) m765(int x) => null;
+ List<Function> Function(int x0) m865(int x) => null;
+ List<Function> Function(int x, [List<Function> x0]) m965(int x) => null;
+ List<Function> Function(int y, {List<T> x}) m1065(int x) => null;
+ core.List<core.int> Function([List<Function> x]) m1165(int x) => null;
+ core.List<core.int> Function(List<T> x0) m1265(int x) => null;
+ List<T> Function(int x0, [Function x1]) m1365(int x) => null;
+ List<T> Function(int x0, {core.List<core.int> x}) m1465(int x) => null;
+ Function(Function x) m1565(int x) => null;
+ Function(int y, [core.List<core.int> x]) m1665(int x) => null;
+ int Function<A>() m1765(int x) => null;
+ core.List<core.int> Function<A>(A x) m1865(int x) => null;
+ A Function<A>(List<A> x) m1965(int x) => null;
+
+
+ runTests() {
+ testF65();
+ testF165();
+ testF265();
+ testF365();
+ testF465();
+ testF565();
+ testF665();
+ testF765();
+ testF865();
+ testF965();
+ testF1065();
+ testF1165();
+ testF1265();
+ testF1365();
+ testF1465();
+ testF1565();
+ testF1665();
+ testF1765();
+ testF1865();
+ testF1965();
+ }
+
+ void testF65() {
+ // Function Function(int x0, {int x})
+ Expect.isTrue(f65 is F65);
+ Expect.isTrue(confuse(f65) is F65);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {int x}) l65;
+ // The static function f65 sets `T` to `int`.
+ if (!tIsBool) {
+ x65 = f65 as dynamic;
+ l65 = f65 as dynamic;
+ x65 = confuse(f65);
+ l65 = confuse(f65);
+ }
+
+ Expect.isTrue(m65 is F65);
+ Expect.isTrue(m65 is Function Function(int x0, {int x}));
+ Expect.isTrue(confuse(m65) is F65);
+ // In checked mode, verifies the type.
+ x65 = m65;
+ l65 = m65;
+ x65 = confuse(m65);
+ l65 = confuse(m65);
+
+ }
+
+ void testF165() {
+ // List<Function> Function(int x0, {List<T> x})
+ Expect.isTrue(f165 is F165);
+ Expect.isTrue(confuse(f165) is F165);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {List<T> x}) l165;
+ // The static function f165 sets `T` to `int`.
+ if (!tIsBool) {
+ x165 = f165 as dynamic;
+ l165 = f165 as dynamic;
+ x165 = confuse(f165);
+ l165 = confuse(f165);
+ }
+
+ Expect.isTrue(m165 is F165);
+ Expect.isTrue(m165 is List<Function> Function(int x0, {List<T> x}));
+ Expect.isTrue(confuse(m165) is F165);
+ // In checked mode, verifies the type.
+ x165 = m165;
+ l165 = m165;
+ x165 = confuse(m165);
+ l165 = confuse(m165);
+ if (!tIsBool) {
+ Expect.isTrue(f165 is F165<int>);
+ Expect.isFalse(f165 is F165<bool>);
+ Expect.isTrue(confuse(f165) is F165<int>);
+ Expect.isFalse(confuse(f165) is F165<bool>);
+ Expect.equals(tIsDynamic, m165 is F165<bool>);
+ Expect.equals(tIsDynamic, confuse(m165) is F165<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x165 = (f165 as dynamic); });
+ Expect.throws(() { x165 = confuse(f165); });
+ List<Function> Function(int x0, {List<T> x}) l165;
+ Expect.throws(() { l165 = (f165 as dynamic); });
+ Expect.throws(() { l165 = confuse(f165); });
+ }
+ List<Function> Function(int x0, {List<T> x}) l165 = m165;
+ // In checked mode, verifies the type.
+ x165 = m165;
+ x165 = confuse(m165);
+ }
+ }
+
+ void testF265() {
+ // List<T> Function({core.List<core.int> x})
+ Expect.isTrue(f265 is F265);
+ Expect.isTrue(confuse(f265) is F265);
+ // In checked mode, verifies the type.
+ List<T> Function({core.List<core.int> x}) l265;
+ // The static function f265 sets `T` to `int`.
+ if (!tIsBool) {
+ x265 = f265 as dynamic;
+ l265 = f265 as dynamic;
+ x265 = confuse(f265);
+ l265 = confuse(f265);
+ }
+
+ Expect.isTrue(m265 is F265);
+ Expect.isTrue(m265 is List<T> Function({core.List<core.int> x}));
+ Expect.isTrue(confuse(m265) is F265);
+ // In checked mode, verifies the type.
+ x265 = m265;
+ l265 = m265;
+ x265 = confuse(m265);
+ l265 = confuse(m265);
+ if (!tIsBool) {
+ Expect.isTrue(f265 is F265<int>);
+ Expect.isFalse(f265 is F265<bool>);
+ Expect.isTrue(confuse(f265) is F265<int>);
+ Expect.isFalse(confuse(f265) is F265<bool>);
+ Expect.equals(tIsDynamic, m265 is F265<bool>);
+ Expect.equals(tIsDynamic, confuse(m265) is F265<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x265 = (f265 as dynamic); });
+ Expect.throws(() { x265 = confuse(f265); });
+ List<T> Function({core.List<core.int> x}) l265;
+ Expect.throws(() { l265 = (f265 as dynamic); });
+ Expect.throws(() { l265 = confuse(f265); });
+ }
+ List<T> Function({core.List<core.int> x}) l265 = m265;
+ // In checked mode, verifies the type.
+ x265 = m265;
+ x265 = confuse(m265);
+ }
+ }
+
+ void testF365() {
+ // core.List<core.int> Function<A>()
+ Expect.isTrue(f365 is F365);
+ Expect.isTrue(confuse(f365) is F365);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>() l365;
+ // The static function f365 sets `T` to `int`.
+ if (!tIsBool) {
+ x365 = f365 as dynamic;
+ l365 = f365 as dynamic;
+ x365 = confuse(f365);
+ l365 = confuse(f365);
+ }
+
+ Expect.isTrue(m365 is F365);
+ Expect.isTrue(m365 is core.List<core.int> Function<A>());
+ Expect.isTrue(confuse(m365) is F365);
+ // In checked mode, verifies the type.
+ x365 = m365;
+ l365 = m365;
+ x365 = confuse(m365);
+ l365 = confuse(m365);
+
+ }
+
+ void testF465() {
+ // int Function([Function x1]) Function(int x)
+ Expect.isTrue(f465 is F465);
+ Expect.isTrue(confuse(f465) is F465);
+ // In checked mode, verifies the type.
+ int Function([Function x1]) Function(int x) l465;
+ // The static function f465 sets `T` to `int`.
+ if (!tIsBool) {
+ x465 = f465 as dynamic;
+ l465 = f465 as dynamic;
+ x465 = confuse(f465);
+ l465 = confuse(f465);
+ }
+
+ Expect.isTrue(m465 is F465);
+ Expect.isTrue(m465 is int Function([Function x1]) Function(int x));
+ Expect.isTrue(confuse(m465) is F465);
+ // In checked mode, verifies the type.
+ x465 = m465;
+ l465 = m465;
+ x465 = confuse(m465);
+ l465 = confuse(m465);
+
+ }
+
+ void testF565() {
+ // int Function({core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f565 is F565);
+ Expect.isTrue(confuse(f565) is F565);
+ // In checked mode, verifies the type.
+ int Function({core.List<core.int> x}) Function(int x) l565;
+ // The static function f565 sets `T` to `int`.
+ if (!tIsBool) {
+ x565 = f565 as dynamic;
+ l565 = f565 as dynamic;
+ x565 = confuse(f565);
+ l565 = confuse(f565);
+ }
+
+ Expect.isTrue(m565 is F565);
+ Expect.isTrue(m565 is int Function({core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m565) is F565);
+ // In checked mode, verifies the type.
+ x565 = m565;
+ l565 = m565;
+ x565 = confuse(m565);
+ l565 = confuse(m565);
+
+ }
+
+ void testF665() {
+ // Function Function(int y, {int x}) Function(int x)
+ Expect.isTrue(f665 is F665);
+ Expect.isTrue(confuse(f665) is F665);
+ // In checked mode, verifies the type.
+ Function Function(int y, {int x}) Function(int x) l665;
+ // The static function f665 sets `T` to `int`.
+ if (!tIsBool) {
+ x665 = f665 as dynamic;
+ l665 = f665 as dynamic;
+ x665 = confuse(f665);
+ l665 = confuse(f665);
+ }
+
+ Expect.isTrue(m665 is F665);
+ Expect.isTrue(m665 is Function Function(int y, {int x}) Function(int x));
+ Expect.isTrue(confuse(m665) is F665);
+ // In checked mode, verifies the type.
+ x665 = m665;
+ l665 = m665;
+ x665 = confuse(m665);
+ l665 = confuse(m665);
+
+ }
+
+ void testF765() {
+ // Function Function(int x1, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f765 is F765);
+ Expect.isTrue(confuse(f765) is F765);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [core.List<core.int> x]) Function(int x) l765;
+ // The static function f765 sets `T` to `int`.
+ if (!tIsBool) {
+ x765 = f765 as dynamic;
+ l765 = f765 as dynamic;
+ x765 = confuse(f765);
+ l765 = confuse(f765);
+ }
+
+ Expect.isTrue(m765 is F765);
+ Expect.isTrue(m765 is Function Function(int x1, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m765) is F765);
+ // In checked mode, verifies the type.
+ x765 = m765;
+ l765 = m765;
+ x765 = confuse(m765);
+ l765 = confuse(m765);
+
+ }
+
+ void testF865() {
+ // List<Function> Function(int x1) Function(int x)
+ Expect.isTrue(f865 is F865);
+ Expect.isTrue(confuse(f865) is F865);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1) Function(int x) l865;
+ // The static function f865 sets `T` to `int`.
+ if (!tIsBool) {
+ x865 = f865 as dynamic;
+ l865 = f865 as dynamic;
+ x865 = confuse(f865);
+ l865 = confuse(f865);
+ }
+
+ Expect.isTrue(m865 is F865);
+ Expect.isTrue(m865 is List<Function> Function(int x1) Function(int x));
+ Expect.isTrue(confuse(m865) is F865);
+ // In checked mode, verifies the type.
+ x865 = m865;
+ l865 = m865;
+ x865 = confuse(m865);
+ l865 = confuse(m865);
+
+ }
+
+ void testF965() {
+ // List<Function> Function(int x, [List<Function> x1]) Function(int x)
+ Expect.isTrue(f965 is F965);
+ Expect.isTrue(confuse(f965) is F965);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<Function> x1]) Function(int x) l965;
+ // The static function f965 sets `T` to `int`.
+ if (!tIsBool) {
+ x965 = f965 as dynamic;
+ l965 = f965 as dynamic;
+ x965 = confuse(f965);
+ l965 = confuse(f965);
+ }
+
+ Expect.isTrue(m965 is F965);
+ Expect.isTrue(m965 is List<Function> Function(int x, [List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m965) is F965);
+ // In checked mode, verifies the type.
+ x965 = m965;
+ l965 = m965;
+ x965 = confuse(m965);
+ l965 = confuse(m965);
+
+ }
+
+ void testF1065() {
+ // List<Function> Function(int y, {List<T> x}) Function(int x)
+ Expect.isTrue(f1065 is F1065);
+ Expect.isTrue(confuse(f1065) is F1065);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<T> x}) Function(int x) l1065;
+ // The static function f1065 sets `T` to `int`.
+ if (!tIsBool) {
+ x1065 = f1065 as dynamic;
+ l1065 = f1065 as dynamic;
+ x1065 = confuse(f1065);
+ l1065 = confuse(f1065);
+ }
+
+ Expect.isTrue(m1065 is F1065);
+ Expect.isTrue(m1065 is List<Function> Function(int y, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1065) is F1065);
+ // In checked mode, verifies the type.
+ x1065 = m1065;
+ l1065 = m1065;
+ x1065 = confuse(m1065);
+ l1065 = confuse(m1065);
+ if (!tIsBool) {
+ Expect.isTrue(f1065 is F1065<int>);
+ Expect.isFalse(f1065 is F1065<bool>);
+ Expect.isTrue(confuse(f1065) is F1065<int>);
+ Expect.isFalse(confuse(f1065) is F1065<bool>);
+ Expect.equals(tIsDynamic, m1065 is F1065<bool>);
+ Expect.equals(tIsDynamic, confuse(m1065) is F1065<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1065 = (f1065 as dynamic); });
+ Expect.throws(() { x1065 = confuse(f1065); });
+ List<Function> Function(int y, {List<T> x}) Function(int x) l1065;
+ Expect.throws(() { l1065 = (f1065 as dynamic); });
+ Expect.throws(() { l1065 = confuse(f1065); });
+ }
+ List<Function> Function(int y, {List<T> x}) Function(int x) l1065 = m1065;
+ // In checked mode, verifies the type.
+ x1065 = m1065;
+ x1065 = confuse(m1065);
+ }
+ }
+
+ void testF1165() {
+ // core.List<core.int> Function([List<Function> x]) Function(int x)
+ Expect.isTrue(f1165 is F1165);
+ Expect.isTrue(confuse(f1165) is F1165);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x]) Function(int x) l1165;
+ // The static function f1165 sets `T` to `int`.
+ if (!tIsBool) {
+ x1165 = f1165 as dynamic;
+ l1165 = f1165 as dynamic;
+ x1165 = confuse(f1165);
+ l1165 = confuse(f1165);
+ }
+
+ Expect.isTrue(m1165 is F1165);
+ Expect.isTrue(m1165 is core.List<core.int> Function([List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1165) is F1165);
+ // In checked mode, verifies the type.
+ x1165 = m1165;
+ l1165 = m1165;
+ x1165 = confuse(m1165);
+ l1165 = confuse(m1165);
+
+ }
+
+ void testF1265() {
+ // core.List<core.int> Function(List<T> x1) Function(int x)
+ Expect.isTrue(f1265 is F1265);
+ Expect.isTrue(confuse(f1265) is F1265);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x1) Function(int x) l1265;
+ // The static function f1265 sets `T` to `int`.
+ if (!tIsBool) {
+ x1265 = f1265 as dynamic;
+ l1265 = f1265 as dynamic;
+ x1265 = confuse(f1265);
+ l1265 = confuse(f1265);
+ }
+
+ Expect.isTrue(m1265 is F1265);
+ Expect.isTrue(m1265 is core.List<core.int> Function(List<T> x1) Function(int x));
+ Expect.isTrue(confuse(m1265) is F1265);
+ // In checked mode, verifies the type.
+ x1265 = m1265;
+ l1265 = m1265;
+ x1265 = confuse(m1265);
+ l1265 = confuse(m1265);
+ if (!tIsBool) {
+ Expect.isTrue(f1265 is F1265<int>);
+ Expect.isFalse(f1265 is F1265<bool>);
+ Expect.isTrue(confuse(f1265) is F1265<int>);
+ Expect.isFalse(confuse(f1265) is F1265<bool>);
+ Expect.equals(tIsDynamic, m1265 is F1265<bool>);
+ Expect.equals(tIsDynamic, confuse(m1265) is F1265<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1265 = (f1265 as dynamic); });
+ Expect.throws(() { x1265 = confuse(f1265); });
+ core.List<core.int> Function(List<T> x1) Function(int x) l1265;
+ Expect.throws(() { l1265 = (f1265 as dynamic); });
+ Expect.throws(() { l1265 = confuse(f1265); });
+ }
+ core.List<core.int> Function(List<T> x1) Function(int x) l1265 = m1265;
+ // In checked mode, verifies the type.
+ x1265 = m1265;
+ x1265 = confuse(m1265);
+ }
+ }
+
+ void testF1365() {
+ // List<T> Function(int x2, [Function x3]) Function(int x)
+ Expect.isTrue(f1365 is F1365);
+ Expect.isTrue(confuse(f1365) is F1365);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [Function x3]) Function(int x) l1365;
+ // The static function f1365 sets `T` to `int`.
+ if (!tIsBool) {
+ x1365 = f1365 as dynamic;
+ l1365 = f1365 as dynamic;
+ x1365 = confuse(f1365);
+ l1365 = confuse(f1365);
+ }
+
+ Expect.isTrue(m1365 is F1365);
+ Expect.isTrue(m1365 is List<T> Function(int x2, [Function x3]) Function(int x));
+ Expect.isTrue(confuse(m1365) is F1365);
+ // In checked mode, verifies the type.
+ x1365 = m1365;
+ l1365 = m1365;
+ x1365 = confuse(m1365);
+ l1365 = confuse(m1365);
+ if (!tIsBool) {
+ Expect.isTrue(f1365 is F1365<int>);
+ Expect.isFalse(f1365 is F1365<bool>);
+ Expect.isTrue(confuse(f1365) is F1365<int>);
+ Expect.isFalse(confuse(f1365) is F1365<bool>);
+ Expect.equals(tIsDynamic, m1365 is F1365<bool>);
+ Expect.equals(tIsDynamic, confuse(m1365) is F1365<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1365 = (f1365 as dynamic); });
+ Expect.throws(() { x1365 = confuse(f1365); });
+ List<T> Function(int x2, [Function x3]) Function(int x) l1365;
+ Expect.throws(() { l1365 = (f1365 as dynamic); });
+ Expect.throws(() { l1365 = confuse(f1365); });
+ }
+ List<T> Function(int x2, [Function x3]) Function(int x) l1365 = m1365;
+ // In checked mode, verifies the type.
+ x1365 = m1365;
+ x1365 = confuse(m1365);
+ }
+ }
+
+ void testF1465() {
+ // List<T> Function(int x1, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1465 is F1465);
+ Expect.isTrue(confuse(f1465) is F1465);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {core.List<core.int> x}) Function(int x) l1465;
+ // The static function f1465 sets `T` to `int`.
+ if (!tIsBool) {
+ x1465 = f1465 as dynamic;
+ l1465 = f1465 as dynamic;
+ x1465 = confuse(f1465);
+ l1465 = confuse(f1465);
+ }
+
+ Expect.isTrue(m1465 is F1465);
+ Expect.isTrue(m1465 is List<T> Function(int x1, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1465) is F1465);
+ // In checked mode, verifies the type.
+ x1465 = m1465;
+ l1465 = m1465;
+ x1465 = confuse(m1465);
+ l1465 = confuse(m1465);
+ if (!tIsBool) {
+ Expect.isTrue(f1465 is F1465<int>);
+ Expect.isFalse(f1465 is F1465<bool>);
+ Expect.isTrue(confuse(f1465) is F1465<int>);
+ Expect.isFalse(confuse(f1465) is F1465<bool>);
+ Expect.equals(tIsDynamic, m1465 is F1465<bool>);
+ Expect.equals(tIsDynamic, confuse(m1465) is F1465<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1465 = (f1465 as dynamic); });
+ Expect.throws(() { x1465 = confuse(f1465); });
+ List<T> Function(int x1, {core.List<core.int> x}) Function(int x) l1465;
+ Expect.throws(() { l1465 = (f1465 as dynamic); });
+ Expect.throws(() { l1465 = confuse(f1465); });
+ }
+ List<T> Function(int x1, {core.List<core.int> x}) Function(int x) l1465 = m1465;
+ // In checked mode, verifies the type.
+ x1465 = m1465;
+ x1465 = confuse(m1465);
+ }
+ }
+
+ void testF1565() {
+ // Function(Function x) Function(int x)
+ Expect.isTrue(f1565 is F1565);
+ Expect.isTrue(confuse(f1565) is F1565);
+ // In checked mode, verifies the type.
+ Function(Function x) Function(int x) l1565;
+ // The static function f1565 sets `T` to `int`.
+ if (!tIsBool) {
+ x1565 = f1565 as dynamic;
+ l1565 = f1565 as dynamic;
+ x1565 = confuse(f1565);
+ l1565 = confuse(f1565);
+ }
+
+ Expect.isTrue(m1565 is F1565);
+ Expect.isTrue(m1565 is Function(Function x) Function(int x));
+ Expect.isTrue(confuse(m1565) is F1565);
+ // In checked mode, verifies the type.
+ x1565 = m1565;
+ l1565 = m1565;
+ x1565 = confuse(m1565);
+ l1565 = confuse(m1565);
+
+ }
+
+ void testF1665() {
+ // Function(int y, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f1665 is F1665);
+ Expect.isTrue(confuse(f1665) is F1665);
+ // In checked mode, verifies the type.
+ Function(int y, [core.List<core.int> x]) Function(int x) l1665;
+ // The static function f1665 sets `T` to `int`.
+ if (!tIsBool) {
+ x1665 = f1665 as dynamic;
+ l1665 = f1665 as dynamic;
+ x1665 = confuse(f1665);
+ l1665 = confuse(f1665);
+ }
+
+ Expect.isTrue(m1665 is F1665);
+ Expect.isTrue(m1665 is Function(int y, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m1665) is F1665);
+ // In checked mode, verifies the type.
+ x1665 = m1665;
+ l1665 = m1665;
+ x1665 = confuse(m1665);
+ l1665 = confuse(m1665);
+
+ }
+
+ void testF1765() {
+ // int Function<A>() Function(int x)
+ Expect.isTrue(f1765 is F1765);
+ Expect.isTrue(confuse(f1765) is F1765);
+ // In checked mode, verifies the type.
+ int Function<A>() Function(int x) l1765;
+ // The static function f1765 sets `T` to `int`.
+ if (!tIsBool) {
+ x1765 = f1765 as dynamic;
+ l1765 = f1765 as dynamic;
+ x1765 = confuse(f1765);
+ l1765 = confuse(f1765);
+ }
+
+ Expect.isTrue(m1765 is F1765);
+ Expect.isTrue(m1765 is int Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1765) is F1765);
+ // In checked mode, verifies the type.
+ x1765 = m1765;
+ l1765 = m1765;
+ x1765 = confuse(m1765);
+ l1765 = confuse(m1765);
+
+ }
+
+ void testF1865() {
+ // core.List<core.int> Function<A>(A x) Function(int x)
+ Expect.isTrue(f1865 is F1865);
+ Expect.isTrue(confuse(f1865) is F1865);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(A x) Function(int x) l1865;
+ // The static function f1865 sets `T` to `int`.
+ if (!tIsBool) {
+ x1865 = f1865 as dynamic;
+ l1865 = f1865 as dynamic;
+ x1865 = confuse(f1865);
+ l1865 = confuse(f1865);
+ }
+
+ Expect.isTrue(m1865 is F1865);
+ Expect.isTrue(m1865 is core.List<core.int> Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1865) is F1865);
+ // In checked mode, verifies the type.
+ x1865 = m1865;
+ l1865 = m1865;
+ x1865 = confuse(m1865);
+ l1865 = confuse(m1865);
+
+ }
+
+ void testF1965() {
+ // A Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1965 is F1965);
+ Expect.isTrue(confuse(f1965) is F1965);
+ // In checked mode, verifies the type.
+ A Function<A>(List<A> x) Function(int x) l1965;
+ // The static function f1965 sets `T` to `int`.
+ if (!tIsBool) {
+ x1965 = f1965 as dynamic;
+ l1965 = f1965 as dynamic;
+ x1965 = confuse(f1965);
+ l1965 = confuse(f1965);
+ }
+
+ Expect.isTrue(m1965 is F1965);
+ Expect.isTrue(m1965 is A Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1965) is F1965);
+ // In checked mode, verifies the type.
+ x1965 = m1965;
+ l1965 = m1965;
+ x1965 = confuse(m1965);
+ l1965 = confuse(m1965);
+
+ }
+
+
+}
+
+class C66<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, {int x}) x66;
+ List<Function> Function(int y, {List<T> x}) x166;
+ List<T> Function(int x0, {core.List<core.int> x}) x266;
+ core.List<core.int> Function<A>(A x) x366;
+ int Function([Function x1]) Function<B extends core.int>() x466;
+ int Function({core.List<core.int> x}) Function<B extends core.int>() x566;
+ Function Function(int y, {int x}) Function<B extends core.int>() x666;
+ Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() x766;
+ List<Function> Function(int x1) Function<B extends core.int>() x866;
+ List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>() x966;
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>() x1066;
+ core.List<core.int> Function([List<Function> x]) Function<B extends core.int>() x1166;
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>() x1266;
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>() x1366;
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() x1466;
+ Function(Function x) Function<B extends core.int>() x1566;
+ Function(int y, [core.List<core.int> x]) Function<B extends core.int>() x1666;
+ int Function<A>() Function<B extends core.int>() x1766;
+ core.List<core.int> Function<A>(A x) Function<B extends core.int>() x1866;
+ A Function<A>(List<A> x) Function<B extends core.int>() x1966;
+
+
+ C66({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m66(int y, {int x}) => null;
+ List<Function> m166(int y, {List<T> x}) => null;
+ List<T> m266(int x0, {core.List<core.int> x}) => null;
+ core.List<core.int> m366<A>(A x) => null;
+ int Function([Function x0]) m466<B extends core.int>() => null;
+ int Function({core.List<core.int> x}) m566<B extends core.int>() => null;
+ Function Function(int y, {int x}) m666<B extends core.int>() => null;
+ Function Function(int x0, [core.List<core.int> x]) m766<B extends core.int>() => null;
+ List<Function> Function(int x0) m866<B extends core.int>() => null;
+ List<Function> Function(int x, [List<Function> x0]) m966<B extends core.int>() => null;
+ List<Function> Function(int y, {List<T> x}) m1066<B extends core.int>() => null;
+ core.List<core.int> Function([List<Function> x]) m1166<B extends core.int>() => null;
+ core.List<core.int> Function(List<T> x0) m1266<B extends core.int>() => null;
+ List<T> Function(int x0, [Function x1]) m1366<B extends core.int>() => null;
+ List<T> Function(int x0, {core.List<core.int> x}) m1466<B extends core.int>() => null;
+ Function(Function x) m1566<B extends core.int>() => null;
+ Function(int y, [core.List<core.int> x]) m1666<B extends core.int>() => null;
+ int Function<A>() m1766<B extends core.int>() => null;
+ core.List<core.int> Function<A>(A x) m1866<B extends core.int>() => null;
+ A Function<A>(List<A> x) m1966<B extends core.int>() => null;
+
+
+ runTests() {
+ testF66();
+ testF166();
+ testF266();
+ testF366();
+ testF466();
+ testF566();
+ testF666();
+ testF766();
+ testF866();
+ testF966();
+ testF1066();
+ testF1166();
+ testF1266();
+ testF1366();
+ testF1466();
+ testF1566();
+ testF1666();
+ testF1766();
+ testF1866();
+ testF1966();
+ }
+
+ void testF66() {
+ // Function Function(int y, {int x})
+ Expect.isTrue(f66 is F66);
+ Expect.isTrue(confuse(f66) is F66);
+ // In checked mode, verifies the type.
+ Function Function(int y, {int x}) l66;
+ // The static function f66 sets `T` to `int`.
+ if (!tIsBool) {
+ x66 = f66 as dynamic;
+ l66 = f66 as dynamic;
+ x66 = confuse(f66);
+ l66 = confuse(f66);
+ }
+
+ Expect.isTrue(m66 is F66);
+ Expect.isTrue(m66 is Function Function(int y, {int x}));
+ Expect.isTrue(confuse(m66) is F66);
+ // In checked mode, verifies the type.
+ x66 = m66;
+ l66 = m66;
+ x66 = confuse(m66);
+ l66 = confuse(m66);
+
+ }
+
+ void testF166() {
+ // List<Function> Function(int y, {List<T> x})
+ Expect.isTrue(f166 is F166);
+ Expect.isTrue(confuse(f166) is F166);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<T> x}) l166;
+ // The static function f166 sets `T` to `int`.
+ if (!tIsBool) {
+ x166 = f166 as dynamic;
+ l166 = f166 as dynamic;
+ x166 = confuse(f166);
+ l166 = confuse(f166);
+ }
+
+ Expect.isTrue(m166 is F166);
+ Expect.isTrue(m166 is List<Function> Function(int y, {List<T> x}));
+ Expect.isTrue(confuse(m166) is F166);
+ // In checked mode, verifies the type.
+ x166 = m166;
+ l166 = m166;
+ x166 = confuse(m166);
+ l166 = confuse(m166);
+ if (!tIsBool) {
+ Expect.isTrue(f166 is F166<int>);
+ Expect.isFalse(f166 is F166<bool>);
+ Expect.isTrue(confuse(f166) is F166<int>);
+ Expect.isFalse(confuse(f166) is F166<bool>);
+ Expect.equals(tIsDynamic, m166 is F166<bool>);
+ Expect.equals(tIsDynamic, confuse(m166) is F166<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x166 = (f166 as dynamic); });
+ Expect.throws(() { x166 = confuse(f166); });
+ List<Function> Function(int y, {List<T> x}) l166;
+ Expect.throws(() { l166 = (f166 as dynamic); });
+ Expect.throws(() { l166 = confuse(f166); });
+ }
+ List<Function> Function(int y, {List<T> x}) l166 = m166;
+ // In checked mode, verifies the type.
+ x166 = m166;
+ x166 = confuse(m166);
+ }
+ }
+
+ void testF266() {
+ // List<T> Function(int x0, {core.List<core.int> x})
+ Expect.isTrue(f266 is F266);
+ Expect.isTrue(confuse(f266) is F266);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {core.List<core.int> x}) l266;
+ // The static function f266 sets `T` to `int`.
+ if (!tIsBool) {
+ x266 = f266 as dynamic;
+ l266 = f266 as dynamic;
+ x266 = confuse(f266);
+ l266 = confuse(f266);
+ }
+
+ Expect.isTrue(m266 is F266);
+ Expect.isTrue(m266 is List<T> Function(int x0, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m266) is F266);
+ // In checked mode, verifies the type.
+ x266 = m266;
+ l266 = m266;
+ x266 = confuse(m266);
+ l266 = confuse(m266);
+ if (!tIsBool) {
+ Expect.isTrue(f266 is F266<int>);
+ Expect.isFalse(f266 is F266<bool>);
+ Expect.isTrue(confuse(f266) is F266<int>);
+ Expect.isFalse(confuse(f266) is F266<bool>);
+ Expect.equals(tIsDynamic, m266 is F266<bool>);
+ Expect.equals(tIsDynamic, confuse(m266) is F266<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x266 = (f266 as dynamic); });
+ Expect.throws(() { x266 = confuse(f266); });
+ List<T> Function(int x0, {core.List<core.int> x}) l266;
+ Expect.throws(() { l266 = (f266 as dynamic); });
+ Expect.throws(() { l266 = confuse(f266); });
+ }
+ List<T> Function(int x0, {core.List<core.int> x}) l266 = m266;
+ // In checked mode, verifies the type.
+ x266 = m266;
+ x266 = confuse(m266);
+ }
+ }
+
+ void testF366() {
+ // core.List<core.int> Function<A>(A x)
+ Expect.isTrue(f366 is F366);
+ Expect.isTrue(confuse(f366) is F366);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(A x) l366;
+ // The static function f366 sets `T` to `int`.
+ if (!tIsBool) {
+ x366 = f366 as dynamic;
+ l366 = f366 as dynamic;
+ x366 = confuse(f366);
+ l366 = confuse(f366);
+ }
+
+ Expect.isTrue(m366 is F366);
+ Expect.isTrue(m366 is core.List<core.int> Function<A>(A x));
+ Expect.isTrue(confuse(m366) is F366);
+ // In checked mode, verifies the type.
+ x366 = m366;
+ l366 = m366;
+ x366 = confuse(m366);
+ l366 = confuse(m366);
+
+ }
+
+ void testF466() {
+ // int Function([Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f466 is F466);
+ Expect.isTrue(confuse(f466) is F466);
+ // In checked mode, verifies the type.
+ int Function([Function x1]) Function<B extends core.int>() l466;
+ // The static function f466 sets `T` to `int`.
+ if (!tIsBool) {
+ x466 = f466 as dynamic;
+ l466 = f466 as dynamic;
+ x466 = confuse(f466);
+ l466 = confuse(f466);
+ }
+
+ Expect.isTrue(m466 is F466);
+ Expect.isTrue(m466 is int Function([Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m466) is F466);
+ // In checked mode, verifies the type.
+ x466 = m466;
+ l466 = m466;
+ x466 = confuse(m466);
+ l466 = confuse(m466);
+
+ }
+
+ void testF566() {
+ // int Function({core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f566 is F566);
+ Expect.isTrue(confuse(f566) is F566);
+ // In checked mode, verifies the type.
+ int Function({core.List<core.int> x}) Function<B extends core.int>() l566;
+ // The static function f566 sets `T` to `int`.
+ if (!tIsBool) {
+ x566 = f566 as dynamic;
+ l566 = f566 as dynamic;
+ x566 = confuse(f566);
+ l566 = confuse(f566);
+ }
+
+ Expect.isTrue(m566 is F566);
+ Expect.isTrue(m566 is int Function({core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m566) is F566);
+ // In checked mode, verifies the type.
+ x566 = m566;
+ l566 = m566;
+ x566 = confuse(m566);
+ l566 = confuse(m566);
+
+ }
+
+ void testF666() {
+ // Function Function(int y, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f666 is F666);
+ Expect.isTrue(confuse(f666) is F666);
+ // In checked mode, verifies the type.
+ Function Function(int y, {int x}) Function<B extends core.int>() l666;
+ // The static function f666 sets `T` to `int`.
+ if (!tIsBool) {
+ x666 = f666 as dynamic;
+ l666 = f666 as dynamic;
+ x666 = confuse(f666);
+ l666 = confuse(f666);
+ }
+
+ Expect.isTrue(m666 is F666);
+ Expect.isTrue(m666 is Function Function(int y, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m666) is F666);
+ // In checked mode, verifies the type.
+ x666 = m666;
+ l666 = m666;
+ x666 = confuse(m666);
+ l666 = confuse(m666);
+
+ }
+
+ void testF766() {
+ // Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f766 is F766);
+ Expect.isTrue(confuse(f766) is F766);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l766;
+ // The static function f766 sets `T` to `int`.
+ if (!tIsBool) {
+ x766 = f766 as dynamic;
+ l766 = f766 as dynamic;
+ x766 = confuse(f766);
+ l766 = confuse(f766);
+ }
+
+ Expect.isTrue(m766 is F766);
+ Expect.isTrue(m766 is Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m766) is F766);
+ // In checked mode, verifies the type.
+ x766 = m766;
+ l766 = m766;
+ x766 = confuse(m766);
+ l766 = confuse(m766);
+
+ }
+
+ void testF866() {
+ // List<Function> Function(int x1) Function<B extends core.int>()
+ Expect.isTrue(f866 is F866);
+ Expect.isTrue(confuse(f866) is F866);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1) Function<B extends core.int>() l866;
+ // The static function f866 sets `T` to `int`.
+ if (!tIsBool) {
+ x866 = f866 as dynamic;
+ l866 = f866 as dynamic;
+ x866 = confuse(f866);
+ l866 = confuse(f866);
+ }
+
+ Expect.isTrue(m866 is F866);
+ Expect.isTrue(m866 is List<Function> Function(int x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m866) is F866);
+ // In checked mode, verifies the type.
+ x866 = m866;
+ l866 = m866;
+ x866 = confuse(m866);
+ l866 = confuse(m866);
+
+ }
+
+ void testF966() {
+ // List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f966 is F966);
+ Expect.isTrue(confuse(f966) is F966);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>() l966;
+ // The static function f966 sets `T` to `int`.
+ if (!tIsBool) {
+ x966 = f966 as dynamic;
+ l966 = f966 as dynamic;
+ x966 = confuse(f966);
+ l966 = confuse(f966);
+ }
+
+ Expect.isTrue(m966 is F966);
+ Expect.isTrue(m966 is List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m966) is F966);
+ // In checked mode, verifies the type.
+ x966 = m966;
+ l966 = m966;
+ x966 = confuse(m966);
+ l966 = confuse(m966);
+
+ }
+
+ void testF1066() {
+ // List<Function> Function(int y, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1066 is F1066);
+ Expect.isTrue(confuse(f1066) is F1066);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>() l1066;
+ // The static function f1066 sets `T` to `int`.
+ if (!tIsBool) {
+ x1066 = f1066 as dynamic;
+ l1066 = f1066 as dynamic;
+ x1066 = confuse(f1066);
+ l1066 = confuse(f1066);
+ }
+
+ Expect.isTrue(m1066 is F1066);
+ Expect.isTrue(m1066 is List<Function> Function(int y, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1066) is F1066);
+ // In checked mode, verifies the type.
+ x1066 = m1066;
+ l1066 = m1066;
+ x1066 = confuse(m1066);
+ l1066 = confuse(m1066);
+ if (!tIsBool) {
+ Expect.isTrue(f1066 is F1066<int>);
+ Expect.isFalse(f1066 is F1066<bool>);
+ Expect.isTrue(confuse(f1066) is F1066<int>);
+ Expect.isFalse(confuse(f1066) is F1066<bool>);
+ Expect.equals(tIsDynamic, m1066 is F1066<bool>);
+ Expect.equals(tIsDynamic, confuse(m1066) is F1066<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1066 = (f1066 as dynamic); });
+ Expect.throws(() { x1066 = confuse(f1066); });
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>() l1066;
+ Expect.throws(() { l1066 = (f1066 as dynamic); });
+ Expect.throws(() { l1066 = confuse(f1066); });
+ }
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>() l1066 = m1066;
+ // In checked mode, verifies the type.
+ x1066 = m1066;
+ x1066 = confuse(m1066);
+ }
+ }
+
+ void testF1166() {
+ // core.List<core.int> Function([List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1166 is F1166);
+ Expect.isTrue(confuse(f1166) is F1166);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x]) Function<B extends core.int>() l1166;
+ // The static function f1166 sets `T` to `int`.
+ if (!tIsBool) {
+ x1166 = f1166 as dynamic;
+ l1166 = f1166 as dynamic;
+ x1166 = confuse(f1166);
+ l1166 = confuse(f1166);
+ }
+
+ Expect.isTrue(m1166 is F1166);
+ Expect.isTrue(m1166 is core.List<core.int> Function([List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1166) is F1166);
+ // In checked mode, verifies the type.
+ x1166 = m1166;
+ l1166 = m1166;
+ x1166 = confuse(m1166);
+ l1166 = confuse(m1166);
+
+ }
+
+ void testF1266() {
+ // core.List<core.int> Function(List<T> x1) Function<B extends core.int>()
+ Expect.isTrue(f1266 is F1266);
+ Expect.isTrue(confuse(f1266) is F1266);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>() l1266;
+ // The static function f1266 sets `T` to `int`.
+ if (!tIsBool) {
+ x1266 = f1266 as dynamic;
+ l1266 = f1266 as dynamic;
+ x1266 = confuse(f1266);
+ l1266 = confuse(f1266);
+ }
+
+ Expect.isTrue(m1266 is F1266);
+ Expect.isTrue(m1266 is core.List<core.int> Function(List<T> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1266) is F1266);
+ // In checked mode, verifies the type.
+ x1266 = m1266;
+ l1266 = m1266;
+ x1266 = confuse(m1266);
+ l1266 = confuse(m1266);
+ if (!tIsBool) {
+ Expect.isTrue(f1266 is F1266<int>);
+ Expect.isFalse(f1266 is F1266<bool>);
+ Expect.isTrue(confuse(f1266) is F1266<int>);
+ Expect.isFalse(confuse(f1266) is F1266<bool>);
+ Expect.equals(tIsDynamic, m1266 is F1266<bool>);
+ Expect.equals(tIsDynamic, confuse(m1266) is F1266<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1266 = (f1266 as dynamic); });
+ Expect.throws(() { x1266 = confuse(f1266); });
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>() l1266;
+ Expect.throws(() { l1266 = (f1266 as dynamic); });
+ Expect.throws(() { l1266 = confuse(f1266); });
+ }
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>() l1266 = m1266;
+ // In checked mode, verifies the type.
+ x1266 = m1266;
+ x1266 = confuse(m1266);
+ }
+ }
+
+ void testF1366() {
+ // List<T> Function(int x2, [Function x3]) Function<B extends core.int>()
+ Expect.isTrue(f1366 is F1366);
+ Expect.isTrue(confuse(f1366) is F1366);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>() l1366;
+ // The static function f1366 sets `T` to `int`.
+ if (!tIsBool) {
+ x1366 = f1366 as dynamic;
+ l1366 = f1366 as dynamic;
+ x1366 = confuse(f1366);
+ l1366 = confuse(f1366);
+ }
+
+ Expect.isTrue(m1366 is F1366);
+ Expect.isTrue(m1366 is List<T> Function(int x2, [Function x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1366) is F1366);
+ // In checked mode, verifies the type.
+ x1366 = m1366;
+ l1366 = m1366;
+ x1366 = confuse(m1366);
+ l1366 = confuse(m1366);
+ if (!tIsBool) {
+ Expect.isTrue(f1366 is F1366<int>);
+ Expect.isFalse(f1366 is F1366<bool>);
+ Expect.isTrue(confuse(f1366) is F1366<int>);
+ Expect.isFalse(confuse(f1366) is F1366<bool>);
+ Expect.equals(tIsDynamic, m1366 is F1366<bool>);
+ Expect.equals(tIsDynamic, confuse(m1366) is F1366<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1366 = (f1366 as dynamic); });
+ Expect.throws(() { x1366 = confuse(f1366); });
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>() l1366;
+ Expect.throws(() { l1366 = (f1366 as dynamic); });
+ Expect.throws(() { l1366 = confuse(f1366); });
+ }
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>() l1366 = m1366;
+ // In checked mode, verifies the type.
+ x1366 = m1366;
+ x1366 = confuse(m1366);
+ }
+ }
+
+ void testF1466() {
+ // List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1466 is F1466);
+ Expect.isTrue(confuse(f1466) is F1466);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l1466;
+ // The static function f1466 sets `T` to `int`.
+ if (!tIsBool) {
+ x1466 = f1466 as dynamic;
+ l1466 = f1466 as dynamic;
+ x1466 = confuse(f1466);
+ l1466 = confuse(f1466);
+ }
+
+ Expect.isTrue(m1466 is F1466);
+ Expect.isTrue(m1466 is List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1466) is F1466);
+ // In checked mode, verifies the type.
+ x1466 = m1466;
+ l1466 = m1466;
+ x1466 = confuse(m1466);
+ l1466 = confuse(m1466);
+ if (!tIsBool) {
+ Expect.isTrue(f1466 is F1466<int>);
+ Expect.isFalse(f1466 is F1466<bool>);
+ Expect.isTrue(confuse(f1466) is F1466<int>);
+ Expect.isFalse(confuse(f1466) is F1466<bool>);
+ Expect.equals(tIsDynamic, m1466 is F1466<bool>);
+ Expect.equals(tIsDynamic, confuse(m1466) is F1466<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1466 = (f1466 as dynamic); });
+ Expect.throws(() { x1466 = confuse(f1466); });
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l1466;
+ Expect.throws(() { l1466 = (f1466 as dynamic); });
+ Expect.throws(() { l1466 = confuse(f1466); });
+ }
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l1466 = m1466;
+ // In checked mode, verifies the type.
+ x1466 = m1466;
+ x1466 = confuse(m1466);
+ }
+ }
+
+ void testF1566() {
+ // Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1566 is F1566);
+ Expect.isTrue(confuse(f1566) is F1566);
+ // In checked mode, verifies the type.
+ Function(Function x) Function<B extends core.int>() l1566;
+ // The static function f1566 sets `T` to `int`.
+ if (!tIsBool) {
+ x1566 = f1566 as dynamic;
+ l1566 = f1566 as dynamic;
+ x1566 = confuse(f1566);
+ l1566 = confuse(f1566);
+ }
+
+ Expect.isTrue(m1566 is F1566);
+ Expect.isTrue(m1566 is Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1566) is F1566);
+ // In checked mode, verifies the type.
+ x1566 = m1566;
+ l1566 = m1566;
+ x1566 = confuse(m1566);
+ l1566 = confuse(m1566);
+
+ }
+
+ void testF1666() {
+ // Function(int y, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f1666 is F1666);
+ Expect.isTrue(confuse(f1666) is F1666);
+ // In checked mode, verifies the type.
+ Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l1666;
+ // The static function f1666 sets `T` to `int`.
+ if (!tIsBool) {
+ x1666 = f1666 as dynamic;
+ l1666 = f1666 as dynamic;
+ x1666 = confuse(f1666);
+ l1666 = confuse(f1666);
+ }
+
+ Expect.isTrue(m1666 is F1666);
+ Expect.isTrue(m1666 is Function(int y, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1666) is F1666);
+ // In checked mode, verifies the type.
+ x1666 = m1666;
+ l1666 = m1666;
+ x1666 = confuse(m1666);
+ l1666 = confuse(m1666);
+
+ }
+
+ void testF1766() {
+ // int Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1766 is F1766);
+ Expect.isTrue(confuse(f1766) is F1766);
+ // In checked mode, verifies the type.
+ int Function<A>() Function<B extends core.int>() l1766;
+ // The static function f1766 sets `T` to `int`.
+ if (!tIsBool) {
+ x1766 = f1766 as dynamic;
+ l1766 = f1766 as dynamic;
+ x1766 = confuse(f1766);
+ l1766 = confuse(f1766);
+ }
+
+ Expect.isTrue(m1766 is F1766);
+ Expect.isTrue(m1766 is int Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1766) is F1766);
+ // In checked mode, verifies the type.
+ x1766 = m1766;
+ l1766 = m1766;
+ x1766 = confuse(m1766);
+ l1766 = confuse(m1766);
+
+ }
+
+ void testF1866() {
+ // core.List<core.int> Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1866 is F1866);
+ Expect.isTrue(confuse(f1866) is F1866);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(A x) Function<B extends core.int>() l1866;
+ // The static function f1866 sets `T` to `int`.
+ if (!tIsBool) {
+ x1866 = f1866 as dynamic;
+ l1866 = f1866 as dynamic;
+ x1866 = confuse(f1866);
+ l1866 = confuse(f1866);
+ }
+
+ Expect.isTrue(m1866 is F1866);
+ Expect.isTrue(m1866 is core.List<core.int> Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1866) is F1866);
+ // In checked mode, verifies the type.
+ x1866 = m1866;
+ l1866 = m1866;
+ x1866 = confuse(m1866);
+ l1866 = confuse(m1866);
+
+ }
+
+ void testF1966() {
+ // A Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1966 is F1966);
+ Expect.isTrue(confuse(f1966) is F1966);
+ // In checked mode, verifies the type.
+ A Function<A>(List<A> x) Function<B extends core.int>() l1966;
+ // The static function f1966 sets `T` to `int`.
+ if (!tIsBool) {
+ x1966 = f1966 as dynamic;
+ l1966 = f1966 as dynamic;
+ x1966 = confuse(f1966);
+ l1966 = confuse(f1966);
+ }
+
+ Expect.isTrue(m1966 is F1966);
+ Expect.isTrue(m1966 is A Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1966) is F1966);
+ // In checked mode, verifies the type.
+ x1966 = m1966;
+ l1966 = m1966;
+ x1966 = confuse(m1966);
+ l1966 = confuse(m1966);
+
+ }
+
+
+}
+
+class C67<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(Function x) x67;
+ List<Function> Function() x167;
+ List<T> Function(int y, {core.List<core.int> x}) x267;
+ core.List<core.int> Function<A>(List<A> x) x367;
+ int Function([Function x1]) Function<B extends core.int>(int x) x467;
+ int Function({core.List<core.int> x}) Function<B extends core.int>(int x) x567;
+ Function Function(int y, {int x}) Function<B extends core.int>(int x) x667;
+ Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) x767;
+ List<Function> Function(int x1) Function<B extends core.int>(int x) x867;
+ List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) x967;
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x) x1067;
+ core.List<core.int> Function([List<Function> x]) Function<B extends core.int>(int x) x1167;
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x) x1267;
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x) x1367;
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) x1467;
+ Function(Function x) Function<B extends core.int>(int x) x1567;
+ Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) x1667;
+ int Function<A>() Function<B extends core.int>(int x) x1767;
+ core.List<core.int> Function<A>(A x) Function<B extends core.int>(int x) x1867;
+ A Function<A>(List<A> x) Function<B extends core.int>(int x) x1967;
+
+
+ C67({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m67(Function x) => null;
+ List<Function> m167() => null;
+ List<T> m267(int y, {core.List<core.int> x}) => null;
+ core.List<core.int> m367<A>(List<A> x) => null;
+ int Function([Function x0]) m467<B extends core.int>(int x) => null;
+ int Function({core.List<core.int> x}) m567<B extends core.int>(int x) => null;
+ Function Function(int y, {int x}) m667<B extends core.int>(int x) => null;
+ Function Function(int x0, [core.List<core.int> x]) m767<B extends core.int>(int x) => null;
+ List<Function> Function(int x0) m867<B extends core.int>(int x) => null;
+ List<Function> Function(int x, [List<Function> x0]) m967<B extends core.int>(int x) => null;
+ List<Function> Function(int y, {List<T> x}) m1067<B extends core.int>(int x) => null;
+ core.List<core.int> Function([List<Function> x]) m1167<B extends core.int>(int x) => null;
+ core.List<core.int> Function(List<T> x0) m1267<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [Function x1]) m1367<B extends core.int>(int x) => null;
+ List<T> Function(int x0, {core.List<core.int> x}) m1467<B extends core.int>(int x) => null;
+ Function(Function x) m1567<B extends core.int>(int x) => null;
+ Function(int y, [core.List<core.int> x]) m1667<B extends core.int>(int x) => null;
+ int Function<A>() m1767<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(A x) m1867<B extends core.int>(int x) => null;
+ A Function<A>(List<A> x) m1967<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF67();
+ testF167();
+ testF267();
+ testF367();
+ testF467();
+ testF567();
+ testF667();
+ testF767();
+ testF867();
+ testF967();
+ testF1067();
+ testF1167();
+ testF1267();
+ testF1367();
+ testF1467();
+ testF1567();
+ testF1667();
+ testF1767();
+ testF1867();
+ testF1967();
+ }
+
+ void testF67() {
+ // Function Function(Function x)
+ Expect.isTrue(f67 is F67);
+ Expect.isTrue(confuse(f67) is F67);
+ // In checked mode, verifies the type.
+ Function Function(Function x) l67;
+ // The static function f67 sets `T` to `int`.
+ if (!tIsBool) {
+ x67 = f67 as dynamic;
+ l67 = f67 as dynamic;
+ x67 = confuse(f67);
+ l67 = confuse(f67);
+ }
+
+ Expect.isTrue(m67 is F67);
+ Expect.isTrue(m67 is Function Function(Function x));
+ Expect.isTrue(confuse(m67) is F67);
+ // In checked mode, verifies the type.
+ x67 = m67;
+ l67 = m67;
+ x67 = confuse(m67);
+ l67 = confuse(m67);
+
+ }
+
+ void testF167() {
+ // List<Function> Function()
+ Expect.isTrue(f167 is F167);
+ Expect.isTrue(confuse(f167) is F167);
+ // In checked mode, verifies the type.
+ List<Function> Function() l167;
+ // The static function f167 sets `T` to `int`.
+ if (!tIsBool) {
+ x167 = f167 as dynamic;
+ l167 = f167 as dynamic;
+ x167 = confuse(f167);
+ l167 = confuse(f167);
+ }
+
+ Expect.isTrue(m167 is F167);
+ Expect.isTrue(m167 is List<Function> Function());
+ Expect.isTrue(confuse(m167) is F167);
+ // In checked mode, verifies the type.
+ x167 = m167;
+ l167 = m167;
+ x167 = confuse(m167);
+ l167 = confuse(m167);
+
+ }
+
+ void testF267() {
+ // List<T> Function(int y, {core.List<core.int> x})
+ Expect.isTrue(f267 is F267);
+ Expect.isTrue(confuse(f267) is F267);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {core.List<core.int> x}) l267;
+ // The static function f267 sets `T` to `int`.
+ if (!tIsBool) {
+ x267 = f267 as dynamic;
+ l267 = f267 as dynamic;
+ x267 = confuse(f267);
+ l267 = confuse(f267);
+ }
+
+ Expect.isTrue(m267 is F267);
+ Expect.isTrue(m267 is List<T> Function(int y, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m267) is F267);
+ // In checked mode, verifies the type.
+ x267 = m267;
+ l267 = m267;
+ x267 = confuse(m267);
+ l267 = confuse(m267);
+ if (!tIsBool) {
+ Expect.isTrue(f267 is F267<int>);
+ Expect.isFalse(f267 is F267<bool>);
+ Expect.isTrue(confuse(f267) is F267<int>);
+ Expect.isFalse(confuse(f267) is F267<bool>);
+ Expect.equals(tIsDynamic, m267 is F267<bool>);
+ Expect.equals(tIsDynamic, confuse(m267) is F267<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x267 = (f267 as dynamic); });
+ Expect.throws(() { x267 = confuse(f267); });
+ List<T> Function(int y, {core.List<core.int> x}) l267;
+ Expect.throws(() { l267 = (f267 as dynamic); });
+ Expect.throws(() { l267 = confuse(f267); });
+ }
+ List<T> Function(int y, {core.List<core.int> x}) l267 = m267;
+ // In checked mode, verifies the type.
+ x267 = m267;
+ x267 = confuse(m267);
+ }
+ }
+
+ void testF367() {
+ // core.List<core.int> Function<A>(List<A> x)
+ Expect.isTrue(f367 is F367);
+ Expect.isTrue(confuse(f367) is F367);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<A> x) l367;
+ // The static function f367 sets `T` to `int`.
+ if (!tIsBool) {
+ x367 = f367 as dynamic;
+ l367 = f367 as dynamic;
+ x367 = confuse(f367);
+ l367 = confuse(f367);
+ }
+
+ Expect.isTrue(m367 is F367);
+ Expect.isTrue(m367 is core.List<core.int> Function<A>(List<A> x));
+ Expect.isTrue(confuse(m367) is F367);
+ // In checked mode, verifies the type.
+ x367 = m367;
+ l367 = m367;
+ x367 = confuse(m367);
+ l367 = confuse(m367);
+
+ }
+
+ void testF467() {
+ // int Function([Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f467 is F467);
+ Expect.isTrue(confuse(f467) is F467);
+ // In checked mode, verifies the type.
+ int Function([Function x1]) Function<B extends core.int>(int x) l467;
+ // The static function f467 sets `T` to `int`.
+ if (!tIsBool) {
+ x467 = f467 as dynamic;
+ l467 = f467 as dynamic;
+ x467 = confuse(f467);
+ l467 = confuse(f467);
+ }
+
+ Expect.isTrue(m467 is F467);
+ Expect.isTrue(m467 is int Function([Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m467) is F467);
+ // In checked mode, verifies the type.
+ x467 = m467;
+ l467 = m467;
+ x467 = confuse(m467);
+ l467 = confuse(m467);
+
+ }
+
+ void testF567() {
+ // int Function({core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f567 is F567);
+ Expect.isTrue(confuse(f567) is F567);
+ // In checked mode, verifies the type.
+ int Function({core.List<core.int> x}) Function<B extends core.int>(int x) l567;
+ // The static function f567 sets `T` to `int`.
+ if (!tIsBool) {
+ x567 = f567 as dynamic;
+ l567 = f567 as dynamic;
+ x567 = confuse(f567);
+ l567 = confuse(f567);
+ }
+
+ Expect.isTrue(m567 is F567);
+ Expect.isTrue(m567 is int Function({core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m567) is F567);
+ // In checked mode, verifies the type.
+ x567 = m567;
+ l567 = m567;
+ x567 = confuse(m567);
+ l567 = confuse(m567);
+
+ }
+
+ void testF667() {
+ // Function Function(int y, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f667 is F667);
+ Expect.isTrue(confuse(f667) is F667);
+ // In checked mode, verifies the type.
+ Function Function(int y, {int x}) Function<B extends core.int>(int x) l667;
+ // The static function f667 sets `T` to `int`.
+ if (!tIsBool) {
+ x667 = f667 as dynamic;
+ l667 = f667 as dynamic;
+ x667 = confuse(f667);
+ l667 = confuse(f667);
+ }
+
+ Expect.isTrue(m667 is F667);
+ Expect.isTrue(m667 is Function Function(int y, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m667) is F667);
+ // In checked mode, verifies the type.
+ x667 = m667;
+ l667 = m667;
+ x667 = confuse(m667);
+ l667 = confuse(m667);
+
+ }
+
+ void testF767() {
+ // Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f767 is F767);
+ Expect.isTrue(confuse(f767) is F767);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l767;
+ // The static function f767 sets `T` to `int`.
+ if (!tIsBool) {
+ x767 = f767 as dynamic;
+ l767 = f767 as dynamic;
+ x767 = confuse(f767);
+ l767 = confuse(f767);
+ }
+
+ Expect.isTrue(m767 is F767);
+ Expect.isTrue(m767 is Function Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m767) is F767);
+ // In checked mode, verifies the type.
+ x767 = m767;
+ l767 = m767;
+ x767 = confuse(m767);
+ l767 = confuse(m767);
+
+ }
+
+ void testF867() {
+ // List<Function> Function(int x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f867 is F867);
+ Expect.isTrue(confuse(f867) is F867);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1) Function<B extends core.int>(int x) l867;
+ // The static function f867 sets `T` to `int`.
+ if (!tIsBool) {
+ x867 = f867 as dynamic;
+ l867 = f867 as dynamic;
+ x867 = confuse(f867);
+ l867 = confuse(f867);
+ }
+
+ Expect.isTrue(m867 is F867);
+ Expect.isTrue(m867 is List<Function> Function(int x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m867) is F867);
+ // In checked mode, verifies the type.
+ x867 = m867;
+ l867 = m867;
+ x867 = confuse(m867);
+ l867 = confuse(m867);
+
+ }
+
+ void testF967() {
+ // List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f967 is F967);
+ Expect.isTrue(confuse(f967) is F967);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l967;
+ // The static function f967 sets `T` to `int`.
+ if (!tIsBool) {
+ x967 = f967 as dynamic;
+ l967 = f967 as dynamic;
+ x967 = confuse(f967);
+ l967 = confuse(f967);
+ }
+
+ Expect.isTrue(m967 is F967);
+ Expect.isTrue(m967 is List<Function> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m967) is F967);
+ // In checked mode, verifies the type.
+ x967 = m967;
+ l967 = m967;
+ x967 = confuse(m967);
+ l967 = confuse(m967);
+
+ }
+
+ void testF1067() {
+ // List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1067 is F1067);
+ Expect.isTrue(confuse(f1067) is F1067);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1067;
+ // The static function f1067 sets `T` to `int`.
+ if (!tIsBool) {
+ x1067 = f1067 as dynamic;
+ l1067 = f1067 as dynamic;
+ x1067 = confuse(f1067);
+ l1067 = confuse(f1067);
+ }
+
+ Expect.isTrue(m1067 is F1067);
+ Expect.isTrue(m1067 is List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1067) is F1067);
+ // In checked mode, verifies the type.
+ x1067 = m1067;
+ l1067 = m1067;
+ x1067 = confuse(m1067);
+ l1067 = confuse(m1067);
+ if (!tIsBool) {
+ Expect.isTrue(f1067 is F1067<int>);
+ Expect.isFalse(f1067 is F1067<bool>);
+ Expect.isTrue(confuse(f1067) is F1067<int>);
+ Expect.isFalse(confuse(f1067) is F1067<bool>);
+ Expect.equals(tIsDynamic, m1067 is F1067<bool>);
+ Expect.equals(tIsDynamic, confuse(m1067) is F1067<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1067 = (f1067 as dynamic); });
+ Expect.throws(() { x1067 = confuse(f1067); });
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1067;
+ Expect.throws(() { l1067 = (f1067 as dynamic); });
+ Expect.throws(() { l1067 = confuse(f1067); });
+ }
+ List<Function> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1067 = m1067;
+ // In checked mode, verifies the type.
+ x1067 = m1067;
+ x1067 = confuse(m1067);
+ }
+ }
+
+ void testF1167() {
+ // core.List<core.int> Function([List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1167 is F1167);
+ Expect.isTrue(confuse(f1167) is F1167);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x]) Function<B extends core.int>(int x) l1167;
+ // The static function f1167 sets `T` to `int`.
+ if (!tIsBool) {
+ x1167 = f1167 as dynamic;
+ l1167 = f1167 as dynamic;
+ x1167 = confuse(f1167);
+ l1167 = confuse(f1167);
+ }
+
+ Expect.isTrue(m1167 is F1167);
+ Expect.isTrue(m1167 is core.List<core.int> Function([List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1167) is F1167);
+ // In checked mode, verifies the type.
+ x1167 = m1167;
+ l1167 = m1167;
+ x1167 = confuse(m1167);
+ l1167 = confuse(m1167);
+
+ }
+
+ void testF1267() {
+ // core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1267 is F1267);
+ Expect.isTrue(confuse(f1267) is F1267);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x) l1267;
+ // The static function f1267 sets `T` to `int`.
+ if (!tIsBool) {
+ x1267 = f1267 as dynamic;
+ l1267 = f1267 as dynamic;
+ x1267 = confuse(f1267);
+ l1267 = confuse(f1267);
+ }
+
+ Expect.isTrue(m1267 is F1267);
+ Expect.isTrue(m1267 is core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1267) is F1267);
+ // In checked mode, verifies the type.
+ x1267 = m1267;
+ l1267 = m1267;
+ x1267 = confuse(m1267);
+ l1267 = confuse(m1267);
+ if (!tIsBool) {
+ Expect.isTrue(f1267 is F1267<int>);
+ Expect.isFalse(f1267 is F1267<bool>);
+ Expect.isTrue(confuse(f1267) is F1267<int>);
+ Expect.isFalse(confuse(f1267) is F1267<bool>);
+ Expect.equals(tIsDynamic, m1267 is F1267<bool>);
+ Expect.equals(tIsDynamic, confuse(m1267) is F1267<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1267 = (f1267 as dynamic); });
+ Expect.throws(() { x1267 = confuse(f1267); });
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x) l1267;
+ Expect.throws(() { l1267 = (f1267 as dynamic); });
+ Expect.throws(() { l1267 = confuse(f1267); });
+ }
+ core.List<core.int> Function(List<T> x1) Function<B extends core.int>(int x) l1267 = m1267;
+ // In checked mode, verifies the type.
+ x1267 = m1267;
+ x1267 = confuse(m1267);
+ }
+ }
+
+ void testF1367() {
+ // List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1367 is F1367);
+ Expect.isTrue(confuse(f1367) is F1367);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x) l1367;
+ // The static function f1367 sets `T` to `int`.
+ if (!tIsBool) {
+ x1367 = f1367 as dynamic;
+ l1367 = f1367 as dynamic;
+ x1367 = confuse(f1367);
+ l1367 = confuse(f1367);
+ }
+
+ Expect.isTrue(m1367 is F1367);
+ Expect.isTrue(m1367 is List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1367) is F1367);
+ // In checked mode, verifies the type.
+ x1367 = m1367;
+ l1367 = m1367;
+ x1367 = confuse(m1367);
+ l1367 = confuse(m1367);
+ if (!tIsBool) {
+ Expect.isTrue(f1367 is F1367<int>);
+ Expect.isFalse(f1367 is F1367<bool>);
+ Expect.isTrue(confuse(f1367) is F1367<int>);
+ Expect.isFalse(confuse(f1367) is F1367<bool>);
+ Expect.equals(tIsDynamic, m1367 is F1367<bool>);
+ Expect.equals(tIsDynamic, confuse(m1367) is F1367<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1367 = (f1367 as dynamic); });
+ Expect.throws(() { x1367 = confuse(f1367); });
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x) l1367;
+ Expect.throws(() { l1367 = (f1367 as dynamic); });
+ Expect.throws(() { l1367 = confuse(f1367); });
+ }
+ List<T> Function(int x2, [Function x3]) Function<B extends core.int>(int x) l1367 = m1367;
+ // In checked mode, verifies the type.
+ x1367 = m1367;
+ x1367 = confuse(m1367);
+ }
+ }
+
+ void testF1467() {
+ // List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1467 is F1467);
+ Expect.isTrue(confuse(f1467) is F1467);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l1467;
+ // The static function f1467 sets `T` to `int`.
+ if (!tIsBool) {
+ x1467 = f1467 as dynamic;
+ l1467 = f1467 as dynamic;
+ x1467 = confuse(f1467);
+ l1467 = confuse(f1467);
+ }
+
+ Expect.isTrue(m1467 is F1467);
+ Expect.isTrue(m1467 is List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1467) is F1467);
+ // In checked mode, verifies the type.
+ x1467 = m1467;
+ l1467 = m1467;
+ x1467 = confuse(m1467);
+ l1467 = confuse(m1467);
+ if (!tIsBool) {
+ Expect.isTrue(f1467 is F1467<int>);
+ Expect.isFalse(f1467 is F1467<bool>);
+ Expect.isTrue(confuse(f1467) is F1467<int>);
+ Expect.isFalse(confuse(f1467) is F1467<bool>);
+ Expect.equals(tIsDynamic, m1467 is F1467<bool>);
+ Expect.equals(tIsDynamic, confuse(m1467) is F1467<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1467 = (f1467 as dynamic); });
+ Expect.throws(() { x1467 = confuse(f1467); });
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l1467;
+ Expect.throws(() { l1467 = (f1467 as dynamic); });
+ Expect.throws(() { l1467 = confuse(f1467); });
+ }
+ List<T> Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l1467 = m1467;
+ // In checked mode, verifies the type.
+ x1467 = m1467;
+ x1467 = confuse(m1467);
+ }
+ }
+
+ void testF1567() {
+ // Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1567 is F1567);
+ Expect.isTrue(confuse(f1567) is F1567);
+ // In checked mode, verifies the type.
+ Function(Function x) Function<B extends core.int>(int x) l1567;
+ // The static function f1567 sets `T` to `int`.
+ if (!tIsBool) {
+ x1567 = f1567 as dynamic;
+ l1567 = f1567 as dynamic;
+ x1567 = confuse(f1567);
+ l1567 = confuse(f1567);
+ }
+
+ Expect.isTrue(m1567 is F1567);
+ Expect.isTrue(m1567 is Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1567) is F1567);
+ // In checked mode, verifies the type.
+ x1567 = m1567;
+ l1567 = m1567;
+ x1567 = confuse(m1567);
+ l1567 = confuse(m1567);
+
+ }
+
+ void testF1667() {
+ // Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1667 is F1667);
+ Expect.isTrue(confuse(f1667) is F1667);
+ // In checked mode, verifies the type.
+ Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l1667;
+ // The static function f1667 sets `T` to `int`.
+ if (!tIsBool) {
+ x1667 = f1667 as dynamic;
+ l1667 = f1667 as dynamic;
+ x1667 = confuse(f1667);
+ l1667 = confuse(f1667);
+ }
+
+ Expect.isTrue(m1667 is F1667);
+ Expect.isTrue(m1667 is Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1667) is F1667);
+ // In checked mode, verifies the type.
+ x1667 = m1667;
+ l1667 = m1667;
+ x1667 = confuse(m1667);
+ l1667 = confuse(m1667);
+
+ }
+
+ void testF1767() {
+ // int Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1767 is F1767);
+ Expect.isTrue(confuse(f1767) is F1767);
+ // In checked mode, verifies the type.
+ int Function<A>() Function<B extends core.int>(int x) l1767;
+ // The static function f1767 sets `T` to `int`.
+ if (!tIsBool) {
+ x1767 = f1767 as dynamic;
+ l1767 = f1767 as dynamic;
+ x1767 = confuse(f1767);
+ l1767 = confuse(f1767);
+ }
+
+ Expect.isTrue(m1767 is F1767);
+ Expect.isTrue(m1767 is int Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1767) is F1767);
+ // In checked mode, verifies the type.
+ x1767 = m1767;
+ l1767 = m1767;
+ x1767 = confuse(m1767);
+ l1767 = confuse(m1767);
+
+ }
+
+ void testF1867() {
+ // core.List<core.int> Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1867 is F1867);
+ Expect.isTrue(confuse(f1867) is F1867);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(A x) Function<B extends core.int>(int x) l1867;
+ // The static function f1867 sets `T` to `int`.
+ if (!tIsBool) {
+ x1867 = f1867 as dynamic;
+ l1867 = f1867 as dynamic;
+ x1867 = confuse(f1867);
+ l1867 = confuse(f1867);
+ }
+
+ Expect.isTrue(m1867 is F1867);
+ Expect.isTrue(m1867 is core.List<core.int> Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1867) is F1867);
+ // In checked mode, verifies the type.
+ x1867 = m1867;
+ l1867 = m1867;
+ x1867 = confuse(m1867);
+ l1867 = confuse(m1867);
+
+ }
+
+ void testF1967() {
+ // A Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1967 is F1967);
+ Expect.isTrue(confuse(f1967) is F1967);
+ // In checked mode, verifies the type.
+ A Function<A>(List<A> x) Function<B extends core.int>(int x) l1967;
+ // The static function f1967 sets `T` to `int`.
+ if (!tIsBool) {
+ x1967 = f1967 as dynamic;
+ l1967 = f1967 as dynamic;
+ x1967 = confuse(f1967);
+ l1967 = confuse(f1967);
+ }
+
+ Expect.isTrue(m1967 is F1967);
+ Expect.isTrue(m1967 is A Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1967) is F1967);
+ // In checked mode, verifies the type.
+ x1967 = m1967;
+ l1967 = m1967;
+ x1967 = confuse(m1967);
+ l1967 = confuse(m1967);
+
+ }
+
+
+}
+
+class C68<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([Function x]) x68;
+ core.List<core.int> Function(int x) x168;
+ List<T> Function(List<T> x) x268;
+ List<T> Function<A>(int x) x368;
+ int Function(int x1, [Function x2]) Function() x468;
+ int Function(int x0, {core.List<core.int> x}) Function() x568;
+ Function Function(Function x) Function() x668;
+ Function Function(int y, [core.List<core.int> x]) Function() x768;
+ List<Function> Function([int x1]) Function() x868;
+ List<Function> Function({List<Function> x}) Function() x968;
+ List<Function> Function() Function() x1068;
+ core.List<core.int> Function(int x0, [List<Function> x]) Function() x1168;
+ core.List<core.int> Function([List<T> x1]) Function() x1268;
+ List<T> Function(int x, [Function x2]) Function() x1368;
+ List<T> Function(int y, {core.List<core.int> x}) Function() x1468;
+ Function([Function x]) Function() x1568;
+ Function(core.List<core.int> x0) Function() x1668;
+ int Function<A>(A x) Function() x1768;
+ core.List<core.int> Function<A>(List<A> x) Function() x1868;
+ List<A> Function<A>(int x) Function() x1968;
+
+
+ C68({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m68([Function x]) => null;
+ core.List<core.int> m168(int x) => null;
+ List<T> m268(List<T> x) => null;
+ List<T> m368<A>(int x) => null;
+ int Function(int x0, [Function x1]) m468() => null;
+ int Function(int x0, {core.List<core.int> x}) m568() => null;
+ Function Function(Function x) m668() => null;
+ Function Function(int y, [core.List<core.int> x]) m768() => null;
+ List<Function> Function([int x0]) m868() => null;
+ List<Function> Function({List<Function> x}) m968() => null;
+ List<Function> Function() m1068() => null;
+ core.List<core.int> Function(int x0, [List<Function> x]) m1168() => null;
+ core.List<core.int> Function([List<T> x0]) m1268() => null;
+ List<T> Function(int x, [Function x0]) m1368() => null;
+ List<T> Function(int y, {core.List<core.int> x}) m1468() => null;
+ Function([Function x]) m1568() => null;
+ Function(core.List<core.int> x0) m1668() => null;
+ int Function<A>(A x) m1768() => null;
+ core.List<core.int> Function<A>(List<A> x) m1868() => null;
+ List<A> Function<A>(int x) m1968() => null;
+
+
+ runTests() {
+ testF68();
+ testF168();
+ testF268();
+ testF368();
+ testF468();
+ testF568();
+ testF668();
+ testF768();
+ testF868();
+ testF968();
+ testF1068();
+ testF1168();
+ testF1268();
+ testF1368();
+ testF1468();
+ testF1568();
+ testF1668();
+ testF1768();
+ testF1868();
+ testF1968();
+ }
+
+ void testF68() {
+ // Function Function([Function x])
+ Expect.isTrue(f68 is F68);
+ Expect.isTrue(confuse(f68) is F68);
+ // In checked mode, verifies the type.
+ Function Function([Function x]) l68;
+ // The static function f68 sets `T` to `int`.
+ if (!tIsBool) {
+ x68 = f68 as dynamic;
+ l68 = f68 as dynamic;
+ x68 = confuse(f68);
+ l68 = confuse(f68);
+ }
+
+ Expect.isTrue(m68 is F68);
+ Expect.isTrue(m68 is Function Function([Function x]));
+ Expect.isTrue(confuse(m68) is F68);
+ // In checked mode, verifies the type.
+ x68 = m68;
+ l68 = m68;
+ x68 = confuse(m68);
+ l68 = confuse(m68);
+
+ }
+
+ void testF168() {
+ // core.List<core.int> Function(int x)
+ Expect.isTrue(f168 is F168);
+ Expect.isTrue(confuse(f168) is F168);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x) l168;
+ // The static function f168 sets `T` to `int`.
+ if (!tIsBool) {
+ x168 = f168 as dynamic;
+ l168 = f168 as dynamic;
+ x168 = confuse(f168);
+ l168 = confuse(f168);
+ }
+
+ Expect.isTrue(m168 is F168);
+ Expect.isTrue(m168 is core.List<core.int> Function(int x));
+ Expect.isTrue(confuse(m168) is F168);
+ // In checked mode, verifies the type.
+ x168 = m168;
+ l168 = m168;
+ x168 = confuse(m168);
+ l168 = confuse(m168);
+
+ }
+
+ void testF268() {
+ // List<T> Function(List<T> x)
+ Expect.isTrue(f268 is F268);
+ Expect.isTrue(confuse(f268) is F268);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x) l268;
+ // The static function f268 sets `T` to `int`.
+ if (!tIsBool) {
+ x268 = f268 as dynamic;
+ l268 = f268 as dynamic;
+ x268 = confuse(f268);
+ l268 = confuse(f268);
+ }
+
+ Expect.isTrue(m268 is F268);
+ Expect.isTrue(m268 is List<T> Function(List<T> x));
+ Expect.isTrue(confuse(m268) is F268);
+ // In checked mode, verifies the type.
+ x268 = m268;
+ l268 = m268;
+ x268 = confuse(m268);
+ l268 = confuse(m268);
+ if (!tIsBool) {
+ Expect.isTrue(f268 is F268<int>);
+ Expect.isFalse(f268 is F268<bool>);
+ Expect.isTrue(confuse(f268) is F268<int>);
+ Expect.isFalse(confuse(f268) is F268<bool>);
+ Expect.equals(tIsDynamic, m268 is F268<bool>);
+ Expect.equals(tIsDynamic, confuse(m268) is F268<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x268 = (f268 as dynamic); });
+ Expect.throws(() { x268 = confuse(f268); });
+ List<T> Function(List<T> x) l268;
+ Expect.throws(() { l268 = (f268 as dynamic); });
+ Expect.throws(() { l268 = confuse(f268); });
+ }
+ List<T> Function(List<T> x) l268 = m268;
+ // In checked mode, verifies the type.
+ x268 = m268;
+ x268 = confuse(m268);
+ }
+ }
+
+ void testF368() {
+ // List<T> Function<A>(int x)
+ Expect.isTrue(f368 is F368);
+ Expect.isTrue(confuse(f368) is F368);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(int x) l368;
+ // The static function f368 sets `T` to `int`.
+ if (!tIsBool) {
+ x368 = f368 as dynamic;
+ l368 = f368 as dynamic;
+ x368 = confuse(f368);
+ l368 = confuse(f368);
+ }
+
+ Expect.isTrue(m368 is F368);
+ Expect.isTrue(m368 is List<T> Function<A>(int x));
+ Expect.isTrue(confuse(m368) is F368);
+ // In checked mode, verifies the type.
+ x368 = m368;
+ l368 = m368;
+ x368 = confuse(m368);
+ l368 = confuse(m368);
+ if (!tIsBool) {
+ Expect.isTrue(f368 is F368<int>);
+ Expect.isFalse(f368 is F368<bool>);
+ Expect.isTrue(confuse(f368) is F368<int>);
+ Expect.isFalse(confuse(f368) is F368<bool>);
+ Expect.equals(tIsDynamic, m368 is F368<bool>);
+ Expect.equals(tIsDynamic, confuse(m368) is F368<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x368 = (f368 as dynamic); });
+ Expect.throws(() { x368 = confuse(f368); });
+ List<T> Function<A>(int x) l368;
+ Expect.throws(() { l368 = (f368 as dynamic); });
+ Expect.throws(() { l368 = confuse(f368); });
+ }
+ List<T> Function<A>(int x) l368 = m368;
+ // In checked mode, verifies the type.
+ x368 = m368;
+ x368 = confuse(m368);
+ }
+ }
+
+ void testF468() {
+ // int Function(int x1, [Function x2]) Function()
+ Expect.isTrue(f468 is F468);
+ Expect.isTrue(confuse(f468) is F468);
+ // In checked mode, verifies the type.
+ int Function(int x1, [Function x2]) Function() l468;
+ // The static function f468 sets `T` to `int`.
+ if (!tIsBool) {
+ x468 = f468 as dynamic;
+ l468 = f468 as dynamic;
+ x468 = confuse(f468);
+ l468 = confuse(f468);
+ }
+
+ Expect.isTrue(m468 is F468);
+ Expect.isTrue(m468 is int Function(int x1, [Function x2]) Function());
+ Expect.isTrue(confuse(m468) is F468);
+ // In checked mode, verifies the type.
+ x468 = m468;
+ l468 = m468;
+ x468 = confuse(m468);
+ l468 = confuse(m468);
+
+ }
+
+ void testF568() {
+ // int Function(int x0, {core.List<core.int> x}) Function()
+ Expect.isTrue(f568 is F568);
+ Expect.isTrue(confuse(f568) is F568);
+ // In checked mode, verifies the type.
+ int Function(int x0, {core.List<core.int> x}) Function() l568;
+ // The static function f568 sets `T` to `int`.
+ if (!tIsBool) {
+ x568 = f568 as dynamic;
+ l568 = f568 as dynamic;
+ x568 = confuse(f568);
+ l568 = confuse(f568);
+ }
+
+ Expect.isTrue(m568 is F568);
+ Expect.isTrue(m568 is int Function(int x0, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m568) is F568);
+ // In checked mode, verifies the type.
+ x568 = m568;
+ l568 = m568;
+ x568 = confuse(m568);
+ l568 = confuse(m568);
+
+ }
+
+ void testF668() {
+ // Function Function(Function x) Function()
+ Expect.isTrue(f668 is F668);
+ Expect.isTrue(confuse(f668) is F668);
+ // In checked mode, verifies the type.
+ Function Function(Function x) Function() l668;
+ // The static function f668 sets `T` to `int`.
+ if (!tIsBool) {
+ x668 = f668 as dynamic;
+ l668 = f668 as dynamic;
+ x668 = confuse(f668);
+ l668 = confuse(f668);
+ }
+
+ Expect.isTrue(m668 is F668);
+ Expect.isTrue(m668 is Function Function(Function x) Function());
+ Expect.isTrue(confuse(m668) is F668);
+ // In checked mode, verifies the type.
+ x668 = m668;
+ l668 = m668;
+ x668 = confuse(m668);
+ l668 = confuse(m668);
+
+ }
+
+ void testF768() {
+ // Function Function(int y, [core.List<core.int> x]) Function()
+ Expect.isTrue(f768 is F768);
+ Expect.isTrue(confuse(f768) is F768);
+ // In checked mode, verifies the type.
+ Function Function(int y, [core.List<core.int> x]) Function() l768;
+ // The static function f768 sets `T` to `int`.
+ if (!tIsBool) {
+ x768 = f768 as dynamic;
+ l768 = f768 as dynamic;
+ x768 = confuse(f768);
+ l768 = confuse(f768);
+ }
+
+ Expect.isTrue(m768 is F768);
+ Expect.isTrue(m768 is Function Function(int y, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m768) is F768);
+ // In checked mode, verifies the type.
+ x768 = m768;
+ l768 = m768;
+ x768 = confuse(m768);
+ l768 = confuse(m768);
+
+ }
+
+ void testF868() {
+ // List<Function> Function([int x1]) Function()
+ Expect.isTrue(f868 is F868);
+ Expect.isTrue(confuse(f868) is F868);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x1]) Function() l868;
+ // The static function f868 sets `T` to `int`.
+ if (!tIsBool) {
+ x868 = f868 as dynamic;
+ l868 = f868 as dynamic;
+ x868 = confuse(f868);
+ l868 = confuse(f868);
+ }
+
+ Expect.isTrue(m868 is F868);
+ Expect.isTrue(m868 is List<Function> Function([int x1]) Function());
+ Expect.isTrue(confuse(m868) is F868);
+ // In checked mode, verifies the type.
+ x868 = m868;
+ l868 = m868;
+ x868 = confuse(m868);
+ l868 = confuse(m868);
+
+ }
+
+ void testF968() {
+ // List<Function> Function({List<Function> x}) Function()
+ Expect.isTrue(f968 is F968);
+ Expect.isTrue(confuse(f968) is F968);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<Function> x}) Function() l968;
+ // The static function f968 sets `T` to `int`.
+ if (!tIsBool) {
+ x968 = f968 as dynamic;
+ l968 = f968 as dynamic;
+ x968 = confuse(f968);
+ l968 = confuse(f968);
+ }
+
+ Expect.isTrue(m968 is F968);
+ Expect.isTrue(m968 is List<Function> Function({List<Function> x}) Function());
+ Expect.isTrue(confuse(m968) is F968);
+ // In checked mode, verifies the type.
+ x968 = m968;
+ l968 = m968;
+ x968 = confuse(m968);
+ l968 = confuse(m968);
+
+ }
+
+ void testF1068() {
+ // List<Function> Function() Function()
+ Expect.isTrue(f1068 is F1068);
+ Expect.isTrue(confuse(f1068) is F1068);
+ // In checked mode, verifies the type.
+ List<Function> Function() Function() l1068;
+ // The static function f1068 sets `T` to `int`.
+ if (!tIsBool) {
+ x1068 = f1068 as dynamic;
+ l1068 = f1068 as dynamic;
+ x1068 = confuse(f1068);
+ l1068 = confuse(f1068);
+ }
+
+ Expect.isTrue(m1068 is F1068);
+ Expect.isTrue(m1068 is List<Function> Function() Function());
+ Expect.isTrue(confuse(m1068) is F1068);
+ // In checked mode, verifies the type.
+ x1068 = m1068;
+ l1068 = m1068;
+ x1068 = confuse(m1068);
+ l1068 = confuse(m1068);
+
+ }
+
+ void testF1168() {
+ // core.List<core.int> Function(int x0, [List<Function> x]) Function()
+ Expect.isTrue(f1168 is F1168);
+ Expect.isTrue(confuse(f1168) is F1168);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [List<Function> x]) Function() l1168;
+ // The static function f1168 sets `T` to `int`.
+ if (!tIsBool) {
+ x1168 = f1168 as dynamic;
+ l1168 = f1168 as dynamic;
+ x1168 = confuse(f1168);
+ l1168 = confuse(f1168);
+ }
+
+ Expect.isTrue(m1168 is F1168);
+ Expect.isTrue(m1168 is core.List<core.int> Function(int x0, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m1168) is F1168);
+ // In checked mode, verifies the type.
+ x1168 = m1168;
+ l1168 = m1168;
+ x1168 = confuse(m1168);
+ l1168 = confuse(m1168);
+
+ }
+
+ void testF1268() {
+ // core.List<core.int> Function([List<T> x1]) Function()
+ Expect.isTrue(f1268 is F1268);
+ Expect.isTrue(confuse(f1268) is F1268);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x1]) Function() l1268;
+ // The static function f1268 sets `T` to `int`.
+ if (!tIsBool) {
+ x1268 = f1268 as dynamic;
+ l1268 = f1268 as dynamic;
+ x1268 = confuse(f1268);
+ l1268 = confuse(f1268);
+ }
+
+ Expect.isTrue(m1268 is F1268);
+ Expect.isTrue(m1268 is core.List<core.int> Function([List<T> x1]) Function());
+ Expect.isTrue(confuse(m1268) is F1268);
+ // In checked mode, verifies the type.
+ x1268 = m1268;
+ l1268 = m1268;
+ x1268 = confuse(m1268);
+ l1268 = confuse(m1268);
+ if (!tIsBool) {
+ Expect.isTrue(f1268 is F1268<int>);
+ Expect.isFalse(f1268 is F1268<bool>);
+ Expect.isTrue(confuse(f1268) is F1268<int>);
+ Expect.isFalse(confuse(f1268) is F1268<bool>);
+ Expect.equals(tIsDynamic, m1268 is F1268<bool>);
+ Expect.equals(tIsDynamic, confuse(m1268) is F1268<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1268 = (f1268 as dynamic); });
+ Expect.throws(() { x1268 = confuse(f1268); });
+ core.List<core.int> Function([List<T> x1]) Function() l1268;
+ Expect.throws(() { l1268 = (f1268 as dynamic); });
+ Expect.throws(() { l1268 = confuse(f1268); });
+ }
+ core.List<core.int> Function([List<T> x1]) Function() l1268 = m1268;
+ // In checked mode, verifies the type.
+ x1268 = m1268;
+ x1268 = confuse(m1268);
+ }
+ }
+
+ void testF1368() {
+ // List<T> Function(int x, [Function x2]) Function()
+ Expect.isTrue(f1368 is F1368);
+ Expect.isTrue(confuse(f1368) is F1368);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [Function x2]) Function() l1368;
+ // The static function f1368 sets `T` to `int`.
+ if (!tIsBool) {
+ x1368 = f1368 as dynamic;
+ l1368 = f1368 as dynamic;
+ x1368 = confuse(f1368);
+ l1368 = confuse(f1368);
+ }
+
+ Expect.isTrue(m1368 is F1368);
+ Expect.isTrue(m1368 is List<T> Function(int x, [Function x2]) Function());
+ Expect.isTrue(confuse(m1368) is F1368);
+ // In checked mode, verifies the type.
+ x1368 = m1368;
+ l1368 = m1368;
+ x1368 = confuse(m1368);
+ l1368 = confuse(m1368);
+ if (!tIsBool) {
+ Expect.isTrue(f1368 is F1368<int>);
+ Expect.isFalse(f1368 is F1368<bool>);
+ Expect.isTrue(confuse(f1368) is F1368<int>);
+ Expect.isFalse(confuse(f1368) is F1368<bool>);
+ Expect.equals(tIsDynamic, m1368 is F1368<bool>);
+ Expect.equals(tIsDynamic, confuse(m1368) is F1368<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1368 = (f1368 as dynamic); });
+ Expect.throws(() { x1368 = confuse(f1368); });
+ List<T> Function(int x, [Function x2]) Function() l1368;
+ Expect.throws(() { l1368 = (f1368 as dynamic); });
+ Expect.throws(() { l1368 = confuse(f1368); });
+ }
+ List<T> Function(int x, [Function x2]) Function() l1368 = m1368;
+ // In checked mode, verifies the type.
+ x1368 = m1368;
+ x1368 = confuse(m1368);
+ }
+ }
+
+ void testF1468() {
+ // List<T> Function(int y, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1468 is F1468);
+ Expect.isTrue(confuse(f1468) is F1468);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {core.List<core.int> x}) Function() l1468;
+ // The static function f1468 sets `T` to `int`.
+ if (!tIsBool) {
+ x1468 = f1468 as dynamic;
+ l1468 = f1468 as dynamic;
+ x1468 = confuse(f1468);
+ l1468 = confuse(f1468);
+ }
+
+ Expect.isTrue(m1468 is F1468);
+ Expect.isTrue(m1468 is List<T> Function(int y, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1468) is F1468);
+ // In checked mode, verifies the type.
+ x1468 = m1468;
+ l1468 = m1468;
+ x1468 = confuse(m1468);
+ l1468 = confuse(m1468);
+ if (!tIsBool) {
+ Expect.isTrue(f1468 is F1468<int>);
+ Expect.isFalse(f1468 is F1468<bool>);
+ Expect.isTrue(confuse(f1468) is F1468<int>);
+ Expect.isFalse(confuse(f1468) is F1468<bool>);
+ Expect.equals(tIsDynamic, m1468 is F1468<bool>);
+ Expect.equals(tIsDynamic, confuse(m1468) is F1468<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1468 = (f1468 as dynamic); });
+ Expect.throws(() { x1468 = confuse(f1468); });
+ List<T> Function(int y, {core.List<core.int> x}) Function() l1468;
+ Expect.throws(() { l1468 = (f1468 as dynamic); });
+ Expect.throws(() { l1468 = confuse(f1468); });
+ }
+ List<T> Function(int y, {core.List<core.int> x}) Function() l1468 = m1468;
+ // In checked mode, verifies the type.
+ x1468 = m1468;
+ x1468 = confuse(m1468);
+ }
+ }
+
+ void testF1568() {
+ // Function([Function x]) Function()
+ Expect.isTrue(f1568 is F1568);
+ Expect.isTrue(confuse(f1568) is F1568);
+ // In checked mode, verifies the type.
+ Function([Function x]) Function() l1568;
+ // The static function f1568 sets `T` to `int`.
+ if (!tIsBool) {
+ x1568 = f1568 as dynamic;
+ l1568 = f1568 as dynamic;
+ x1568 = confuse(f1568);
+ l1568 = confuse(f1568);
+ }
+
+ Expect.isTrue(m1568 is F1568);
+ Expect.isTrue(m1568 is Function([Function x]) Function());
+ Expect.isTrue(confuse(m1568) is F1568);
+ // In checked mode, verifies the type.
+ x1568 = m1568;
+ l1568 = m1568;
+ x1568 = confuse(m1568);
+ l1568 = confuse(m1568);
+
+ }
+
+ void testF1668() {
+ // Function(core.List<core.int> x0) Function()
+ Expect.isTrue(f1668 is F1668);
+ Expect.isTrue(confuse(f1668) is F1668);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x0) Function() l1668;
+ // The static function f1668 sets `T` to `int`.
+ if (!tIsBool) {
+ x1668 = f1668 as dynamic;
+ l1668 = f1668 as dynamic;
+ x1668 = confuse(f1668);
+ l1668 = confuse(f1668);
+ }
+
+ Expect.isTrue(m1668 is F1668);
+ Expect.isTrue(m1668 is Function(core.List<core.int> x0) Function());
+ Expect.isTrue(confuse(m1668) is F1668);
+ // In checked mode, verifies the type.
+ x1668 = m1668;
+ l1668 = m1668;
+ x1668 = confuse(m1668);
+ l1668 = confuse(m1668);
+
+ }
+
+ void testF1768() {
+ // int Function<A>(A x) Function()
+ Expect.isTrue(f1768 is F1768);
+ Expect.isTrue(confuse(f1768) is F1768);
+ // In checked mode, verifies the type.
+ int Function<A>(A x) Function() l1768;
+ // The static function f1768 sets `T` to `int`.
+ if (!tIsBool) {
+ x1768 = f1768 as dynamic;
+ l1768 = f1768 as dynamic;
+ x1768 = confuse(f1768);
+ l1768 = confuse(f1768);
+ }
+
+ Expect.isTrue(m1768 is F1768);
+ Expect.isTrue(m1768 is int Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1768) is F1768);
+ // In checked mode, verifies the type.
+ x1768 = m1768;
+ l1768 = m1768;
+ x1768 = confuse(m1768);
+ l1768 = confuse(m1768);
+
+ }
+
+ void testF1868() {
+ // core.List<core.int> Function<A>(List<A> x) Function()
+ Expect.isTrue(f1868 is F1868);
+ Expect.isTrue(confuse(f1868) is F1868);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<A> x) Function() l1868;
+ // The static function f1868 sets `T` to `int`.
+ if (!tIsBool) {
+ x1868 = f1868 as dynamic;
+ l1868 = f1868 as dynamic;
+ x1868 = confuse(f1868);
+ l1868 = confuse(f1868);
+ }
+
+ Expect.isTrue(m1868 is F1868);
+ Expect.isTrue(m1868 is core.List<core.int> Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1868) is F1868);
+ // In checked mode, verifies the type.
+ x1868 = m1868;
+ l1868 = m1868;
+ x1868 = confuse(m1868);
+ l1868 = confuse(m1868);
+
+ }
+
+ void testF1968() {
+ // List<A> Function<A>(int x) Function()
+ Expect.isTrue(f1968 is F1968);
+ Expect.isTrue(confuse(f1968) is F1968);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(int x) Function() l1968;
+ // The static function f1968 sets `T` to `int`.
+ if (!tIsBool) {
+ x1968 = f1968 as dynamic;
+ l1968 = f1968 as dynamic;
+ x1968 = confuse(f1968);
+ l1968 = confuse(f1968);
+ }
+
+ Expect.isTrue(m1968 is F1968);
+ Expect.isTrue(m1968 is List<A> Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1968) is F1968);
+ // In checked mode, verifies the type.
+ x1968 = m1968;
+ l1968 = m1968;
+ x1968 = confuse(m1968);
+ l1968 = confuse(m1968);
+
+ }
+
+
+}
+
+class C69<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, [Function x]) x69;
+ core.List<core.int> Function([int x]) x169;
+ List<T> Function([List<T> x]) x269;
+ List<T> Function<A>(Function x) x369;
+ int Function(int x2, [Function x3]) Function(int x) x469;
+ int Function(int x1, {core.List<core.int> x}) Function(int x) x569;
+ Function Function(Function x) Function(int x) x669;
+ Function Function(int y, [core.List<core.int> x]) Function(int x) x769;
+ List<Function> Function([int x1]) Function(int x) x869;
+ List<Function> Function({List<Function> x}) Function(int x) x969;
+ List<Function> Function() Function(int x) x1069;
+ core.List<core.int> Function(int x1, [List<Function> x]) Function(int x) x1169;
+ core.List<core.int> Function([List<T> x1]) Function(int x) x1269;
+ List<T> Function(int x, [Function x1]) Function(int x) x1369;
+ List<T> Function(int y, {core.List<core.int> x}) Function(int x) x1469;
+ Function([Function x]) Function(int x) x1569;
+ Function(core.List<core.int> x1) Function(int x) x1669;
+ int Function<A>(A x) Function(int x) x1769;
+ core.List<core.int> Function<A>(List<A> x) Function(int x) x1869;
+ List<A> Function<A>(int x) Function(int x) x1969;
+
+
+ C69({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m69(int x0, [Function x]) => null;
+ core.List<core.int> m169([int x]) => null;
+ List<T> m269([List<T> x]) => null;
+ List<T> m369<A>(Function x) => null;
+ int Function(int x0, [Function x1]) m469(int x) => null;
+ int Function(int x0, {core.List<core.int> x}) m569(int x) => null;
+ Function Function(Function x) m669(int x) => null;
+ Function Function(int y, [core.List<core.int> x]) m769(int x) => null;
+ List<Function> Function([int x0]) m869(int x) => null;
+ List<Function> Function({List<Function> x}) m969(int x) => null;
+ List<Function> Function() m1069(int x) => null;
+ core.List<core.int> Function(int x0, [List<Function> x]) m1169(int x) => null;
+ core.List<core.int> Function([List<T> x0]) m1269(int x) => null;
+ List<T> Function(int x, [Function x0]) m1369(int x) => null;
+ List<T> Function(int y, {core.List<core.int> x}) m1469(int x) => null;
+ Function([Function x]) m1569(int x) => null;
+ Function(core.List<core.int> x0) m1669(int x) => null;
+ int Function<A>(A x) m1769(int x) => null;
+ core.List<core.int> Function<A>(List<A> x) m1869(int x) => null;
+ List<A> Function<A>(int x) m1969(int x) => null;
+
+
+ runTests() {
+ testF69();
+ testF169();
+ testF269();
+ testF369();
+ testF469();
+ testF569();
+ testF669();
+ testF769();
+ testF869();
+ testF969();
+ testF1069();
+ testF1169();
+ testF1269();
+ testF1369();
+ testF1469();
+ testF1569();
+ testF1669();
+ testF1769();
+ testF1869();
+ testF1969();
+ }
+
+ void testF69() {
+ // Function Function(int x0, [Function x])
+ Expect.isTrue(f69 is F69);
+ Expect.isTrue(confuse(f69) is F69);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [Function x]) l69;
+ // The static function f69 sets `T` to `int`.
+ if (!tIsBool) {
+ x69 = f69 as dynamic;
+ l69 = f69 as dynamic;
+ x69 = confuse(f69);
+ l69 = confuse(f69);
+ }
+
+ Expect.isTrue(m69 is F69);
+ Expect.isTrue(m69 is Function Function(int x0, [Function x]));
+ Expect.isTrue(confuse(m69) is F69);
+ // In checked mode, verifies the type.
+ x69 = m69;
+ l69 = m69;
+ x69 = confuse(m69);
+ l69 = confuse(m69);
+
+ }
+
+ void testF169() {
+ // core.List<core.int> Function([int x])
+ Expect.isTrue(f169 is F169);
+ Expect.isTrue(confuse(f169) is F169);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x]) l169;
+ // The static function f169 sets `T` to `int`.
+ if (!tIsBool) {
+ x169 = f169 as dynamic;
+ l169 = f169 as dynamic;
+ x169 = confuse(f169);
+ l169 = confuse(f169);
+ }
+
+ Expect.isTrue(m169 is F169);
+ Expect.isTrue(m169 is core.List<core.int> Function([int x]));
+ Expect.isTrue(confuse(m169) is F169);
+ // In checked mode, verifies the type.
+ x169 = m169;
+ l169 = m169;
+ x169 = confuse(m169);
+ l169 = confuse(m169);
+
+ }
+
+ void testF269() {
+ // List<T> Function([List<T> x])
+ Expect.isTrue(f269 is F269);
+ Expect.isTrue(confuse(f269) is F269);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x]) l269;
+ // The static function f269 sets `T` to `int`.
+ if (!tIsBool) {
+ x269 = f269 as dynamic;
+ l269 = f269 as dynamic;
+ x269 = confuse(f269);
+ l269 = confuse(f269);
+ }
+
+ Expect.isTrue(m269 is F269);
+ Expect.isTrue(m269 is List<T> Function([List<T> x]));
+ Expect.isTrue(confuse(m269) is F269);
+ // In checked mode, verifies the type.
+ x269 = m269;
+ l269 = m269;
+ x269 = confuse(m269);
+ l269 = confuse(m269);
+ if (!tIsBool) {
+ Expect.isTrue(f269 is F269<int>);
+ Expect.isFalse(f269 is F269<bool>);
+ Expect.isTrue(confuse(f269) is F269<int>);
+ Expect.isFalse(confuse(f269) is F269<bool>);
+ Expect.equals(tIsDynamic, m269 is F269<bool>);
+ Expect.equals(tIsDynamic, confuse(m269) is F269<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x269 = (f269 as dynamic); });
+ Expect.throws(() { x269 = confuse(f269); });
+ List<T> Function([List<T> x]) l269;
+ Expect.throws(() { l269 = (f269 as dynamic); });
+ Expect.throws(() { l269 = confuse(f269); });
+ }
+ List<T> Function([List<T> x]) l269 = m269;
+ // In checked mode, verifies the type.
+ x269 = m269;
+ x269 = confuse(m269);
+ }
+ }
+
+ void testF369() {
+ // List<T> Function<A>(Function x)
+ Expect.isTrue(f369 is F369);
+ Expect.isTrue(confuse(f369) is F369);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(Function x) l369;
+ // The static function f369 sets `T` to `int`.
+ if (!tIsBool) {
+ x369 = f369 as dynamic;
+ l369 = f369 as dynamic;
+ x369 = confuse(f369);
+ l369 = confuse(f369);
+ }
+
+ Expect.isTrue(m369 is F369);
+ Expect.isTrue(m369 is List<T> Function<A>(Function x));
+ Expect.isTrue(confuse(m369) is F369);
+ // In checked mode, verifies the type.
+ x369 = m369;
+ l369 = m369;
+ x369 = confuse(m369);
+ l369 = confuse(m369);
+ if (!tIsBool) {
+ Expect.isTrue(f369 is F369<int>);
+ Expect.isFalse(f369 is F369<bool>);
+ Expect.isTrue(confuse(f369) is F369<int>);
+ Expect.isFalse(confuse(f369) is F369<bool>);
+ Expect.equals(tIsDynamic, m369 is F369<bool>);
+ Expect.equals(tIsDynamic, confuse(m369) is F369<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x369 = (f369 as dynamic); });
+ Expect.throws(() { x369 = confuse(f369); });
+ List<T> Function<A>(Function x) l369;
+ Expect.throws(() { l369 = (f369 as dynamic); });
+ Expect.throws(() { l369 = confuse(f369); });
+ }
+ List<T> Function<A>(Function x) l369 = m369;
+ // In checked mode, verifies the type.
+ x369 = m369;
+ x369 = confuse(m369);
+ }
+ }
+
+ void testF469() {
+ // int Function(int x2, [Function x3]) Function(int x)
+ Expect.isTrue(f469 is F469);
+ Expect.isTrue(confuse(f469) is F469);
+ // In checked mode, verifies the type.
+ int Function(int x2, [Function x3]) Function(int x) l469;
+ // The static function f469 sets `T` to `int`.
+ if (!tIsBool) {
+ x469 = f469 as dynamic;
+ l469 = f469 as dynamic;
+ x469 = confuse(f469);
+ l469 = confuse(f469);
+ }
+
+ Expect.isTrue(m469 is F469);
+ Expect.isTrue(m469 is int Function(int x2, [Function x3]) Function(int x));
+ Expect.isTrue(confuse(m469) is F469);
+ // In checked mode, verifies the type.
+ x469 = m469;
+ l469 = m469;
+ x469 = confuse(m469);
+ l469 = confuse(m469);
+
+ }
+
+ void testF569() {
+ // int Function(int x1, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f569 is F569);
+ Expect.isTrue(confuse(f569) is F569);
+ // In checked mode, verifies the type.
+ int Function(int x1, {core.List<core.int> x}) Function(int x) l569;
+ // The static function f569 sets `T` to `int`.
+ if (!tIsBool) {
+ x569 = f569 as dynamic;
+ l569 = f569 as dynamic;
+ x569 = confuse(f569);
+ l569 = confuse(f569);
+ }
+
+ Expect.isTrue(m569 is F569);
+ Expect.isTrue(m569 is int Function(int x1, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m569) is F569);
+ // In checked mode, verifies the type.
+ x569 = m569;
+ l569 = m569;
+ x569 = confuse(m569);
+ l569 = confuse(m569);
+
+ }
+
+ void testF669() {
+ // Function Function(Function x) Function(int x)
+ Expect.isTrue(f669 is F669);
+ Expect.isTrue(confuse(f669) is F669);
+ // In checked mode, verifies the type.
+ Function Function(Function x) Function(int x) l669;
+ // The static function f669 sets `T` to `int`.
+ if (!tIsBool) {
+ x669 = f669 as dynamic;
+ l669 = f669 as dynamic;
+ x669 = confuse(f669);
+ l669 = confuse(f669);
+ }
+
+ Expect.isTrue(m669 is F669);
+ Expect.isTrue(m669 is Function Function(Function x) Function(int x));
+ Expect.isTrue(confuse(m669) is F669);
+ // In checked mode, verifies the type.
+ x669 = m669;
+ l669 = m669;
+ x669 = confuse(m669);
+ l669 = confuse(m669);
+
+ }
+
+ void testF769() {
+ // Function Function(int y, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f769 is F769);
+ Expect.isTrue(confuse(f769) is F769);
+ // In checked mode, verifies the type.
+ Function Function(int y, [core.List<core.int> x]) Function(int x) l769;
+ // The static function f769 sets `T` to `int`.
+ if (!tIsBool) {
+ x769 = f769 as dynamic;
+ l769 = f769 as dynamic;
+ x769 = confuse(f769);
+ l769 = confuse(f769);
+ }
+
+ Expect.isTrue(m769 is F769);
+ Expect.isTrue(m769 is Function Function(int y, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m769) is F769);
+ // In checked mode, verifies the type.
+ x769 = m769;
+ l769 = m769;
+ x769 = confuse(m769);
+ l769 = confuse(m769);
+
+ }
+
+ void testF869() {
+ // List<Function> Function([int x1]) Function(int x)
+ Expect.isTrue(f869 is F869);
+ Expect.isTrue(confuse(f869) is F869);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x1]) Function(int x) l869;
+ // The static function f869 sets `T` to `int`.
+ if (!tIsBool) {
+ x869 = f869 as dynamic;
+ l869 = f869 as dynamic;
+ x869 = confuse(f869);
+ l869 = confuse(f869);
+ }
+
+ Expect.isTrue(m869 is F869);
+ Expect.isTrue(m869 is List<Function> Function([int x1]) Function(int x));
+ Expect.isTrue(confuse(m869) is F869);
+ // In checked mode, verifies the type.
+ x869 = m869;
+ l869 = m869;
+ x869 = confuse(m869);
+ l869 = confuse(m869);
+
+ }
+
+ void testF969() {
+ // List<Function> Function({List<Function> x}) Function(int x)
+ Expect.isTrue(f969 is F969);
+ Expect.isTrue(confuse(f969) is F969);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<Function> x}) Function(int x) l969;
+ // The static function f969 sets `T` to `int`.
+ if (!tIsBool) {
+ x969 = f969 as dynamic;
+ l969 = f969 as dynamic;
+ x969 = confuse(f969);
+ l969 = confuse(f969);
+ }
+
+ Expect.isTrue(m969 is F969);
+ Expect.isTrue(m969 is List<Function> Function({List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m969) is F969);
+ // In checked mode, verifies the type.
+ x969 = m969;
+ l969 = m969;
+ x969 = confuse(m969);
+ l969 = confuse(m969);
+
+ }
+
+ void testF1069() {
+ // List<Function> Function() Function(int x)
+ Expect.isTrue(f1069 is F1069);
+ Expect.isTrue(confuse(f1069) is F1069);
+ // In checked mode, verifies the type.
+ List<Function> Function() Function(int x) l1069;
+ // The static function f1069 sets `T` to `int`.
+ if (!tIsBool) {
+ x1069 = f1069 as dynamic;
+ l1069 = f1069 as dynamic;
+ x1069 = confuse(f1069);
+ l1069 = confuse(f1069);
+ }
+
+ Expect.isTrue(m1069 is F1069);
+ Expect.isTrue(m1069 is List<Function> Function() Function(int x));
+ Expect.isTrue(confuse(m1069) is F1069);
+ // In checked mode, verifies the type.
+ x1069 = m1069;
+ l1069 = m1069;
+ x1069 = confuse(m1069);
+ l1069 = confuse(m1069);
+
+ }
+
+ void testF1169() {
+ // core.List<core.int> Function(int x1, [List<Function> x]) Function(int x)
+ Expect.isTrue(f1169 is F1169);
+ Expect.isTrue(confuse(f1169) is F1169);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<Function> x]) Function(int x) l1169;
+ // The static function f1169 sets `T` to `int`.
+ if (!tIsBool) {
+ x1169 = f1169 as dynamic;
+ l1169 = f1169 as dynamic;
+ x1169 = confuse(f1169);
+ l1169 = confuse(f1169);
+ }
+
+ Expect.isTrue(m1169 is F1169);
+ Expect.isTrue(m1169 is core.List<core.int> Function(int x1, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1169) is F1169);
+ // In checked mode, verifies the type.
+ x1169 = m1169;
+ l1169 = m1169;
+ x1169 = confuse(m1169);
+ l1169 = confuse(m1169);
+
+ }
+
+ void testF1269() {
+ // core.List<core.int> Function([List<T> x1]) Function(int x)
+ Expect.isTrue(f1269 is F1269);
+ Expect.isTrue(confuse(f1269) is F1269);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x1]) Function(int x) l1269;
+ // The static function f1269 sets `T` to `int`.
+ if (!tIsBool) {
+ x1269 = f1269 as dynamic;
+ l1269 = f1269 as dynamic;
+ x1269 = confuse(f1269);
+ l1269 = confuse(f1269);
+ }
+
+ Expect.isTrue(m1269 is F1269);
+ Expect.isTrue(m1269 is core.List<core.int> Function([List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1269) is F1269);
+ // In checked mode, verifies the type.
+ x1269 = m1269;
+ l1269 = m1269;
+ x1269 = confuse(m1269);
+ l1269 = confuse(m1269);
+ if (!tIsBool) {
+ Expect.isTrue(f1269 is F1269<int>);
+ Expect.isFalse(f1269 is F1269<bool>);
+ Expect.isTrue(confuse(f1269) is F1269<int>);
+ Expect.isFalse(confuse(f1269) is F1269<bool>);
+ Expect.equals(tIsDynamic, m1269 is F1269<bool>);
+ Expect.equals(tIsDynamic, confuse(m1269) is F1269<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1269 = (f1269 as dynamic); });
+ Expect.throws(() { x1269 = confuse(f1269); });
+ core.List<core.int> Function([List<T> x1]) Function(int x) l1269;
+ Expect.throws(() { l1269 = (f1269 as dynamic); });
+ Expect.throws(() { l1269 = confuse(f1269); });
+ }
+ core.List<core.int> Function([List<T> x1]) Function(int x) l1269 = m1269;
+ // In checked mode, verifies the type.
+ x1269 = m1269;
+ x1269 = confuse(m1269);
+ }
+ }
+
+ void testF1369() {
+ // List<T> Function(int x, [Function x1]) Function(int x)
+ Expect.isTrue(f1369 is F1369);
+ Expect.isTrue(confuse(f1369) is F1369);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [Function x1]) Function(int x) l1369;
+ // The static function f1369 sets `T` to `int`.
+ if (!tIsBool) {
+ x1369 = f1369 as dynamic;
+ l1369 = f1369 as dynamic;
+ x1369 = confuse(f1369);
+ l1369 = confuse(f1369);
+ }
+
+ Expect.isTrue(m1369 is F1369);
+ Expect.isTrue(m1369 is List<T> Function(int x, [Function x1]) Function(int x));
+ Expect.isTrue(confuse(m1369) is F1369);
+ // In checked mode, verifies the type.
+ x1369 = m1369;
+ l1369 = m1369;
+ x1369 = confuse(m1369);
+ l1369 = confuse(m1369);
+ if (!tIsBool) {
+ Expect.isTrue(f1369 is F1369<int>);
+ Expect.isFalse(f1369 is F1369<bool>);
+ Expect.isTrue(confuse(f1369) is F1369<int>);
+ Expect.isFalse(confuse(f1369) is F1369<bool>);
+ Expect.equals(tIsDynamic, m1369 is F1369<bool>);
+ Expect.equals(tIsDynamic, confuse(m1369) is F1369<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1369 = (f1369 as dynamic); });
+ Expect.throws(() { x1369 = confuse(f1369); });
+ List<T> Function(int x, [Function x1]) Function(int x) l1369;
+ Expect.throws(() { l1369 = (f1369 as dynamic); });
+ Expect.throws(() { l1369 = confuse(f1369); });
+ }
+ List<T> Function(int x, [Function x1]) Function(int x) l1369 = m1369;
+ // In checked mode, verifies the type.
+ x1369 = m1369;
+ x1369 = confuse(m1369);
+ }
+ }
+
+ void testF1469() {
+ // List<T> Function(int y, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1469 is F1469);
+ Expect.isTrue(confuse(f1469) is F1469);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {core.List<core.int> x}) Function(int x) l1469;
+ // The static function f1469 sets `T` to `int`.
+ if (!tIsBool) {
+ x1469 = f1469 as dynamic;
+ l1469 = f1469 as dynamic;
+ x1469 = confuse(f1469);
+ l1469 = confuse(f1469);
+ }
+
+ Expect.isTrue(m1469 is F1469);
+ Expect.isTrue(m1469 is List<T> Function(int y, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1469) is F1469);
+ // In checked mode, verifies the type.
+ x1469 = m1469;
+ l1469 = m1469;
+ x1469 = confuse(m1469);
+ l1469 = confuse(m1469);
+ if (!tIsBool) {
+ Expect.isTrue(f1469 is F1469<int>);
+ Expect.isFalse(f1469 is F1469<bool>);
+ Expect.isTrue(confuse(f1469) is F1469<int>);
+ Expect.isFalse(confuse(f1469) is F1469<bool>);
+ Expect.equals(tIsDynamic, m1469 is F1469<bool>);
+ Expect.equals(tIsDynamic, confuse(m1469) is F1469<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1469 = (f1469 as dynamic); });
+ Expect.throws(() { x1469 = confuse(f1469); });
+ List<T> Function(int y, {core.List<core.int> x}) Function(int x) l1469;
+ Expect.throws(() { l1469 = (f1469 as dynamic); });
+ Expect.throws(() { l1469 = confuse(f1469); });
+ }
+ List<T> Function(int y, {core.List<core.int> x}) Function(int x) l1469 = m1469;
+ // In checked mode, verifies the type.
+ x1469 = m1469;
+ x1469 = confuse(m1469);
+ }
+ }
+
+ void testF1569() {
+ // Function([Function x]) Function(int x)
+ Expect.isTrue(f1569 is F1569);
+ Expect.isTrue(confuse(f1569) is F1569);
+ // In checked mode, verifies the type.
+ Function([Function x]) Function(int x) l1569;
+ // The static function f1569 sets `T` to `int`.
+ if (!tIsBool) {
+ x1569 = f1569 as dynamic;
+ l1569 = f1569 as dynamic;
+ x1569 = confuse(f1569);
+ l1569 = confuse(f1569);
+ }
+
+ Expect.isTrue(m1569 is F1569);
+ Expect.isTrue(m1569 is Function([Function x]) Function(int x));
+ Expect.isTrue(confuse(m1569) is F1569);
+ // In checked mode, verifies the type.
+ x1569 = m1569;
+ l1569 = m1569;
+ x1569 = confuse(m1569);
+ l1569 = confuse(m1569);
+
+ }
+
+ void testF1669() {
+ // Function(core.List<core.int> x1) Function(int x)
+ Expect.isTrue(f1669 is F1669);
+ Expect.isTrue(confuse(f1669) is F1669);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x1) Function(int x) l1669;
+ // The static function f1669 sets `T` to `int`.
+ if (!tIsBool) {
+ x1669 = f1669 as dynamic;
+ l1669 = f1669 as dynamic;
+ x1669 = confuse(f1669);
+ l1669 = confuse(f1669);
+ }
+
+ Expect.isTrue(m1669 is F1669);
+ Expect.isTrue(m1669 is Function(core.List<core.int> x1) Function(int x));
+ Expect.isTrue(confuse(m1669) is F1669);
+ // In checked mode, verifies the type.
+ x1669 = m1669;
+ l1669 = m1669;
+ x1669 = confuse(m1669);
+ l1669 = confuse(m1669);
+
+ }
+
+ void testF1769() {
+ // int Function<A>(A x) Function(int x)
+ Expect.isTrue(f1769 is F1769);
+ Expect.isTrue(confuse(f1769) is F1769);
+ // In checked mode, verifies the type.
+ int Function<A>(A x) Function(int x) l1769;
+ // The static function f1769 sets `T` to `int`.
+ if (!tIsBool) {
+ x1769 = f1769 as dynamic;
+ l1769 = f1769 as dynamic;
+ x1769 = confuse(f1769);
+ l1769 = confuse(f1769);
+ }
+
+ Expect.isTrue(m1769 is F1769);
+ Expect.isTrue(m1769 is int Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1769) is F1769);
+ // In checked mode, verifies the type.
+ x1769 = m1769;
+ l1769 = m1769;
+ x1769 = confuse(m1769);
+ l1769 = confuse(m1769);
+
+ }
+
+ void testF1869() {
+ // core.List<core.int> Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1869 is F1869);
+ Expect.isTrue(confuse(f1869) is F1869);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<A> x) Function(int x) l1869;
+ // The static function f1869 sets `T` to `int`.
+ if (!tIsBool) {
+ x1869 = f1869 as dynamic;
+ l1869 = f1869 as dynamic;
+ x1869 = confuse(f1869);
+ l1869 = confuse(f1869);
+ }
+
+ Expect.isTrue(m1869 is F1869);
+ Expect.isTrue(m1869 is core.List<core.int> Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1869) is F1869);
+ // In checked mode, verifies the type.
+ x1869 = m1869;
+ l1869 = m1869;
+ x1869 = confuse(m1869);
+ l1869 = confuse(m1869);
+
+ }
+
+ void testF1969() {
+ // List<A> Function<A>(int x) Function(int x)
+ Expect.isTrue(f1969 is F1969);
+ Expect.isTrue(confuse(f1969) is F1969);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(int x) Function(int x) l1969;
+ // The static function f1969 sets `T` to `int`.
+ if (!tIsBool) {
+ x1969 = f1969 as dynamic;
+ l1969 = f1969 as dynamic;
+ x1969 = confuse(f1969);
+ l1969 = confuse(f1969);
+ }
+
+ Expect.isTrue(m1969 is F1969);
+ Expect.isTrue(m1969 is List<A> Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1969) is F1969);
+ // In checked mode, verifies the type.
+ x1969 = m1969;
+ l1969 = m1969;
+ x1969 = confuse(m1969);
+ l1969 = confuse(m1969);
+
+ }
+
+
+}
+
+class C70<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, [Function x]) x70;
+ core.List<core.int> Function(int x0, [int x]) x170;
+ List<T> Function(int x0, [List<T> x]) x270;
+ List<T> Function<A>(List<Function> x) x370;
+ int Function(int x2, [Function x3]) Function<B extends core.int>() x470;
+ int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() x570;
+ Function Function(Function x) Function<B extends core.int>() x670;
+ Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>() x770;
+ List<Function> Function([int x1]) Function<B extends core.int>() x870;
+ List<Function> Function({List<Function> x}) Function<B extends core.int>() x970;
+ List<Function> Function() Function<B extends core.int>() x1070;
+ core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>() x1170;
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>() x1270;
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>() x1370;
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() x1470;
+ Function([Function x]) Function<B extends core.int>() x1570;
+ Function(core.List<core.int> x1) Function<B extends core.int>() x1670;
+ int Function<A>(A x) Function<B extends core.int>() x1770;
+ core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>() x1870;
+ List<A> Function<A>(int x) Function<B extends core.int>() x1970;
+
+
+ C70({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m70(int y, [Function x]) => null;
+ core.List<core.int> m170(int x0, [int x]) => null;
+ List<T> m270(int x0, [List<T> x]) => null;
+ List<T> m370<A>(List<Function> x) => null;
+ int Function(int x0, [Function x1]) m470<B extends core.int>() => null;
+ int Function(int x0, {core.List<core.int> x}) m570<B extends core.int>() => null;
+ Function Function(Function x) m670<B extends core.int>() => null;
+ Function Function(int y, [core.List<core.int> x]) m770<B extends core.int>() => null;
+ List<Function> Function([int x0]) m870<B extends core.int>() => null;
+ List<Function> Function({List<Function> x}) m970<B extends core.int>() => null;
+ List<Function> Function() m1070<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [List<Function> x]) m1170<B extends core.int>() => null;
+ core.List<core.int> Function([List<T> x0]) m1270<B extends core.int>() => null;
+ List<T> Function(int x, [Function x0]) m1370<B extends core.int>() => null;
+ List<T> Function(int y, {core.List<core.int> x}) m1470<B extends core.int>() => null;
+ Function([Function x]) m1570<B extends core.int>() => null;
+ Function(core.List<core.int> x0) m1670<B extends core.int>() => null;
+ int Function<A>(A x) m1770<B extends core.int>() => null;
+ core.List<core.int> Function<A>(List<A> x) m1870<B extends core.int>() => null;
+ List<A> Function<A>(int x) m1970<B extends core.int>() => null;
+
+
+ runTests() {
+ testF70();
+ testF170();
+ testF270();
+ testF370();
+ testF470();
+ testF570();
+ testF670();
+ testF770();
+ testF870();
+ testF970();
+ testF1070();
+ testF1170();
+ testF1270();
+ testF1370();
+ testF1470();
+ testF1570();
+ testF1670();
+ testF1770();
+ testF1870();
+ testF1970();
+ }
+
+ void testF70() {
+ // Function Function(int y, [Function x])
+ Expect.isTrue(f70 is F70);
+ Expect.isTrue(confuse(f70) is F70);
+ // In checked mode, verifies the type.
+ Function Function(int y, [Function x]) l70;
+ // The static function f70 sets `T` to `int`.
+ if (!tIsBool) {
+ x70 = f70 as dynamic;
+ l70 = f70 as dynamic;
+ x70 = confuse(f70);
+ l70 = confuse(f70);
+ }
+
+ Expect.isTrue(m70 is F70);
+ Expect.isTrue(m70 is Function Function(int y, [Function x]));
+ Expect.isTrue(confuse(m70) is F70);
+ // In checked mode, verifies the type.
+ x70 = m70;
+ l70 = m70;
+ x70 = confuse(m70);
+ l70 = confuse(m70);
+
+ }
+
+ void testF170() {
+ // core.List<core.int> Function(int x0, [int x])
+ Expect.isTrue(f170 is F170);
+ Expect.isTrue(confuse(f170) is F170);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [int x]) l170;
+ // The static function f170 sets `T` to `int`.
+ if (!tIsBool) {
+ x170 = f170 as dynamic;
+ l170 = f170 as dynamic;
+ x170 = confuse(f170);
+ l170 = confuse(f170);
+ }
+
+ Expect.isTrue(m170 is F170);
+ Expect.isTrue(m170 is core.List<core.int> Function(int x0, [int x]));
+ Expect.isTrue(confuse(m170) is F170);
+ // In checked mode, verifies the type.
+ x170 = m170;
+ l170 = m170;
+ x170 = confuse(m170);
+ l170 = confuse(m170);
+
+ }
+
+ void testF270() {
+ // List<T> Function(int x0, [List<T> x])
+ Expect.isTrue(f270 is F270);
+ Expect.isTrue(confuse(f270) is F270);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [List<T> x]) l270;
+ // The static function f270 sets `T` to `int`.
+ if (!tIsBool) {
+ x270 = f270 as dynamic;
+ l270 = f270 as dynamic;
+ x270 = confuse(f270);
+ l270 = confuse(f270);
+ }
+
+ Expect.isTrue(m270 is F270);
+ Expect.isTrue(m270 is List<T> Function(int x0, [List<T> x]));
+ Expect.isTrue(confuse(m270) is F270);
+ // In checked mode, verifies the type.
+ x270 = m270;
+ l270 = m270;
+ x270 = confuse(m270);
+ l270 = confuse(m270);
+ if (!tIsBool) {
+ Expect.isTrue(f270 is F270<int>);
+ Expect.isFalse(f270 is F270<bool>);
+ Expect.isTrue(confuse(f270) is F270<int>);
+ Expect.isFalse(confuse(f270) is F270<bool>);
+ Expect.equals(tIsDynamic, m270 is F270<bool>);
+ Expect.equals(tIsDynamic, confuse(m270) is F270<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x270 = (f270 as dynamic); });
+ Expect.throws(() { x270 = confuse(f270); });
+ List<T> Function(int x0, [List<T> x]) l270;
+ Expect.throws(() { l270 = (f270 as dynamic); });
+ Expect.throws(() { l270 = confuse(f270); });
+ }
+ List<T> Function(int x0, [List<T> x]) l270 = m270;
+ // In checked mode, verifies the type.
+ x270 = m270;
+ x270 = confuse(m270);
+ }
+ }
+
+ void testF370() {
+ // List<T> Function<A>(List<Function> x)
+ Expect.isTrue(f370 is F370);
+ Expect.isTrue(confuse(f370) is F370);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<Function> x) l370;
+ // The static function f370 sets `T` to `int`.
+ if (!tIsBool) {
+ x370 = f370 as dynamic;
+ l370 = f370 as dynamic;
+ x370 = confuse(f370);
+ l370 = confuse(f370);
+ }
+
+ Expect.isTrue(m370 is F370);
+ Expect.isTrue(m370 is List<T> Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m370) is F370);
+ // In checked mode, verifies the type.
+ x370 = m370;
+ l370 = m370;
+ x370 = confuse(m370);
+ l370 = confuse(m370);
+ if (!tIsBool) {
+ Expect.isTrue(f370 is F370<int>);
+ Expect.isFalse(f370 is F370<bool>);
+ Expect.isTrue(confuse(f370) is F370<int>);
+ Expect.isFalse(confuse(f370) is F370<bool>);
+ Expect.equals(tIsDynamic, m370 is F370<bool>);
+ Expect.equals(tIsDynamic, confuse(m370) is F370<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x370 = (f370 as dynamic); });
+ Expect.throws(() { x370 = confuse(f370); });
+ List<T> Function<A>(List<Function> x) l370;
+ Expect.throws(() { l370 = (f370 as dynamic); });
+ Expect.throws(() { l370 = confuse(f370); });
+ }
+ List<T> Function<A>(List<Function> x) l370 = m370;
+ // In checked mode, verifies the type.
+ x370 = m370;
+ x370 = confuse(m370);
+ }
+ }
+
+ void testF470() {
+ // int Function(int x2, [Function x3]) Function<B extends core.int>()
+ Expect.isTrue(f470 is F470);
+ Expect.isTrue(confuse(f470) is F470);
+ // In checked mode, verifies the type.
+ int Function(int x2, [Function x3]) Function<B extends core.int>() l470;
+ // The static function f470 sets `T` to `int`.
+ if (!tIsBool) {
+ x470 = f470 as dynamic;
+ l470 = f470 as dynamic;
+ x470 = confuse(f470);
+ l470 = confuse(f470);
+ }
+
+ Expect.isTrue(m470 is F470);
+ Expect.isTrue(m470 is int Function(int x2, [Function x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m470) is F470);
+ // In checked mode, verifies the type.
+ x470 = m470;
+ l470 = m470;
+ x470 = confuse(m470);
+ l470 = confuse(m470);
+
+ }
+
+ void testF570() {
+ // int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f570 is F570);
+ Expect.isTrue(confuse(f570) is F570);
+ // In checked mode, verifies the type.
+ int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l570;
+ // The static function f570 sets `T` to `int`.
+ if (!tIsBool) {
+ x570 = f570 as dynamic;
+ l570 = f570 as dynamic;
+ x570 = confuse(f570);
+ l570 = confuse(f570);
+ }
+
+ Expect.isTrue(m570 is F570);
+ Expect.isTrue(m570 is int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m570) is F570);
+ // In checked mode, verifies the type.
+ x570 = m570;
+ l570 = m570;
+ x570 = confuse(m570);
+ l570 = confuse(m570);
+
+ }
+
+ void testF670() {
+ // Function Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f670 is F670);
+ Expect.isTrue(confuse(f670) is F670);
+ // In checked mode, verifies the type.
+ Function Function(Function x) Function<B extends core.int>() l670;
+ // The static function f670 sets `T` to `int`.
+ if (!tIsBool) {
+ x670 = f670 as dynamic;
+ l670 = f670 as dynamic;
+ x670 = confuse(f670);
+ l670 = confuse(f670);
+ }
+
+ Expect.isTrue(m670 is F670);
+ Expect.isTrue(m670 is Function Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m670) is F670);
+ // In checked mode, verifies the type.
+ x670 = m670;
+ l670 = m670;
+ x670 = confuse(m670);
+ l670 = confuse(m670);
+
+ }
+
+ void testF770() {
+ // Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f770 is F770);
+ Expect.isTrue(confuse(f770) is F770);
+ // In checked mode, verifies the type.
+ Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l770;
+ // The static function f770 sets `T` to `int`.
+ if (!tIsBool) {
+ x770 = f770 as dynamic;
+ l770 = f770 as dynamic;
+ x770 = confuse(f770);
+ l770 = confuse(f770);
+ }
+
+ Expect.isTrue(m770 is F770);
+ Expect.isTrue(m770 is Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m770) is F770);
+ // In checked mode, verifies the type.
+ x770 = m770;
+ l770 = m770;
+ x770 = confuse(m770);
+ l770 = confuse(m770);
+
+ }
+
+ void testF870() {
+ // List<Function> Function([int x1]) Function<B extends core.int>()
+ Expect.isTrue(f870 is F870);
+ Expect.isTrue(confuse(f870) is F870);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x1]) Function<B extends core.int>() l870;
+ // The static function f870 sets `T` to `int`.
+ if (!tIsBool) {
+ x870 = f870 as dynamic;
+ l870 = f870 as dynamic;
+ x870 = confuse(f870);
+ l870 = confuse(f870);
+ }
+
+ Expect.isTrue(m870 is F870);
+ Expect.isTrue(m870 is List<Function> Function([int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m870) is F870);
+ // In checked mode, verifies the type.
+ x870 = m870;
+ l870 = m870;
+ x870 = confuse(m870);
+ l870 = confuse(m870);
+
+ }
+
+ void testF970() {
+ // List<Function> Function({List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f970 is F970);
+ Expect.isTrue(confuse(f970) is F970);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<Function> x}) Function<B extends core.int>() l970;
+ // The static function f970 sets `T` to `int`.
+ if (!tIsBool) {
+ x970 = f970 as dynamic;
+ l970 = f970 as dynamic;
+ x970 = confuse(f970);
+ l970 = confuse(f970);
+ }
+
+ Expect.isTrue(m970 is F970);
+ Expect.isTrue(m970 is List<Function> Function({List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m970) is F970);
+ // In checked mode, verifies the type.
+ x970 = m970;
+ l970 = m970;
+ x970 = confuse(m970);
+ l970 = confuse(m970);
+
+ }
+
+ void testF1070() {
+ // List<Function> Function() Function<B extends core.int>()
+ Expect.isTrue(f1070 is F1070);
+ Expect.isTrue(confuse(f1070) is F1070);
+ // In checked mode, verifies the type.
+ List<Function> Function() Function<B extends core.int>() l1070;
+ // The static function f1070 sets `T` to `int`.
+ if (!tIsBool) {
+ x1070 = f1070 as dynamic;
+ l1070 = f1070 as dynamic;
+ x1070 = confuse(f1070);
+ l1070 = confuse(f1070);
+ }
+
+ Expect.isTrue(m1070 is F1070);
+ Expect.isTrue(m1070 is List<Function> Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1070) is F1070);
+ // In checked mode, verifies the type.
+ x1070 = m1070;
+ l1070 = m1070;
+ x1070 = confuse(m1070);
+ l1070 = confuse(m1070);
+
+ }
+
+ void testF1170() {
+ // core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1170 is F1170);
+ Expect.isTrue(confuse(f1170) is F1170);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>() l1170;
+ // The static function f1170 sets `T` to `int`.
+ if (!tIsBool) {
+ x1170 = f1170 as dynamic;
+ l1170 = f1170 as dynamic;
+ x1170 = confuse(f1170);
+ l1170 = confuse(f1170);
+ }
+
+ Expect.isTrue(m1170 is F1170);
+ Expect.isTrue(m1170 is core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1170) is F1170);
+ // In checked mode, verifies the type.
+ x1170 = m1170;
+ l1170 = m1170;
+ x1170 = confuse(m1170);
+ l1170 = confuse(m1170);
+
+ }
+
+ void testF1270() {
+ // core.List<core.int> Function([List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1270 is F1270);
+ Expect.isTrue(confuse(f1270) is F1270);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>() l1270;
+ // The static function f1270 sets `T` to `int`.
+ if (!tIsBool) {
+ x1270 = f1270 as dynamic;
+ l1270 = f1270 as dynamic;
+ x1270 = confuse(f1270);
+ l1270 = confuse(f1270);
+ }
+
+ Expect.isTrue(m1270 is F1270);
+ Expect.isTrue(m1270 is core.List<core.int> Function([List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1270) is F1270);
+ // In checked mode, verifies the type.
+ x1270 = m1270;
+ l1270 = m1270;
+ x1270 = confuse(m1270);
+ l1270 = confuse(m1270);
+ if (!tIsBool) {
+ Expect.isTrue(f1270 is F1270<int>);
+ Expect.isFalse(f1270 is F1270<bool>);
+ Expect.isTrue(confuse(f1270) is F1270<int>);
+ Expect.isFalse(confuse(f1270) is F1270<bool>);
+ Expect.equals(tIsDynamic, m1270 is F1270<bool>);
+ Expect.equals(tIsDynamic, confuse(m1270) is F1270<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1270 = (f1270 as dynamic); });
+ Expect.throws(() { x1270 = confuse(f1270); });
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>() l1270;
+ Expect.throws(() { l1270 = (f1270 as dynamic); });
+ Expect.throws(() { l1270 = confuse(f1270); });
+ }
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>() l1270 = m1270;
+ // In checked mode, verifies the type.
+ x1270 = m1270;
+ x1270 = confuse(m1270);
+ }
+ }
+
+ void testF1370() {
+ // List<T> Function(int x, [Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f1370 is F1370);
+ Expect.isTrue(confuse(f1370) is F1370);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>() l1370;
+ // The static function f1370 sets `T` to `int`.
+ if (!tIsBool) {
+ x1370 = f1370 as dynamic;
+ l1370 = f1370 as dynamic;
+ x1370 = confuse(f1370);
+ l1370 = confuse(f1370);
+ }
+
+ Expect.isTrue(m1370 is F1370);
+ Expect.isTrue(m1370 is List<T> Function(int x, [Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1370) is F1370);
+ // In checked mode, verifies the type.
+ x1370 = m1370;
+ l1370 = m1370;
+ x1370 = confuse(m1370);
+ l1370 = confuse(m1370);
+ if (!tIsBool) {
+ Expect.isTrue(f1370 is F1370<int>);
+ Expect.isFalse(f1370 is F1370<bool>);
+ Expect.isTrue(confuse(f1370) is F1370<int>);
+ Expect.isFalse(confuse(f1370) is F1370<bool>);
+ Expect.equals(tIsDynamic, m1370 is F1370<bool>);
+ Expect.equals(tIsDynamic, confuse(m1370) is F1370<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1370 = (f1370 as dynamic); });
+ Expect.throws(() { x1370 = confuse(f1370); });
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>() l1370;
+ Expect.throws(() { l1370 = (f1370 as dynamic); });
+ Expect.throws(() { l1370 = confuse(f1370); });
+ }
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>() l1370 = m1370;
+ // In checked mode, verifies the type.
+ x1370 = m1370;
+ x1370 = confuse(m1370);
+ }
+ }
+
+ void testF1470() {
+ // List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1470 is F1470);
+ Expect.isTrue(confuse(f1470) is F1470);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l1470;
+ // The static function f1470 sets `T` to `int`.
+ if (!tIsBool) {
+ x1470 = f1470 as dynamic;
+ l1470 = f1470 as dynamic;
+ x1470 = confuse(f1470);
+ l1470 = confuse(f1470);
+ }
+
+ Expect.isTrue(m1470 is F1470);
+ Expect.isTrue(m1470 is List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1470) is F1470);
+ // In checked mode, verifies the type.
+ x1470 = m1470;
+ l1470 = m1470;
+ x1470 = confuse(m1470);
+ l1470 = confuse(m1470);
+ if (!tIsBool) {
+ Expect.isTrue(f1470 is F1470<int>);
+ Expect.isFalse(f1470 is F1470<bool>);
+ Expect.isTrue(confuse(f1470) is F1470<int>);
+ Expect.isFalse(confuse(f1470) is F1470<bool>);
+ Expect.equals(tIsDynamic, m1470 is F1470<bool>);
+ Expect.equals(tIsDynamic, confuse(m1470) is F1470<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1470 = (f1470 as dynamic); });
+ Expect.throws(() { x1470 = confuse(f1470); });
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l1470;
+ Expect.throws(() { l1470 = (f1470 as dynamic); });
+ Expect.throws(() { l1470 = confuse(f1470); });
+ }
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l1470 = m1470;
+ // In checked mode, verifies the type.
+ x1470 = m1470;
+ x1470 = confuse(m1470);
+ }
+ }
+
+ void testF1570() {
+ // Function([Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1570 is F1570);
+ Expect.isTrue(confuse(f1570) is F1570);
+ // In checked mode, verifies the type.
+ Function([Function x]) Function<B extends core.int>() l1570;
+ // The static function f1570 sets `T` to `int`.
+ if (!tIsBool) {
+ x1570 = f1570 as dynamic;
+ l1570 = f1570 as dynamic;
+ x1570 = confuse(f1570);
+ l1570 = confuse(f1570);
+ }
+
+ Expect.isTrue(m1570 is F1570);
+ Expect.isTrue(m1570 is Function([Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1570) is F1570);
+ // In checked mode, verifies the type.
+ x1570 = m1570;
+ l1570 = m1570;
+ x1570 = confuse(m1570);
+ l1570 = confuse(m1570);
+
+ }
+
+ void testF1670() {
+ // Function(core.List<core.int> x1) Function<B extends core.int>()
+ Expect.isTrue(f1670 is F1670);
+ Expect.isTrue(confuse(f1670) is F1670);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x1) Function<B extends core.int>() l1670;
+ // The static function f1670 sets `T` to `int`.
+ if (!tIsBool) {
+ x1670 = f1670 as dynamic;
+ l1670 = f1670 as dynamic;
+ x1670 = confuse(f1670);
+ l1670 = confuse(f1670);
+ }
+
+ Expect.isTrue(m1670 is F1670);
+ Expect.isTrue(m1670 is Function(core.List<core.int> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1670) is F1670);
+ // In checked mode, verifies the type.
+ x1670 = m1670;
+ l1670 = m1670;
+ x1670 = confuse(m1670);
+ l1670 = confuse(m1670);
+
+ }
+
+ void testF1770() {
+ // int Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1770 is F1770);
+ Expect.isTrue(confuse(f1770) is F1770);
+ // In checked mode, verifies the type.
+ int Function<A>(A x) Function<B extends core.int>() l1770;
+ // The static function f1770 sets `T` to `int`.
+ if (!tIsBool) {
+ x1770 = f1770 as dynamic;
+ l1770 = f1770 as dynamic;
+ x1770 = confuse(f1770);
+ l1770 = confuse(f1770);
+ }
+
+ Expect.isTrue(m1770 is F1770);
+ Expect.isTrue(m1770 is int Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1770) is F1770);
+ // In checked mode, verifies the type.
+ x1770 = m1770;
+ l1770 = m1770;
+ x1770 = confuse(m1770);
+ l1770 = confuse(m1770);
+
+ }
+
+ void testF1870() {
+ // core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1870 is F1870);
+ Expect.isTrue(confuse(f1870) is F1870);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>() l1870;
+ // The static function f1870 sets `T` to `int`.
+ if (!tIsBool) {
+ x1870 = f1870 as dynamic;
+ l1870 = f1870 as dynamic;
+ x1870 = confuse(f1870);
+ l1870 = confuse(f1870);
+ }
+
+ Expect.isTrue(m1870 is F1870);
+ Expect.isTrue(m1870 is core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1870) is F1870);
+ // In checked mode, verifies the type.
+ x1870 = m1870;
+ l1870 = m1870;
+ x1870 = confuse(m1870);
+ l1870 = confuse(m1870);
+
+ }
+
+ void testF1970() {
+ // List<A> Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1970 is F1970);
+ Expect.isTrue(confuse(f1970) is F1970);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(int x) Function<B extends core.int>() l1970;
+ // The static function f1970 sets `T` to `int`.
+ if (!tIsBool) {
+ x1970 = f1970 as dynamic;
+ l1970 = f1970 as dynamic;
+ x1970 = confuse(f1970);
+ l1970 = confuse(f1970);
+ }
+
+ Expect.isTrue(m1970 is F1970);
+ Expect.isTrue(m1970 is List<A> Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1970) is F1970);
+ // In checked mode, verifies the type.
+ x1970 = m1970;
+ l1970 = m1970;
+ x1970 = confuse(m1970);
+ l1970 = confuse(m1970);
+
+ }
+
+
+}
+
+class C71<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(Function x0) x71;
+ core.List<core.int> Function(int y, [int x]) x171;
+ List<T> Function(int y, [List<T> x]) x271;
+ List<T> Function<A>(core.List<core.int> x) x371;
+ int Function(int x2, [Function x3]) Function<B extends core.int>(int x) x471;
+ int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) x571;
+ Function Function(Function x) Function<B extends core.int>(int x) x671;
+ Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) x771;
+ List<Function> Function([int x1]) Function<B extends core.int>(int x) x871;
+ List<Function> Function({List<Function> x}) Function<B extends core.int>(int x) x971;
+ List<Function> Function() Function<B extends core.int>(int x) x1071;
+ core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) x1171;
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x) x1271;
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x) x1371;
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) x1471;
+ Function([Function x]) Function<B extends core.int>(int x) x1571;
+ Function(core.List<core.int> x1) Function<B extends core.int>(int x) x1671;
+ int Function<A>(A x) Function<B extends core.int>(int x) x1771;
+ core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>(int x) x1871;
+ List<A> Function<A>(int x) Function<B extends core.int>(int x) x1971;
+
+
+ C71({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m71(Function x0) => null;
+ core.List<core.int> m171(int y, [int x]) => null;
+ List<T> m271(int y, [List<T> x]) => null;
+ List<T> m371<A>(core.List<core.int> x) => null;
+ int Function(int x0, [Function x1]) m471<B extends core.int>(int x) => null;
+ int Function(int x0, {core.List<core.int> x}) m571<B extends core.int>(int x) => null;
+ Function Function(Function x) m671<B extends core.int>(int x) => null;
+ Function Function(int y, [core.List<core.int> x]) m771<B extends core.int>(int x) => null;
+ List<Function> Function([int x0]) m871<B extends core.int>(int x) => null;
+ List<Function> Function({List<Function> x}) m971<B extends core.int>(int x) => null;
+ List<Function> Function() m1071<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [List<Function> x]) m1171<B extends core.int>(int x) => null;
+ core.List<core.int> Function([List<T> x0]) m1271<B extends core.int>(int x) => null;
+ List<T> Function(int x, [Function x0]) m1371<B extends core.int>(int x) => null;
+ List<T> Function(int y, {core.List<core.int> x}) m1471<B extends core.int>(int x) => null;
+ Function([Function x]) m1571<B extends core.int>(int x) => null;
+ Function(core.List<core.int> x0) m1671<B extends core.int>(int x) => null;
+ int Function<A>(A x) m1771<B extends core.int>(int x) => null;
+ core.List<core.int> Function<A>(List<A> x) m1871<B extends core.int>(int x) => null;
+ List<A> Function<A>(int x) m1971<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF71();
+ testF171();
+ testF271();
+ testF371();
+ testF471();
+ testF571();
+ testF671();
+ testF771();
+ testF871();
+ testF971();
+ testF1071();
+ testF1171();
+ testF1271();
+ testF1371();
+ testF1471();
+ testF1571();
+ testF1671();
+ testF1771();
+ testF1871();
+ testF1971();
+ }
+
+ void testF71() {
+ // Function Function(Function x0)
+ Expect.isTrue(f71 is F71);
+ Expect.isTrue(confuse(f71) is F71);
+ // In checked mode, verifies the type.
+ Function Function(Function x0) l71;
+ // The static function f71 sets `T` to `int`.
+ if (!tIsBool) {
+ x71 = f71 as dynamic;
+ l71 = f71 as dynamic;
+ x71 = confuse(f71);
+ l71 = confuse(f71);
+ }
+
+ Expect.isTrue(m71 is F71);
+ Expect.isTrue(m71 is Function Function(Function x0));
+ Expect.isTrue(confuse(m71) is F71);
+ // In checked mode, verifies the type.
+ x71 = m71;
+ l71 = m71;
+ x71 = confuse(m71);
+ l71 = confuse(m71);
+
+ }
+
+ void testF171() {
+ // core.List<core.int> Function(int y, [int x])
+ Expect.isTrue(f171 is F171);
+ Expect.isTrue(confuse(f171) is F171);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [int x]) l171;
+ // The static function f171 sets `T` to `int`.
+ if (!tIsBool) {
+ x171 = f171 as dynamic;
+ l171 = f171 as dynamic;
+ x171 = confuse(f171);
+ l171 = confuse(f171);
+ }
+
+ Expect.isTrue(m171 is F171);
+ Expect.isTrue(m171 is core.List<core.int> Function(int y, [int x]));
+ Expect.isTrue(confuse(m171) is F171);
+ // In checked mode, verifies the type.
+ x171 = m171;
+ l171 = m171;
+ x171 = confuse(m171);
+ l171 = confuse(m171);
+
+ }
+
+ void testF271() {
+ // List<T> Function(int y, [List<T> x])
+ Expect.isTrue(f271 is F271);
+ Expect.isTrue(confuse(f271) is F271);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<T> x]) l271;
+ // The static function f271 sets `T` to `int`.
+ if (!tIsBool) {
+ x271 = f271 as dynamic;
+ l271 = f271 as dynamic;
+ x271 = confuse(f271);
+ l271 = confuse(f271);
+ }
+
+ Expect.isTrue(m271 is F271);
+ Expect.isTrue(m271 is List<T> Function(int y, [List<T> x]));
+ Expect.isTrue(confuse(m271) is F271);
+ // In checked mode, verifies the type.
+ x271 = m271;
+ l271 = m271;
+ x271 = confuse(m271);
+ l271 = confuse(m271);
+ if (!tIsBool) {
+ Expect.isTrue(f271 is F271<int>);
+ Expect.isFalse(f271 is F271<bool>);
+ Expect.isTrue(confuse(f271) is F271<int>);
+ Expect.isFalse(confuse(f271) is F271<bool>);
+ Expect.equals(tIsDynamic, m271 is F271<bool>);
+ Expect.equals(tIsDynamic, confuse(m271) is F271<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x271 = (f271 as dynamic); });
+ Expect.throws(() { x271 = confuse(f271); });
+ List<T> Function(int y, [List<T> x]) l271;
+ Expect.throws(() { l271 = (f271 as dynamic); });
+ Expect.throws(() { l271 = confuse(f271); });
+ }
+ List<T> Function(int y, [List<T> x]) l271 = m271;
+ // In checked mode, verifies the type.
+ x271 = m271;
+ x271 = confuse(m271);
+ }
+ }
+
+ void testF371() {
+ // List<T> Function<A>(core.List<core.int> x)
+ Expect.isTrue(f371 is F371);
+ Expect.isTrue(confuse(f371) is F371);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(core.List<core.int> x) l371;
+ // The static function f371 sets `T` to `int`.
+ if (!tIsBool) {
+ x371 = f371 as dynamic;
+ l371 = f371 as dynamic;
+ x371 = confuse(f371);
+ l371 = confuse(f371);
+ }
+
+ Expect.isTrue(m371 is F371);
+ Expect.isTrue(m371 is List<T> Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m371) is F371);
+ // In checked mode, verifies the type.
+ x371 = m371;
+ l371 = m371;
+ x371 = confuse(m371);
+ l371 = confuse(m371);
+ if (!tIsBool) {
+ Expect.isTrue(f371 is F371<int>);
+ Expect.isFalse(f371 is F371<bool>);
+ Expect.isTrue(confuse(f371) is F371<int>);
+ Expect.isFalse(confuse(f371) is F371<bool>);
+ Expect.equals(tIsDynamic, m371 is F371<bool>);
+ Expect.equals(tIsDynamic, confuse(m371) is F371<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x371 = (f371 as dynamic); });
+ Expect.throws(() { x371 = confuse(f371); });
+ List<T> Function<A>(core.List<core.int> x) l371;
+ Expect.throws(() { l371 = (f371 as dynamic); });
+ Expect.throws(() { l371 = confuse(f371); });
+ }
+ List<T> Function<A>(core.List<core.int> x) l371 = m371;
+ // In checked mode, verifies the type.
+ x371 = m371;
+ x371 = confuse(m371);
+ }
+ }
+
+ void testF471() {
+ // int Function(int x2, [Function x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f471 is F471);
+ Expect.isTrue(confuse(f471) is F471);
+ // In checked mode, verifies the type.
+ int Function(int x2, [Function x3]) Function<B extends core.int>(int x) l471;
+ // The static function f471 sets `T` to `int`.
+ if (!tIsBool) {
+ x471 = f471 as dynamic;
+ l471 = f471 as dynamic;
+ x471 = confuse(f471);
+ l471 = confuse(f471);
+ }
+
+ Expect.isTrue(m471 is F471);
+ Expect.isTrue(m471 is int Function(int x2, [Function x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m471) is F471);
+ // In checked mode, verifies the type.
+ x471 = m471;
+ l471 = m471;
+ x471 = confuse(m471);
+ l471 = confuse(m471);
+
+ }
+
+ void testF571() {
+ // int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f571 is F571);
+ Expect.isTrue(confuse(f571) is F571);
+ // In checked mode, verifies the type.
+ int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l571;
+ // The static function f571 sets `T` to `int`.
+ if (!tIsBool) {
+ x571 = f571 as dynamic;
+ l571 = f571 as dynamic;
+ x571 = confuse(f571);
+ l571 = confuse(f571);
+ }
+
+ Expect.isTrue(m571 is F571);
+ Expect.isTrue(m571 is int Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m571) is F571);
+ // In checked mode, verifies the type.
+ x571 = m571;
+ l571 = m571;
+ x571 = confuse(m571);
+ l571 = confuse(m571);
+
+ }
+
+ void testF671() {
+ // Function Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f671 is F671);
+ Expect.isTrue(confuse(f671) is F671);
+ // In checked mode, verifies the type.
+ Function Function(Function x) Function<B extends core.int>(int x) l671;
+ // The static function f671 sets `T` to `int`.
+ if (!tIsBool) {
+ x671 = f671 as dynamic;
+ l671 = f671 as dynamic;
+ x671 = confuse(f671);
+ l671 = confuse(f671);
+ }
+
+ Expect.isTrue(m671 is F671);
+ Expect.isTrue(m671 is Function Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m671) is F671);
+ // In checked mode, verifies the type.
+ x671 = m671;
+ l671 = m671;
+ x671 = confuse(m671);
+ l671 = confuse(m671);
+
+ }
+
+ void testF771() {
+ // Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f771 is F771);
+ Expect.isTrue(confuse(f771) is F771);
+ // In checked mode, verifies the type.
+ Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l771;
+ // The static function f771 sets `T` to `int`.
+ if (!tIsBool) {
+ x771 = f771 as dynamic;
+ l771 = f771 as dynamic;
+ x771 = confuse(f771);
+ l771 = confuse(f771);
+ }
+
+ Expect.isTrue(m771 is F771);
+ Expect.isTrue(m771 is Function Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m771) is F771);
+ // In checked mode, verifies the type.
+ x771 = m771;
+ l771 = m771;
+ x771 = confuse(m771);
+ l771 = confuse(m771);
+
+ }
+
+ void testF871() {
+ // List<Function> Function([int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f871 is F871);
+ Expect.isTrue(confuse(f871) is F871);
+ // In checked mode, verifies the type.
+ List<Function> Function([int x1]) Function<B extends core.int>(int x) l871;
+ // The static function f871 sets `T` to `int`.
+ if (!tIsBool) {
+ x871 = f871 as dynamic;
+ l871 = f871 as dynamic;
+ x871 = confuse(f871);
+ l871 = confuse(f871);
+ }
+
+ Expect.isTrue(m871 is F871);
+ Expect.isTrue(m871 is List<Function> Function([int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m871) is F871);
+ // In checked mode, verifies the type.
+ x871 = m871;
+ l871 = m871;
+ x871 = confuse(m871);
+ l871 = confuse(m871);
+
+ }
+
+ void testF971() {
+ // List<Function> Function({List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f971 is F971);
+ Expect.isTrue(confuse(f971) is F971);
+ // In checked mode, verifies the type.
+ List<Function> Function({List<Function> x}) Function<B extends core.int>(int x) l971;
+ // The static function f971 sets `T` to `int`.
+ if (!tIsBool) {
+ x971 = f971 as dynamic;
+ l971 = f971 as dynamic;
+ x971 = confuse(f971);
+ l971 = confuse(f971);
+ }
+
+ Expect.isTrue(m971 is F971);
+ Expect.isTrue(m971 is List<Function> Function({List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m971) is F971);
+ // In checked mode, verifies the type.
+ x971 = m971;
+ l971 = m971;
+ x971 = confuse(m971);
+ l971 = confuse(m971);
+
+ }
+
+ void testF1071() {
+ // List<Function> Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f1071 is F1071);
+ Expect.isTrue(confuse(f1071) is F1071);
+ // In checked mode, verifies the type.
+ List<Function> Function() Function<B extends core.int>(int x) l1071;
+ // The static function f1071 sets `T` to `int`.
+ if (!tIsBool) {
+ x1071 = f1071 as dynamic;
+ l1071 = f1071 as dynamic;
+ x1071 = confuse(f1071);
+ l1071 = confuse(f1071);
+ }
+
+ Expect.isTrue(m1071 is F1071);
+ Expect.isTrue(m1071 is List<Function> Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1071) is F1071);
+ // In checked mode, verifies the type.
+ x1071 = m1071;
+ l1071 = m1071;
+ x1071 = confuse(m1071);
+ l1071 = confuse(m1071);
+
+ }
+
+ void testF1171() {
+ // core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1171 is F1171);
+ Expect.isTrue(confuse(f1171) is F1171);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l1171;
+ // The static function f1171 sets `T` to `int`.
+ if (!tIsBool) {
+ x1171 = f1171 as dynamic;
+ l1171 = f1171 as dynamic;
+ x1171 = confuse(f1171);
+ l1171 = confuse(f1171);
+ }
+
+ Expect.isTrue(m1171 is F1171);
+ Expect.isTrue(m1171 is core.List<core.int> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1171) is F1171);
+ // In checked mode, verifies the type.
+ x1171 = m1171;
+ l1171 = m1171;
+ x1171 = confuse(m1171);
+ l1171 = confuse(m1171);
+
+ }
+
+ void testF1271() {
+ // core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1271 is F1271);
+ Expect.isTrue(confuse(f1271) is F1271);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x) l1271;
+ // The static function f1271 sets `T` to `int`.
+ if (!tIsBool) {
+ x1271 = f1271 as dynamic;
+ l1271 = f1271 as dynamic;
+ x1271 = confuse(f1271);
+ l1271 = confuse(f1271);
+ }
+
+ Expect.isTrue(m1271 is F1271);
+ Expect.isTrue(m1271 is core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1271) is F1271);
+ // In checked mode, verifies the type.
+ x1271 = m1271;
+ l1271 = m1271;
+ x1271 = confuse(m1271);
+ l1271 = confuse(m1271);
+ if (!tIsBool) {
+ Expect.isTrue(f1271 is F1271<int>);
+ Expect.isFalse(f1271 is F1271<bool>);
+ Expect.isTrue(confuse(f1271) is F1271<int>);
+ Expect.isFalse(confuse(f1271) is F1271<bool>);
+ Expect.equals(tIsDynamic, m1271 is F1271<bool>);
+ Expect.equals(tIsDynamic, confuse(m1271) is F1271<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1271 = (f1271 as dynamic); });
+ Expect.throws(() { x1271 = confuse(f1271); });
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x) l1271;
+ Expect.throws(() { l1271 = (f1271 as dynamic); });
+ Expect.throws(() { l1271 = confuse(f1271); });
+ }
+ core.List<core.int> Function([List<T> x1]) Function<B extends core.int>(int x) l1271 = m1271;
+ // In checked mode, verifies the type.
+ x1271 = m1271;
+ x1271 = confuse(m1271);
+ }
+ }
+
+ void testF1371() {
+ // List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1371 is F1371);
+ Expect.isTrue(confuse(f1371) is F1371);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x) l1371;
+ // The static function f1371 sets `T` to `int`.
+ if (!tIsBool) {
+ x1371 = f1371 as dynamic;
+ l1371 = f1371 as dynamic;
+ x1371 = confuse(f1371);
+ l1371 = confuse(f1371);
+ }
+
+ Expect.isTrue(m1371 is F1371);
+ Expect.isTrue(m1371 is List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1371) is F1371);
+ // In checked mode, verifies the type.
+ x1371 = m1371;
+ l1371 = m1371;
+ x1371 = confuse(m1371);
+ l1371 = confuse(m1371);
+ if (!tIsBool) {
+ Expect.isTrue(f1371 is F1371<int>);
+ Expect.isFalse(f1371 is F1371<bool>);
+ Expect.isTrue(confuse(f1371) is F1371<int>);
+ Expect.isFalse(confuse(f1371) is F1371<bool>);
+ Expect.equals(tIsDynamic, m1371 is F1371<bool>);
+ Expect.equals(tIsDynamic, confuse(m1371) is F1371<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1371 = (f1371 as dynamic); });
+ Expect.throws(() { x1371 = confuse(f1371); });
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x) l1371;
+ Expect.throws(() { l1371 = (f1371 as dynamic); });
+ Expect.throws(() { l1371 = confuse(f1371); });
+ }
+ List<T> Function(int x, [Function x1]) Function<B extends core.int>(int x) l1371 = m1371;
+ // In checked mode, verifies the type.
+ x1371 = m1371;
+ x1371 = confuse(m1371);
+ }
+ }
+
+ void testF1471() {
+ // List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1471 is F1471);
+ Expect.isTrue(confuse(f1471) is F1471);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l1471;
+ // The static function f1471 sets `T` to `int`.
+ if (!tIsBool) {
+ x1471 = f1471 as dynamic;
+ l1471 = f1471 as dynamic;
+ x1471 = confuse(f1471);
+ l1471 = confuse(f1471);
+ }
+
+ Expect.isTrue(m1471 is F1471);
+ Expect.isTrue(m1471 is List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1471) is F1471);
+ // In checked mode, verifies the type.
+ x1471 = m1471;
+ l1471 = m1471;
+ x1471 = confuse(m1471);
+ l1471 = confuse(m1471);
+ if (!tIsBool) {
+ Expect.isTrue(f1471 is F1471<int>);
+ Expect.isFalse(f1471 is F1471<bool>);
+ Expect.isTrue(confuse(f1471) is F1471<int>);
+ Expect.isFalse(confuse(f1471) is F1471<bool>);
+ Expect.equals(tIsDynamic, m1471 is F1471<bool>);
+ Expect.equals(tIsDynamic, confuse(m1471) is F1471<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1471 = (f1471 as dynamic); });
+ Expect.throws(() { x1471 = confuse(f1471); });
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l1471;
+ Expect.throws(() { l1471 = (f1471 as dynamic); });
+ Expect.throws(() { l1471 = confuse(f1471); });
+ }
+ List<T> Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l1471 = m1471;
+ // In checked mode, verifies the type.
+ x1471 = m1471;
+ x1471 = confuse(m1471);
+ }
+ }
+
+ void testF1571() {
+ // Function([Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1571 is F1571);
+ Expect.isTrue(confuse(f1571) is F1571);
+ // In checked mode, verifies the type.
+ Function([Function x]) Function<B extends core.int>(int x) l1571;
+ // The static function f1571 sets `T` to `int`.
+ if (!tIsBool) {
+ x1571 = f1571 as dynamic;
+ l1571 = f1571 as dynamic;
+ x1571 = confuse(f1571);
+ l1571 = confuse(f1571);
+ }
+
+ Expect.isTrue(m1571 is F1571);
+ Expect.isTrue(m1571 is Function([Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1571) is F1571);
+ // In checked mode, verifies the type.
+ x1571 = m1571;
+ l1571 = m1571;
+ x1571 = confuse(m1571);
+ l1571 = confuse(m1571);
+
+ }
+
+ void testF1671() {
+ // Function(core.List<core.int> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1671 is F1671);
+ Expect.isTrue(confuse(f1671) is F1671);
+ // In checked mode, verifies the type.
+ Function(core.List<core.int> x1) Function<B extends core.int>(int x) l1671;
+ // The static function f1671 sets `T` to `int`.
+ if (!tIsBool) {
+ x1671 = f1671 as dynamic;
+ l1671 = f1671 as dynamic;
+ x1671 = confuse(f1671);
+ l1671 = confuse(f1671);
+ }
+
+ Expect.isTrue(m1671 is F1671);
+ Expect.isTrue(m1671 is Function(core.List<core.int> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1671) is F1671);
+ // In checked mode, verifies the type.
+ x1671 = m1671;
+ l1671 = m1671;
+ x1671 = confuse(m1671);
+ l1671 = confuse(m1671);
+
+ }
+
+ void testF1771() {
+ // int Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1771 is F1771);
+ Expect.isTrue(confuse(f1771) is F1771);
+ // In checked mode, verifies the type.
+ int Function<A>(A x) Function<B extends core.int>(int x) l1771;
+ // The static function f1771 sets `T` to `int`.
+ if (!tIsBool) {
+ x1771 = f1771 as dynamic;
+ l1771 = f1771 as dynamic;
+ x1771 = confuse(f1771);
+ l1771 = confuse(f1771);
+ }
+
+ Expect.isTrue(m1771 is F1771);
+ Expect.isTrue(m1771 is int Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1771) is F1771);
+ // In checked mode, verifies the type.
+ x1771 = m1771;
+ l1771 = m1771;
+ x1771 = confuse(m1771);
+ l1771 = confuse(m1771);
+
+ }
+
+ void testF1871() {
+ // core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1871 is F1871);
+ Expect.isTrue(confuse(f1871) is F1871);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>(int x) l1871;
+ // The static function f1871 sets `T` to `int`.
+ if (!tIsBool) {
+ x1871 = f1871 as dynamic;
+ l1871 = f1871 as dynamic;
+ x1871 = confuse(f1871);
+ l1871 = confuse(f1871);
+ }
+
+ Expect.isTrue(m1871 is F1871);
+ Expect.isTrue(m1871 is core.List<core.int> Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1871) is F1871);
+ // In checked mode, verifies the type.
+ x1871 = m1871;
+ l1871 = m1871;
+ x1871 = confuse(m1871);
+ l1871 = confuse(m1871);
+
+ }
+
+ void testF1971() {
+ // List<A> Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1971 is F1971);
+ Expect.isTrue(confuse(f1971) is F1971);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(int x) Function<B extends core.int>(int x) l1971;
+ // The static function f1971 sets `T` to `int`.
+ if (!tIsBool) {
+ x1971 = f1971 as dynamic;
+ l1971 = f1971 as dynamic;
+ x1971 = confuse(f1971);
+ l1971 = confuse(f1971);
+ }
+
+ Expect.isTrue(m1971 is F1971);
+ Expect.isTrue(m1971 is List<A> Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1971) is F1971);
+ // In checked mode, verifies the type.
+ x1971 = m1971;
+ l1971 = m1971;
+ x1971 = confuse(m1971);
+ l1971 = confuse(m1971);
+
+ }
+
+
+}
+
+class C72<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([Function x1]) x72;
+ core.List<core.int> Function(int x0) x172;
+ List<T> Function(List<T> x0) x272;
+ List<T> Function<A>(List<T> x) x372;
+ int Function(int x, [Function x2]) Function() x472;
+ int Function(int y, {core.List<core.int> x}) Function() x572;
+ Function Function([Function x]) Function() x672;
+ Function Function(core.List<core.int> x0) Function() x772;
+ List<Function> Function(int x1, [int x2]) Function() x872;
+ List<Function> Function(int x0, {List<Function> x}) Function() x972;
+ core.List<core.int> Function(int x) Function() x1072;
+ core.List<core.int> Function(int y, [List<Function> x]) Function() x1172;
+ core.List<core.int> Function(int x1, [List<T> x2]) Function() x1272;
+ List<T> Function({Function x}) Function() x1372;
+ List<T> Function(List<T> x) Function() x1472;
+ Function(int x0, [Function x]) Function() x1572;
+ Function([core.List<core.int> x1]) Function() x1672;
+ int Function<A>(List<A> x) Function() x1772;
+ List<T> Function<A>(int x) Function() x1872;
+ List<A> Function<A>(Function x) Function() x1972;
+
+
+ C72({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m72([Function x0]) => null;
+ core.List<core.int> m172(int x0) => null;
+ List<T> m272(List<T> x0) => null;
+ List<T> m372<A>(List<T> x) => null;
+ int Function(int x, [Function x0]) m472() => null;
+ int Function(int y, {core.List<core.int> x}) m572() => null;
+ Function Function([Function x]) m672() => null;
+ Function Function(core.List<core.int> x0) m772() => null;
+ List<Function> Function(int x0, [int x1]) m872() => null;
+ List<Function> Function(int x0, {List<Function> x}) m972() => null;
+ core.List<core.int> Function(int x) m1072() => null;
+ core.List<core.int> Function(int y, [List<Function> x]) m1172() => null;
+ core.List<core.int> Function(int x0, [List<T> x1]) m1272() => null;
+ List<T> Function({Function x}) m1372() => null;
+ List<T> Function(List<T> x) m1472() => null;
+ Function(int x0, [Function x]) m1572() => null;
+ Function([core.List<core.int> x0]) m1672() => null;
+ int Function<A>(List<A> x) m1772() => null;
+ List<T> Function<A>(int x) m1872() => null;
+ List<A> Function<A>(Function x) m1972() => null;
+
+
+ runTests() {
+ testF72();
+ testF172();
+ testF272();
+ testF372();
+ testF472();
+ testF572();
+ testF672();
+ testF772();
+ testF872();
+ testF972();
+ testF1072();
+ testF1172();
+ testF1272();
+ testF1372();
+ testF1472();
+ testF1572();
+ testF1672();
+ testF1772();
+ testF1872();
+ testF1972();
+ }
+
+ void testF72() {
+ // Function Function([Function x1])
+ Expect.isTrue(f72 is F72);
+ Expect.isTrue(confuse(f72) is F72);
+ // In checked mode, verifies the type.
+ Function Function([Function x1]) l72;
+ // The static function f72 sets `T` to `int`.
+ if (!tIsBool) {
+ x72 = f72 as dynamic;
+ l72 = f72 as dynamic;
+ x72 = confuse(f72);
+ l72 = confuse(f72);
+ }
+
+ Expect.isTrue(m72 is F72);
+ Expect.isTrue(m72 is Function Function([Function x1]));
+ Expect.isTrue(confuse(m72) is F72);
+ // In checked mode, verifies the type.
+ x72 = m72;
+ l72 = m72;
+ x72 = confuse(m72);
+ l72 = confuse(m72);
+
+ }
+
+ void testF172() {
+ // core.List<core.int> Function(int x0)
+ Expect.isTrue(f172 is F172);
+ Expect.isTrue(confuse(f172) is F172);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0) l172;
+ // The static function f172 sets `T` to `int`.
+ if (!tIsBool) {
+ x172 = f172 as dynamic;
+ l172 = f172 as dynamic;
+ x172 = confuse(f172);
+ l172 = confuse(f172);
+ }
+
+ Expect.isTrue(m172 is F172);
+ Expect.isTrue(m172 is core.List<core.int> Function(int x0));
+ Expect.isTrue(confuse(m172) is F172);
+ // In checked mode, verifies the type.
+ x172 = m172;
+ l172 = m172;
+ x172 = confuse(m172);
+ l172 = confuse(m172);
+
+ }
+
+ void testF272() {
+ // List<T> Function(List<T> x0)
+ Expect.isTrue(f272 is F272);
+ Expect.isTrue(confuse(f272) is F272);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x0) l272;
+ // The static function f272 sets `T` to `int`.
+ if (!tIsBool) {
+ x272 = f272 as dynamic;
+ l272 = f272 as dynamic;
+ x272 = confuse(f272);
+ l272 = confuse(f272);
+ }
+
+ Expect.isTrue(m272 is F272);
+ Expect.isTrue(m272 is List<T> Function(List<T> x0));
+ Expect.isTrue(confuse(m272) is F272);
+ // In checked mode, verifies the type.
+ x272 = m272;
+ l272 = m272;
+ x272 = confuse(m272);
+ l272 = confuse(m272);
+ if (!tIsBool) {
+ Expect.isTrue(f272 is F272<int>);
+ Expect.isFalse(f272 is F272<bool>);
+ Expect.isTrue(confuse(f272) is F272<int>);
+ Expect.isFalse(confuse(f272) is F272<bool>);
+ Expect.equals(tIsDynamic, m272 is F272<bool>);
+ Expect.equals(tIsDynamic, confuse(m272) is F272<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x272 = (f272 as dynamic); });
+ Expect.throws(() { x272 = confuse(f272); });
+ List<T> Function(List<T> x0) l272;
+ Expect.throws(() { l272 = (f272 as dynamic); });
+ Expect.throws(() { l272 = confuse(f272); });
+ }
+ List<T> Function(List<T> x0) l272 = m272;
+ // In checked mode, verifies the type.
+ x272 = m272;
+ x272 = confuse(m272);
+ }
+ }
+
+ void testF372() {
+ // List<T> Function<A>(List<T> x)
+ Expect.isTrue(f372 is F372);
+ Expect.isTrue(confuse(f372) is F372);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<T> x) l372;
+ // The static function f372 sets `T` to `int`.
+ if (!tIsBool) {
+ x372 = f372 as dynamic;
+ l372 = f372 as dynamic;
+ x372 = confuse(f372);
+ l372 = confuse(f372);
+ }
+
+ Expect.isTrue(m372 is F372);
+ Expect.isTrue(m372 is List<T> Function<A>(List<T> x));
+ Expect.isTrue(confuse(m372) is F372);
+ // In checked mode, verifies the type.
+ x372 = m372;
+ l372 = m372;
+ x372 = confuse(m372);
+ l372 = confuse(m372);
+ if (!tIsBool) {
+ Expect.isTrue(f372 is F372<int>);
+ Expect.isFalse(f372 is F372<bool>);
+ Expect.isTrue(confuse(f372) is F372<int>);
+ Expect.isFalse(confuse(f372) is F372<bool>);
+ Expect.equals(tIsDynamic, m372 is F372<bool>);
+ Expect.equals(tIsDynamic, confuse(m372) is F372<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x372 = (f372 as dynamic); });
+ Expect.throws(() { x372 = confuse(f372); });
+ List<T> Function<A>(List<T> x) l372;
+ Expect.throws(() { l372 = (f372 as dynamic); });
+ Expect.throws(() { l372 = confuse(f372); });
+ }
+ List<T> Function<A>(List<T> x) l372 = m372;
+ // In checked mode, verifies the type.
+ x372 = m372;
+ x372 = confuse(m372);
+ }
+ }
+
+ void testF472() {
+ // int Function(int x, [Function x2]) Function()
+ Expect.isTrue(f472 is F472);
+ Expect.isTrue(confuse(f472) is F472);
+ // In checked mode, verifies the type.
+ int Function(int x, [Function x2]) Function() l472;
+ // The static function f472 sets `T` to `int`.
+ if (!tIsBool) {
+ x472 = f472 as dynamic;
+ l472 = f472 as dynamic;
+ x472 = confuse(f472);
+ l472 = confuse(f472);
+ }
+
+ Expect.isTrue(m472 is F472);
+ Expect.isTrue(m472 is int Function(int x, [Function x2]) Function());
+ Expect.isTrue(confuse(m472) is F472);
+ // In checked mode, verifies the type.
+ x472 = m472;
+ l472 = m472;
+ x472 = confuse(m472);
+ l472 = confuse(m472);
+
+ }
+
+ void testF572() {
+ // int Function(int y, {core.List<core.int> x}) Function()
+ Expect.isTrue(f572 is F572);
+ Expect.isTrue(confuse(f572) is F572);
+ // In checked mode, verifies the type.
+ int Function(int y, {core.List<core.int> x}) Function() l572;
+ // The static function f572 sets `T` to `int`.
+ if (!tIsBool) {
+ x572 = f572 as dynamic;
+ l572 = f572 as dynamic;
+ x572 = confuse(f572);
+ l572 = confuse(f572);
+ }
+
+ Expect.isTrue(m572 is F572);
+ Expect.isTrue(m572 is int Function(int y, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m572) is F572);
+ // In checked mode, verifies the type.
+ x572 = m572;
+ l572 = m572;
+ x572 = confuse(m572);
+ l572 = confuse(m572);
+
+ }
+
+ void testF672() {
+ // Function Function([Function x]) Function()
+ Expect.isTrue(f672 is F672);
+ Expect.isTrue(confuse(f672) is F672);
+ // In checked mode, verifies the type.
+ Function Function([Function x]) Function() l672;
+ // The static function f672 sets `T` to `int`.
+ if (!tIsBool) {
+ x672 = f672 as dynamic;
+ l672 = f672 as dynamic;
+ x672 = confuse(f672);
+ l672 = confuse(f672);
+ }
+
+ Expect.isTrue(m672 is F672);
+ Expect.isTrue(m672 is Function Function([Function x]) Function());
+ Expect.isTrue(confuse(m672) is F672);
+ // In checked mode, verifies the type.
+ x672 = m672;
+ l672 = m672;
+ x672 = confuse(m672);
+ l672 = confuse(m672);
+
+ }
+
+ void testF772() {
+ // Function Function(core.List<core.int> x0) Function()
+ Expect.isTrue(f772 is F772);
+ Expect.isTrue(confuse(f772) is F772);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x0) Function() l772;
+ // The static function f772 sets `T` to `int`.
+ if (!tIsBool) {
+ x772 = f772 as dynamic;
+ l772 = f772 as dynamic;
+ x772 = confuse(f772);
+ l772 = confuse(f772);
+ }
+
+ Expect.isTrue(m772 is F772);
+ Expect.isTrue(m772 is Function Function(core.List<core.int> x0) Function());
+ Expect.isTrue(confuse(m772) is F772);
+ // In checked mode, verifies the type.
+ x772 = m772;
+ l772 = m772;
+ x772 = confuse(m772);
+ l772 = confuse(m772);
+
+ }
+
+ void testF872() {
+ // List<Function> Function(int x1, [int x2]) Function()
+ Expect.isTrue(f872 is F872);
+ Expect.isTrue(confuse(f872) is F872);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [int x2]) Function() l872;
+ // The static function f872 sets `T` to `int`.
+ if (!tIsBool) {
+ x872 = f872 as dynamic;
+ l872 = f872 as dynamic;
+ x872 = confuse(f872);
+ l872 = confuse(f872);
+ }
+
+ Expect.isTrue(m872 is F872);
+ Expect.isTrue(m872 is List<Function> Function(int x1, [int x2]) Function());
+ Expect.isTrue(confuse(m872) is F872);
+ // In checked mode, verifies the type.
+ x872 = m872;
+ l872 = m872;
+ x872 = confuse(m872);
+ l872 = confuse(m872);
+
+ }
+
+ void testF972() {
+ // List<Function> Function(int x0, {List<Function> x}) Function()
+ Expect.isTrue(f972 is F972);
+ Expect.isTrue(confuse(f972) is F972);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {List<Function> x}) Function() l972;
+ // The static function f972 sets `T` to `int`.
+ if (!tIsBool) {
+ x972 = f972 as dynamic;
+ l972 = f972 as dynamic;
+ x972 = confuse(f972);
+ l972 = confuse(f972);
+ }
+
+ Expect.isTrue(m972 is F972);
+ Expect.isTrue(m972 is List<Function> Function(int x0, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m972) is F972);
+ // In checked mode, verifies the type.
+ x972 = m972;
+ l972 = m972;
+ x972 = confuse(m972);
+ l972 = confuse(m972);
+
+ }
+
+ void testF1072() {
+ // core.List<core.int> Function(int x) Function()
+ Expect.isTrue(f1072 is F1072);
+ Expect.isTrue(confuse(f1072) is F1072);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x) Function() l1072;
+ // The static function f1072 sets `T` to `int`.
+ if (!tIsBool) {
+ x1072 = f1072 as dynamic;
+ l1072 = f1072 as dynamic;
+ x1072 = confuse(f1072);
+ l1072 = confuse(f1072);
+ }
+
+ Expect.isTrue(m1072 is F1072);
+ Expect.isTrue(m1072 is core.List<core.int> Function(int x) Function());
+ Expect.isTrue(confuse(m1072) is F1072);
+ // In checked mode, verifies the type.
+ x1072 = m1072;
+ l1072 = m1072;
+ x1072 = confuse(m1072);
+ l1072 = confuse(m1072);
+
+ }
+
+ void testF1172() {
+ // core.List<core.int> Function(int y, [List<Function> x]) Function()
+ Expect.isTrue(f1172 is F1172);
+ Expect.isTrue(confuse(f1172) is F1172);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<Function> x]) Function() l1172;
+ // The static function f1172 sets `T` to `int`.
+ if (!tIsBool) {
+ x1172 = f1172 as dynamic;
+ l1172 = f1172 as dynamic;
+ x1172 = confuse(f1172);
+ l1172 = confuse(f1172);
+ }
+
+ Expect.isTrue(m1172 is F1172);
+ Expect.isTrue(m1172 is core.List<core.int> Function(int y, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m1172) is F1172);
+ // In checked mode, verifies the type.
+ x1172 = m1172;
+ l1172 = m1172;
+ x1172 = confuse(m1172);
+ l1172 = confuse(m1172);
+
+ }
+
+ void testF1272() {
+ // core.List<core.int> Function(int x1, [List<T> x2]) Function()
+ Expect.isTrue(f1272 is F1272);
+ Expect.isTrue(confuse(f1272) is F1272);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<T> x2]) Function() l1272;
+ // The static function f1272 sets `T` to `int`.
+ if (!tIsBool) {
+ x1272 = f1272 as dynamic;
+ l1272 = f1272 as dynamic;
+ x1272 = confuse(f1272);
+ l1272 = confuse(f1272);
+ }
+
+ Expect.isTrue(m1272 is F1272);
+ Expect.isTrue(m1272 is core.List<core.int> Function(int x1, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1272) is F1272);
+ // In checked mode, verifies the type.
+ x1272 = m1272;
+ l1272 = m1272;
+ x1272 = confuse(m1272);
+ l1272 = confuse(m1272);
+ if (!tIsBool) {
+ Expect.isTrue(f1272 is F1272<int>);
+ Expect.isFalse(f1272 is F1272<bool>);
+ Expect.isTrue(confuse(f1272) is F1272<int>);
+ Expect.isFalse(confuse(f1272) is F1272<bool>);
+ Expect.equals(tIsDynamic, m1272 is F1272<bool>);
+ Expect.equals(tIsDynamic, confuse(m1272) is F1272<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1272 = (f1272 as dynamic); });
+ Expect.throws(() { x1272 = confuse(f1272); });
+ core.List<core.int> Function(int x1, [List<T> x2]) Function() l1272;
+ Expect.throws(() { l1272 = (f1272 as dynamic); });
+ Expect.throws(() { l1272 = confuse(f1272); });
+ }
+ core.List<core.int> Function(int x1, [List<T> x2]) Function() l1272 = m1272;
+ // In checked mode, verifies the type.
+ x1272 = m1272;
+ x1272 = confuse(m1272);
+ }
+ }
+
+ void testF1372() {
+ // List<T> Function({Function x}) Function()
+ Expect.isTrue(f1372 is F1372);
+ Expect.isTrue(confuse(f1372) is F1372);
+ // In checked mode, verifies the type.
+ List<T> Function({Function x}) Function() l1372;
+ // The static function f1372 sets `T` to `int`.
+ if (!tIsBool) {
+ x1372 = f1372 as dynamic;
+ l1372 = f1372 as dynamic;
+ x1372 = confuse(f1372);
+ l1372 = confuse(f1372);
+ }
+
+ Expect.isTrue(m1372 is F1372);
+ Expect.isTrue(m1372 is List<T> Function({Function x}) Function());
+ Expect.isTrue(confuse(m1372) is F1372);
+ // In checked mode, verifies the type.
+ x1372 = m1372;
+ l1372 = m1372;
+ x1372 = confuse(m1372);
+ l1372 = confuse(m1372);
+ if (!tIsBool) {
+ Expect.isTrue(f1372 is F1372<int>);
+ Expect.isFalse(f1372 is F1372<bool>);
+ Expect.isTrue(confuse(f1372) is F1372<int>);
+ Expect.isFalse(confuse(f1372) is F1372<bool>);
+ Expect.equals(tIsDynamic, m1372 is F1372<bool>);
+ Expect.equals(tIsDynamic, confuse(m1372) is F1372<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1372 = (f1372 as dynamic); });
+ Expect.throws(() { x1372 = confuse(f1372); });
+ List<T> Function({Function x}) Function() l1372;
+ Expect.throws(() { l1372 = (f1372 as dynamic); });
+ Expect.throws(() { l1372 = confuse(f1372); });
+ }
+ List<T> Function({Function x}) Function() l1372 = m1372;
+ // In checked mode, verifies the type.
+ x1372 = m1372;
+ x1372 = confuse(m1372);
+ }
+ }
+
+ void testF1472() {
+ // List<T> Function(List<T> x) Function()
+ Expect.isTrue(f1472 is F1472);
+ Expect.isTrue(confuse(f1472) is F1472);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x) Function() l1472;
+ // The static function f1472 sets `T` to `int`.
+ if (!tIsBool) {
+ x1472 = f1472 as dynamic;
+ l1472 = f1472 as dynamic;
+ x1472 = confuse(f1472);
+ l1472 = confuse(f1472);
+ }
+
+ Expect.isTrue(m1472 is F1472);
+ Expect.isTrue(m1472 is List<T> Function(List<T> x) Function());
+ Expect.isTrue(confuse(m1472) is F1472);
+ // In checked mode, verifies the type.
+ x1472 = m1472;
+ l1472 = m1472;
+ x1472 = confuse(m1472);
+ l1472 = confuse(m1472);
+ if (!tIsBool) {
+ Expect.isTrue(f1472 is F1472<int>);
+ Expect.isFalse(f1472 is F1472<bool>);
+ Expect.isTrue(confuse(f1472) is F1472<int>);
+ Expect.isFalse(confuse(f1472) is F1472<bool>);
+ Expect.equals(tIsDynamic, m1472 is F1472<bool>);
+ Expect.equals(tIsDynamic, confuse(m1472) is F1472<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1472 = (f1472 as dynamic); });
+ Expect.throws(() { x1472 = confuse(f1472); });
+ List<T> Function(List<T> x) Function() l1472;
+ Expect.throws(() { l1472 = (f1472 as dynamic); });
+ Expect.throws(() { l1472 = confuse(f1472); });
+ }
+ List<T> Function(List<T> x) Function() l1472 = m1472;
+ // In checked mode, verifies the type.
+ x1472 = m1472;
+ x1472 = confuse(m1472);
+ }
+ }
+
+ void testF1572() {
+ // Function(int x0, [Function x]) Function()
+ Expect.isTrue(f1572 is F1572);
+ Expect.isTrue(confuse(f1572) is F1572);
+ // In checked mode, verifies the type.
+ Function(int x0, [Function x]) Function() l1572;
+ // The static function f1572 sets `T` to `int`.
+ if (!tIsBool) {
+ x1572 = f1572 as dynamic;
+ l1572 = f1572 as dynamic;
+ x1572 = confuse(f1572);
+ l1572 = confuse(f1572);
+ }
+
+ Expect.isTrue(m1572 is F1572);
+ Expect.isTrue(m1572 is Function(int x0, [Function x]) Function());
+ Expect.isTrue(confuse(m1572) is F1572);
+ // In checked mode, verifies the type.
+ x1572 = m1572;
+ l1572 = m1572;
+ x1572 = confuse(m1572);
+ l1572 = confuse(m1572);
+
+ }
+
+ void testF1672() {
+ // Function([core.List<core.int> x1]) Function()
+ Expect.isTrue(f1672 is F1672);
+ Expect.isTrue(confuse(f1672) is F1672);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x1]) Function() l1672;
+ // The static function f1672 sets `T` to `int`.
+ if (!tIsBool) {
+ x1672 = f1672 as dynamic;
+ l1672 = f1672 as dynamic;
+ x1672 = confuse(f1672);
+ l1672 = confuse(f1672);
+ }
+
+ Expect.isTrue(m1672 is F1672);
+ Expect.isTrue(m1672 is Function([core.List<core.int> x1]) Function());
+ Expect.isTrue(confuse(m1672) is F1672);
+ // In checked mode, verifies the type.
+ x1672 = m1672;
+ l1672 = m1672;
+ x1672 = confuse(m1672);
+ l1672 = confuse(m1672);
+
+ }
+
+ void testF1772() {
+ // int Function<A>(List<A> x) Function()
+ Expect.isTrue(f1772 is F1772);
+ Expect.isTrue(confuse(f1772) is F1772);
+ // In checked mode, verifies the type.
+ int Function<A>(List<A> x) Function() l1772;
+ // The static function f1772 sets `T` to `int`.
+ if (!tIsBool) {
+ x1772 = f1772 as dynamic;
+ l1772 = f1772 as dynamic;
+ x1772 = confuse(f1772);
+ l1772 = confuse(f1772);
+ }
+
+ Expect.isTrue(m1772 is F1772);
+ Expect.isTrue(m1772 is int Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1772) is F1772);
+ // In checked mode, verifies the type.
+ x1772 = m1772;
+ l1772 = m1772;
+ x1772 = confuse(m1772);
+ l1772 = confuse(m1772);
+
+ }
+
+ void testF1872() {
+ // List<T> Function<A>(int x) Function()
+ Expect.isTrue(f1872 is F1872);
+ Expect.isTrue(confuse(f1872) is F1872);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(int x) Function() l1872;
+ // The static function f1872 sets `T` to `int`.
+ if (!tIsBool) {
+ x1872 = f1872 as dynamic;
+ l1872 = f1872 as dynamic;
+ x1872 = confuse(f1872);
+ l1872 = confuse(f1872);
+ }
+
+ Expect.isTrue(m1872 is F1872);
+ Expect.isTrue(m1872 is List<T> Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1872) is F1872);
+ // In checked mode, verifies the type.
+ x1872 = m1872;
+ l1872 = m1872;
+ x1872 = confuse(m1872);
+ l1872 = confuse(m1872);
+ if (!tIsBool) {
+ Expect.isTrue(f1872 is F1872<int>);
+ Expect.isFalse(f1872 is F1872<bool>);
+ Expect.isTrue(confuse(f1872) is F1872<int>);
+ Expect.isFalse(confuse(f1872) is F1872<bool>);
+ Expect.equals(tIsDynamic, m1872 is F1872<bool>);
+ Expect.equals(tIsDynamic, confuse(m1872) is F1872<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1872 = (f1872 as dynamic); });
+ Expect.throws(() { x1872 = confuse(f1872); });
+ List<T> Function<A>(int x) Function() l1872;
+ Expect.throws(() { l1872 = (f1872 as dynamic); });
+ Expect.throws(() { l1872 = confuse(f1872); });
+ }
+ List<T> Function<A>(int x) Function() l1872 = m1872;
+ // In checked mode, verifies the type.
+ x1872 = m1872;
+ x1872 = confuse(m1872);
+ }
+ }
+
+ void testF1972() {
+ // List<A> Function<A>(Function x) Function()
+ Expect.isTrue(f1972 is F1972);
+ Expect.isTrue(confuse(f1972) is F1972);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(Function x) Function() l1972;
+ // The static function f1972 sets `T` to `int`.
+ if (!tIsBool) {
+ x1972 = f1972 as dynamic;
+ l1972 = f1972 as dynamic;
+ x1972 = confuse(f1972);
+ l1972 = confuse(f1972);
+ }
+
+ Expect.isTrue(m1972 is F1972);
+ Expect.isTrue(m1972 is List<A> Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1972) is F1972);
+ // In checked mode, verifies the type.
+ x1972 = m1972;
+ l1972 = m1972;
+ x1972 = confuse(m1972);
+ l1972 = confuse(m1972);
+
+ }
+
+
+}
+
+class C73<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x1, [Function x2]) x73;
+ core.List<core.int> Function([int x1]) x173;
+ List<T> Function([List<T> x1]) x273;
+ List<T> Function<A>() x373;
+ int Function(int x, [Function x1]) Function(int x) x473;
+ int Function(int y, {core.List<core.int> x}) Function(int x) x573;
+ Function Function([Function x]) Function(int x) x673;
+ Function Function(core.List<core.int> x1) Function(int x) x773;
+ List<Function> Function(int x2, [int x3]) Function(int x) x873;
+ List<Function> Function(int x1, {List<Function> x}) Function(int x) x973;
+ core.List<core.int> Function(int x) Function(int x) x1073;
+ core.List<core.int> Function(int y, [List<Function> x]) Function(int x) x1173;
+ core.List<core.int> Function(int x2, [List<T> x3]) Function(int x) x1273;
+ List<T> Function({Function x}) Function(int x) x1373;
+ List<T> Function(List<T> x) Function(int x) x1473;
+ Function(int x1, [Function x]) Function(int x) x1573;
+ Function([core.List<core.int> x1]) Function(int x) x1673;
+ int Function<A>(List<A> x) Function(int x) x1773;
+ List<T> Function<A>(int x) Function(int x) x1873;
+ List<A> Function<A>(Function x) Function(int x) x1973;
+
+
+ C73({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m73(int x0, [Function x1]) => null;
+ core.List<core.int> m173([int x0]) => null;
+ List<T> m273([List<T> x0]) => null;
+ List<T> m373<A>() => null;
+ int Function(int x, [Function x0]) m473(int x) => null;
+ int Function(int y, {core.List<core.int> x}) m573(int x) => null;
+ Function Function([Function x]) m673(int x) => null;
+ Function Function(core.List<core.int> x0) m773(int x) => null;
+ List<Function> Function(int x0, [int x1]) m873(int x) => null;
+ List<Function> Function(int x0, {List<Function> x}) m973(int x) => null;
+ core.List<core.int> Function(int x) m1073(int x) => null;
+ core.List<core.int> Function(int y, [List<Function> x]) m1173(int x) => null;
+ core.List<core.int> Function(int x0, [List<T> x1]) m1273(int x) => null;
+ List<T> Function({Function x}) m1373(int x) => null;
+ List<T> Function(List<T> x) m1473(int x) => null;
+ Function(int x0, [Function x]) m1573(int x) => null;
+ Function([core.List<core.int> x0]) m1673(int x) => null;
+ int Function<A>(List<A> x) m1773(int x) => null;
+ List<T> Function<A>(int x) m1873(int x) => null;
+ List<A> Function<A>(Function x) m1973(int x) => null;
+
+
+ runTests() {
+ testF73();
+ testF173();
+ testF273();
+ testF373();
+ testF473();
+ testF573();
+ testF673();
+ testF773();
+ testF873();
+ testF973();
+ testF1073();
+ testF1173();
+ testF1273();
+ testF1373();
+ testF1473();
+ testF1573();
+ testF1673();
+ testF1773();
+ testF1873();
+ testF1973();
+ }
+
+ void testF73() {
+ // Function Function(int x1, [Function x2])
+ Expect.isTrue(f73 is F73);
+ Expect.isTrue(confuse(f73) is F73);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [Function x2]) l73;
+ // The static function f73 sets `T` to `int`.
+ if (!tIsBool) {
+ x73 = f73 as dynamic;
+ l73 = f73 as dynamic;
+ x73 = confuse(f73);
+ l73 = confuse(f73);
+ }
+
+ Expect.isTrue(m73 is F73);
+ Expect.isTrue(m73 is Function Function(int x1, [Function x2]));
+ Expect.isTrue(confuse(m73) is F73);
+ // In checked mode, verifies the type.
+ x73 = m73;
+ l73 = m73;
+ x73 = confuse(m73);
+ l73 = confuse(m73);
+
+ }
+
+ void testF173() {
+ // core.List<core.int> Function([int x1])
+ Expect.isTrue(f173 is F173);
+ Expect.isTrue(confuse(f173) is F173);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x1]) l173;
+ // The static function f173 sets `T` to `int`.
+ if (!tIsBool) {
+ x173 = f173 as dynamic;
+ l173 = f173 as dynamic;
+ x173 = confuse(f173);
+ l173 = confuse(f173);
+ }
+
+ Expect.isTrue(m173 is F173);
+ Expect.isTrue(m173 is core.List<core.int> Function([int x1]));
+ Expect.isTrue(confuse(m173) is F173);
+ // In checked mode, verifies the type.
+ x173 = m173;
+ l173 = m173;
+ x173 = confuse(m173);
+ l173 = confuse(m173);
+
+ }
+
+ void testF273() {
+ // List<T> Function([List<T> x1])
+ Expect.isTrue(f273 is F273);
+ Expect.isTrue(confuse(f273) is F273);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x1]) l273;
+ // The static function f273 sets `T` to `int`.
+ if (!tIsBool) {
+ x273 = f273 as dynamic;
+ l273 = f273 as dynamic;
+ x273 = confuse(f273);
+ l273 = confuse(f273);
+ }
+
+ Expect.isTrue(m273 is F273);
+ Expect.isTrue(m273 is List<T> Function([List<T> x1]));
+ Expect.isTrue(confuse(m273) is F273);
+ // In checked mode, verifies the type.
+ x273 = m273;
+ l273 = m273;
+ x273 = confuse(m273);
+ l273 = confuse(m273);
+ if (!tIsBool) {
+ Expect.isTrue(f273 is F273<int>);
+ Expect.isFalse(f273 is F273<bool>);
+ Expect.isTrue(confuse(f273) is F273<int>);
+ Expect.isFalse(confuse(f273) is F273<bool>);
+ Expect.equals(tIsDynamic, m273 is F273<bool>);
+ Expect.equals(tIsDynamic, confuse(m273) is F273<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x273 = (f273 as dynamic); });
+ Expect.throws(() { x273 = confuse(f273); });
+ List<T> Function([List<T> x1]) l273;
+ Expect.throws(() { l273 = (f273 as dynamic); });
+ Expect.throws(() { l273 = confuse(f273); });
+ }
+ List<T> Function([List<T> x1]) l273 = m273;
+ // In checked mode, verifies the type.
+ x273 = m273;
+ x273 = confuse(m273);
+ }
+ }
+
+ void testF373() {
+ // List<T> Function<A>()
+ Expect.isTrue(f373 is F373);
+ Expect.isTrue(confuse(f373) is F373);
+ // In checked mode, verifies the type.
+ List<T> Function<A>() l373;
+ // The static function f373 sets `T` to `int`.
+ if (!tIsBool) {
+ x373 = f373 as dynamic;
+ l373 = f373 as dynamic;
+ x373 = confuse(f373);
+ l373 = confuse(f373);
+ }
+
+ Expect.isTrue(m373 is F373);
+ Expect.isTrue(m373 is List<T> Function<A>());
+ Expect.isTrue(confuse(m373) is F373);
+ // In checked mode, verifies the type.
+ x373 = m373;
+ l373 = m373;
+ x373 = confuse(m373);
+ l373 = confuse(m373);
+ if (!tIsBool) {
+ Expect.isTrue(f373 is F373<int>);
+ Expect.isFalse(f373 is F373<bool>);
+ Expect.isTrue(confuse(f373) is F373<int>);
+ Expect.isFalse(confuse(f373) is F373<bool>);
+ Expect.equals(tIsDynamic, m373 is F373<bool>);
+ Expect.equals(tIsDynamic, confuse(m373) is F373<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x373 = (f373 as dynamic); });
+ Expect.throws(() { x373 = confuse(f373); });
+ List<T> Function<A>() l373;
+ Expect.throws(() { l373 = (f373 as dynamic); });
+ Expect.throws(() { l373 = confuse(f373); });
+ }
+ List<T> Function<A>() l373 = m373;
+ // In checked mode, verifies the type.
+ x373 = m373;
+ x373 = confuse(m373);
+ }
+ }
+
+ void testF473() {
+ // int Function(int x, [Function x1]) Function(int x)
+ Expect.isTrue(f473 is F473);
+ Expect.isTrue(confuse(f473) is F473);
+ // In checked mode, verifies the type.
+ int Function(int x, [Function x1]) Function(int x) l473;
+ // The static function f473 sets `T` to `int`.
+ if (!tIsBool) {
+ x473 = f473 as dynamic;
+ l473 = f473 as dynamic;
+ x473 = confuse(f473);
+ l473 = confuse(f473);
+ }
+
+ Expect.isTrue(m473 is F473);
+ Expect.isTrue(m473 is int Function(int x, [Function x1]) Function(int x));
+ Expect.isTrue(confuse(m473) is F473);
+ // In checked mode, verifies the type.
+ x473 = m473;
+ l473 = m473;
+ x473 = confuse(m473);
+ l473 = confuse(m473);
+
+ }
+
+ void testF573() {
+ // int Function(int y, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f573 is F573);
+ Expect.isTrue(confuse(f573) is F573);
+ // In checked mode, verifies the type.
+ int Function(int y, {core.List<core.int> x}) Function(int x) l573;
+ // The static function f573 sets `T` to `int`.
+ if (!tIsBool) {
+ x573 = f573 as dynamic;
+ l573 = f573 as dynamic;
+ x573 = confuse(f573);
+ l573 = confuse(f573);
+ }
+
+ Expect.isTrue(m573 is F573);
+ Expect.isTrue(m573 is int Function(int y, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m573) is F573);
+ // In checked mode, verifies the type.
+ x573 = m573;
+ l573 = m573;
+ x573 = confuse(m573);
+ l573 = confuse(m573);
+
+ }
+
+ void testF673() {
+ // Function Function([Function x]) Function(int x)
+ Expect.isTrue(f673 is F673);
+ Expect.isTrue(confuse(f673) is F673);
+ // In checked mode, verifies the type.
+ Function Function([Function x]) Function(int x) l673;
+ // The static function f673 sets `T` to `int`.
+ if (!tIsBool) {
+ x673 = f673 as dynamic;
+ l673 = f673 as dynamic;
+ x673 = confuse(f673);
+ l673 = confuse(f673);
+ }
+
+ Expect.isTrue(m673 is F673);
+ Expect.isTrue(m673 is Function Function([Function x]) Function(int x));
+ Expect.isTrue(confuse(m673) is F673);
+ // In checked mode, verifies the type.
+ x673 = m673;
+ l673 = m673;
+ x673 = confuse(m673);
+ l673 = confuse(m673);
+
+ }
+
+ void testF773() {
+ // Function Function(core.List<core.int> x1) Function(int x)
+ Expect.isTrue(f773 is F773);
+ Expect.isTrue(confuse(f773) is F773);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x1) Function(int x) l773;
+ // The static function f773 sets `T` to `int`.
+ if (!tIsBool) {
+ x773 = f773 as dynamic;
+ l773 = f773 as dynamic;
+ x773 = confuse(f773);
+ l773 = confuse(f773);
+ }
+
+ Expect.isTrue(m773 is F773);
+ Expect.isTrue(m773 is Function Function(core.List<core.int> x1) Function(int x));
+ Expect.isTrue(confuse(m773) is F773);
+ // In checked mode, verifies the type.
+ x773 = m773;
+ l773 = m773;
+ x773 = confuse(m773);
+ l773 = confuse(m773);
+
+ }
+
+ void testF873() {
+ // List<Function> Function(int x2, [int x3]) Function(int x)
+ Expect.isTrue(f873 is F873);
+ Expect.isTrue(confuse(f873) is F873);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [int x3]) Function(int x) l873;
+ // The static function f873 sets `T` to `int`.
+ if (!tIsBool) {
+ x873 = f873 as dynamic;
+ l873 = f873 as dynamic;
+ x873 = confuse(f873);
+ l873 = confuse(f873);
+ }
+
+ Expect.isTrue(m873 is F873);
+ Expect.isTrue(m873 is List<Function> Function(int x2, [int x3]) Function(int x));
+ Expect.isTrue(confuse(m873) is F873);
+ // In checked mode, verifies the type.
+ x873 = m873;
+ l873 = m873;
+ x873 = confuse(m873);
+ l873 = confuse(m873);
+
+ }
+
+ void testF973() {
+ // List<Function> Function(int x1, {List<Function> x}) Function(int x)
+ Expect.isTrue(f973 is F973);
+ Expect.isTrue(confuse(f973) is F973);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {List<Function> x}) Function(int x) l973;
+ // The static function f973 sets `T` to `int`.
+ if (!tIsBool) {
+ x973 = f973 as dynamic;
+ l973 = f973 as dynamic;
+ x973 = confuse(f973);
+ l973 = confuse(f973);
+ }
+
+ Expect.isTrue(m973 is F973);
+ Expect.isTrue(m973 is List<Function> Function(int x1, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m973) is F973);
+ // In checked mode, verifies the type.
+ x973 = m973;
+ l973 = m973;
+ x973 = confuse(m973);
+ l973 = confuse(m973);
+
+ }
+
+ void testF1073() {
+ // core.List<core.int> Function(int x) Function(int x)
+ Expect.isTrue(f1073 is F1073);
+ Expect.isTrue(confuse(f1073) is F1073);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x) Function(int x) l1073;
+ // The static function f1073 sets `T` to `int`.
+ if (!tIsBool) {
+ x1073 = f1073 as dynamic;
+ l1073 = f1073 as dynamic;
+ x1073 = confuse(f1073);
+ l1073 = confuse(f1073);
+ }
+
+ Expect.isTrue(m1073 is F1073);
+ Expect.isTrue(m1073 is core.List<core.int> Function(int x) Function(int x));
+ Expect.isTrue(confuse(m1073) is F1073);
+ // In checked mode, verifies the type.
+ x1073 = m1073;
+ l1073 = m1073;
+ x1073 = confuse(m1073);
+ l1073 = confuse(m1073);
+
+ }
+
+ void testF1173() {
+ // core.List<core.int> Function(int y, [List<Function> x]) Function(int x)
+ Expect.isTrue(f1173 is F1173);
+ Expect.isTrue(confuse(f1173) is F1173);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<Function> x]) Function(int x) l1173;
+ // The static function f1173 sets `T` to `int`.
+ if (!tIsBool) {
+ x1173 = f1173 as dynamic;
+ l1173 = f1173 as dynamic;
+ x1173 = confuse(f1173);
+ l1173 = confuse(f1173);
+ }
+
+ Expect.isTrue(m1173 is F1173);
+ Expect.isTrue(m1173 is core.List<core.int> Function(int y, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1173) is F1173);
+ // In checked mode, verifies the type.
+ x1173 = m1173;
+ l1173 = m1173;
+ x1173 = confuse(m1173);
+ l1173 = confuse(m1173);
+
+ }
+
+ void testF1273() {
+ // core.List<core.int> Function(int x2, [List<T> x3]) Function(int x)
+ Expect.isTrue(f1273 is F1273);
+ Expect.isTrue(confuse(f1273) is F1273);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [List<T> x3]) Function(int x) l1273;
+ // The static function f1273 sets `T` to `int`.
+ if (!tIsBool) {
+ x1273 = f1273 as dynamic;
+ l1273 = f1273 as dynamic;
+ x1273 = confuse(f1273);
+ l1273 = confuse(f1273);
+ }
+
+ Expect.isTrue(m1273 is F1273);
+ Expect.isTrue(m1273 is core.List<core.int> Function(int x2, [List<T> x3]) Function(int x));
+ Expect.isTrue(confuse(m1273) is F1273);
+ // In checked mode, verifies the type.
+ x1273 = m1273;
+ l1273 = m1273;
+ x1273 = confuse(m1273);
+ l1273 = confuse(m1273);
+ if (!tIsBool) {
+ Expect.isTrue(f1273 is F1273<int>);
+ Expect.isFalse(f1273 is F1273<bool>);
+ Expect.isTrue(confuse(f1273) is F1273<int>);
+ Expect.isFalse(confuse(f1273) is F1273<bool>);
+ Expect.equals(tIsDynamic, m1273 is F1273<bool>);
+ Expect.equals(tIsDynamic, confuse(m1273) is F1273<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1273 = (f1273 as dynamic); });
+ Expect.throws(() { x1273 = confuse(f1273); });
+ core.List<core.int> Function(int x2, [List<T> x3]) Function(int x) l1273;
+ Expect.throws(() { l1273 = (f1273 as dynamic); });
+ Expect.throws(() { l1273 = confuse(f1273); });
+ }
+ core.List<core.int> Function(int x2, [List<T> x3]) Function(int x) l1273 = m1273;
+ // In checked mode, verifies the type.
+ x1273 = m1273;
+ x1273 = confuse(m1273);
+ }
+ }
+
+ void testF1373() {
+ // List<T> Function({Function x}) Function(int x)
+ Expect.isTrue(f1373 is F1373);
+ Expect.isTrue(confuse(f1373) is F1373);
+ // In checked mode, verifies the type.
+ List<T> Function({Function x}) Function(int x) l1373;
+ // The static function f1373 sets `T` to `int`.
+ if (!tIsBool) {
+ x1373 = f1373 as dynamic;
+ l1373 = f1373 as dynamic;
+ x1373 = confuse(f1373);
+ l1373 = confuse(f1373);
+ }
+
+ Expect.isTrue(m1373 is F1373);
+ Expect.isTrue(m1373 is List<T> Function({Function x}) Function(int x));
+ Expect.isTrue(confuse(m1373) is F1373);
+ // In checked mode, verifies the type.
+ x1373 = m1373;
+ l1373 = m1373;
+ x1373 = confuse(m1373);
+ l1373 = confuse(m1373);
+ if (!tIsBool) {
+ Expect.isTrue(f1373 is F1373<int>);
+ Expect.isFalse(f1373 is F1373<bool>);
+ Expect.isTrue(confuse(f1373) is F1373<int>);
+ Expect.isFalse(confuse(f1373) is F1373<bool>);
+ Expect.equals(tIsDynamic, m1373 is F1373<bool>);
+ Expect.equals(tIsDynamic, confuse(m1373) is F1373<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1373 = (f1373 as dynamic); });
+ Expect.throws(() { x1373 = confuse(f1373); });
+ List<T> Function({Function x}) Function(int x) l1373;
+ Expect.throws(() { l1373 = (f1373 as dynamic); });
+ Expect.throws(() { l1373 = confuse(f1373); });
+ }
+ List<T> Function({Function x}) Function(int x) l1373 = m1373;
+ // In checked mode, verifies the type.
+ x1373 = m1373;
+ x1373 = confuse(m1373);
+ }
+ }
+
+ void testF1473() {
+ // List<T> Function(List<T> x) Function(int x)
+ Expect.isTrue(f1473 is F1473);
+ Expect.isTrue(confuse(f1473) is F1473);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x) Function(int x) l1473;
+ // The static function f1473 sets `T` to `int`.
+ if (!tIsBool) {
+ x1473 = f1473 as dynamic;
+ l1473 = f1473 as dynamic;
+ x1473 = confuse(f1473);
+ l1473 = confuse(f1473);
+ }
+
+ Expect.isTrue(m1473 is F1473);
+ Expect.isTrue(m1473 is List<T> Function(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1473) is F1473);
+ // In checked mode, verifies the type.
+ x1473 = m1473;
+ l1473 = m1473;
+ x1473 = confuse(m1473);
+ l1473 = confuse(m1473);
+ if (!tIsBool) {
+ Expect.isTrue(f1473 is F1473<int>);
+ Expect.isFalse(f1473 is F1473<bool>);
+ Expect.isTrue(confuse(f1473) is F1473<int>);
+ Expect.isFalse(confuse(f1473) is F1473<bool>);
+ Expect.equals(tIsDynamic, m1473 is F1473<bool>);
+ Expect.equals(tIsDynamic, confuse(m1473) is F1473<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1473 = (f1473 as dynamic); });
+ Expect.throws(() { x1473 = confuse(f1473); });
+ List<T> Function(List<T> x) Function(int x) l1473;
+ Expect.throws(() { l1473 = (f1473 as dynamic); });
+ Expect.throws(() { l1473 = confuse(f1473); });
+ }
+ List<T> Function(List<T> x) Function(int x) l1473 = m1473;
+ // In checked mode, verifies the type.
+ x1473 = m1473;
+ x1473 = confuse(m1473);
+ }
+ }
+
+ void testF1573() {
+ // Function(int x1, [Function x]) Function(int x)
+ Expect.isTrue(f1573 is F1573);
+ Expect.isTrue(confuse(f1573) is F1573);
+ // In checked mode, verifies the type.
+ Function(int x1, [Function x]) Function(int x) l1573;
+ // The static function f1573 sets `T` to `int`.
+ if (!tIsBool) {
+ x1573 = f1573 as dynamic;
+ l1573 = f1573 as dynamic;
+ x1573 = confuse(f1573);
+ l1573 = confuse(f1573);
+ }
+
+ Expect.isTrue(m1573 is F1573);
+ Expect.isTrue(m1573 is Function(int x1, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m1573) is F1573);
+ // In checked mode, verifies the type.
+ x1573 = m1573;
+ l1573 = m1573;
+ x1573 = confuse(m1573);
+ l1573 = confuse(m1573);
+
+ }
+
+ void testF1673() {
+ // Function([core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1673 is F1673);
+ Expect.isTrue(confuse(f1673) is F1673);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x1]) Function(int x) l1673;
+ // The static function f1673 sets `T` to `int`.
+ if (!tIsBool) {
+ x1673 = f1673 as dynamic;
+ l1673 = f1673 as dynamic;
+ x1673 = confuse(f1673);
+ l1673 = confuse(f1673);
+ }
+
+ Expect.isTrue(m1673 is F1673);
+ Expect.isTrue(m1673 is Function([core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1673) is F1673);
+ // In checked mode, verifies the type.
+ x1673 = m1673;
+ l1673 = m1673;
+ x1673 = confuse(m1673);
+ l1673 = confuse(m1673);
+
+ }
+
+ void testF1773() {
+ // int Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1773 is F1773);
+ Expect.isTrue(confuse(f1773) is F1773);
+ // In checked mode, verifies the type.
+ int Function<A>(List<A> x) Function(int x) l1773;
+ // The static function f1773 sets `T` to `int`.
+ if (!tIsBool) {
+ x1773 = f1773 as dynamic;
+ l1773 = f1773 as dynamic;
+ x1773 = confuse(f1773);
+ l1773 = confuse(f1773);
+ }
+
+ Expect.isTrue(m1773 is F1773);
+ Expect.isTrue(m1773 is int Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1773) is F1773);
+ // In checked mode, verifies the type.
+ x1773 = m1773;
+ l1773 = m1773;
+ x1773 = confuse(m1773);
+ l1773 = confuse(m1773);
+
+ }
+
+ void testF1873() {
+ // List<T> Function<A>(int x) Function(int x)
+ Expect.isTrue(f1873 is F1873);
+ Expect.isTrue(confuse(f1873) is F1873);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(int x) Function(int x) l1873;
+ // The static function f1873 sets `T` to `int`.
+ if (!tIsBool) {
+ x1873 = f1873 as dynamic;
+ l1873 = f1873 as dynamic;
+ x1873 = confuse(f1873);
+ l1873 = confuse(f1873);
+ }
+
+ Expect.isTrue(m1873 is F1873);
+ Expect.isTrue(m1873 is List<T> Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1873) is F1873);
+ // In checked mode, verifies the type.
+ x1873 = m1873;
+ l1873 = m1873;
+ x1873 = confuse(m1873);
+ l1873 = confuse(m1873);
+ if (!tIsBool) {
+ Expect.isTrue(f1873 is F1873<int>);
+ Expect.isFalse(f1873 is F1873<bool>);
+ Expect.isTrue(confuse(f1873) is F1873<int>);
+ Expect.isFalse(confuse(f1873) is F1873<bool>);
+ Expect.equals(tIsDynamic, m1873 is F1873<bool>);
+ Expect.equals(tIsDynamic, confuse(m1873) is F1873<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1873 = (f1873 as dynamic); });
+ Expect.throws(() { x1873 = confuse(f1873); });
+ List<T> Function<A>(int x) Function(int x) l1873;
+ Expect.throws(() { l1873 = (f1873 as dynamic); });
+ Expect.throws(() { l1873 = confuse(f1873); });
+ }
+ List<T> Function<A>(int x) Function(int x) l1873 = m1873;
+ // In checked mode, verifies the type.
+ x1873 = m1873;
+ x1873 = confuse(m1873);
+ }
+ }
+
+ void testF1973() {
+ // List<A> Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1973 is F1973);
+ Expect.isTrue(confuse(f1973) is F1973);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(Function x) Function(int x) l1973;
+ // The static function f1973 sets `T` to `int`.
+ if (!tIsBool) {
+ x1973 = f1973 as dynamic;
+ l1973 = f1973 as dynamic;
+ x1973 = confuse(f1973);
+ l1973 = confuse(f1973);
+ }
+
+ Expect.isTrue(m1973 is F1973);
+ Expect.isTrue(m1973 is List<A> Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1973) is F1973);
+ // In checked mode, verifies the type.
+ x1973 = m1973;
+ l1973 = m1973;
+ x1973 = confuse(m1973);
+ l1973 = confuse(m1973);
+
+ }
+
+
+}
+
+class C74<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x, [Function x2]) x74;
+ core.List<core.int> Function(int x1, [int x2]) x174;
+ List<T> Function(int x1, [List<T> x2]) x274;
+ List<T> Function<A>(A x) x374;
+ int Function(int x, [Function x1]) Function<B extends core.int>() x474;
+ int Function(int y, {core.List<core.int> x}) Function<B extends core.int>() x574;
+ Function Function([Function x]) Function<B extends core.int>() x674;
+ Function Function(core.List<core.int> x1) Function<B extends core.int>() x774;
+ List<Function> Function(int x2, [int x3]) Function<B extends core.int>() x874;
+ List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>() x974;
+ core.List<core.int> Function(int x) Function<B extends core.int>() x1074;
+ core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>() x1174;
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>() x1274;
+ List<T> Function({Function x}) Function<B extends core.int>() x1374;
+ List<T> Function(List<T> x) Function<B extends core.int>() x1474;
+ Function(int x1, [Function x]) Function<B extends core.int>() x1574;
+ Function([core.List<core.int> x1]) Function<B extends core.int>() x1674;
+ int Function<A>(List<A> x) Function<B extends core.int>() x1774;
+ List<T> Function<A>(int x) Function<B extends core.int>() x1874;
+ List<A> Function<A>(Function x) Function<B extends core.int>() x1974;
+
+
+ C74({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m74(int x, [Function x0]) => null;
+ core.List<core.int> m174(int x0, [int x1]) => null;
+ List<T> m274(int x0, [List<T> x1]) => null;
+ List<T> m374<A>(A x) => null;
+ int Function(int x, [Function x0]) m474<B extends core.int>() => null;
+ int Function(int y, {core.List<core.int> x}) m574<B extends core.int>() => null;
+ Function Function([Function x]) m674<B extends core.int>() => null;
+ Function Function(core.List<core.int> x0) m774<B extends core.int>() => null;
+ List<Function> Function(int x0, [int x1]) m874<B extends core.int>() => null;
+ List<Function> Function(int x0, {List<Function> x}) m974<B extends core.int>() => null;
+ core.List<core.int> Function(int x) m1074<B extends core.int>() => null;
+ core.List<core.int> Function(int y, [List<Function> x]) m1174<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [List<T> x1]) m1274<B extends core.int>() => null;
+ List<T> Function({Function x}) m1374<B extends core.int>() => null;
+ List<T> Function(List<T> x) m1474<B extends core.int>() => null;
+ Function(int x0, [Function x]) m1574<B extends core.int>() => null;
+ Function([core.List<core.int> x0]) m1674<B extends core.int>() => null;
+ int Function<A>(List<A> x) m1774<B extends core.int>() => null;
+ List<T> Function<A>(int x) m1874<B extends core.int>() => null;
+ List<A> Function<A>(Function x) m1974<B extends core.int>() => null;
+
+
+ runTests() {
+ testF74();
+ testF174();
+ testF274();
+ testF374();
+ testF474();
+ testF574();
+ testF674();
+ testF774();
+ testF874();
+ testF974();
+ testF1074();
+ testF1174();
+ testF1274();
+ testF1374();
+ testF1474();
+ testF1574();
+ testF1674();
+ testF1774();
+ testF1874();
+ testF1974();
+ }
+
+ void testF74() {
+ // Function Function(int x, [Function x2])
+ Expect.isTrue(f74 is F74);
+ Expect.isTrue(confuse(f74) is F74);
+ // In checked mode, verifies the type.
+ Function Function(int x, [Function x2]) l74;
+ // The static function f74 sets `T` to `int`.
+ if (!tIsBool) {
+ x74 = f74 as dynamic;
+ l74 = f74 as dynamic;
+ x74 = confuse(f74);
+ l74 = confuse(f74);
+ }
+
+ Expect.isTrue(m74 is F74);
+ Expect.isTrue(m74 is Function Function(int x, [Function x2]));
+ Expect.isTrue(confuse(m74) is F74);
+ // In checked mode, verifies the type.
+ x74 = m74;
+ l74 = m74;
+ x74 = confuse(m74);
+ l74 = confuse(m74);
+
+ }
+
+ void testF174() {
+ // core.List<core.int> Function(int x1, [int x2])
+ Expect.isTrue(f174 is F174);
+ Expect.isTrue(confuse(f174) is F174);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [int x2]) l174;
+ // The static function f174 sets `T` to `int`.
+ if (!tIsBool) {
+ x174 = f174 as dynamic;
+ l174 = f174 as dynamic;
+ x174 = confuse(f174);
+ l174 = confuse(f174);
+ }
+
+ Expect.isTrue(m174 is F174);
+ Expect.isTrue(m174 is core.List<core.int> Function(int x1, [int x2]));
+ Expect.isTrue(confuse(m174) is F174);
+ // In checked mode, verifies the type.
+ x174 = m174;
+ l174 = m174;
+ x174 = confuse(m174);
+ l174 = confuse(m174);
+
+ }
+
+ void testF274() {
+ // List<T> Function(int x1, [List<T> x2])
+ Expect.isTrue(f274 is F274);
+ Expect.isTrue(confuse(f274) is F274);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<T> x2]) l274;
+ // The static function f274 sets `T` to `int`.
+ if (!tIsBool) {
+ x274 = f274 as dynamic;
+ l274 = f274 as dynamic;
+ x274 = confuse(f274);
+ l274 = confuse(f274);
+ }
+
+ Expect.isTrue(m274 is F274);
+ Expect.isTrue(m274 is List<T> Function(int x1, [List<T> x2]));
+ Expect.isTrue(confuse(m274) is F274);
+ // In checked mode, verifies the type.
+ x274 = m274;
+ l274 = m274;
+ x274 = confuse(m274);
+ l274 = confuse(m274);
+ if (!tIsBool) {
+ Expect.isTrue(f274 is F274<int>);
+ Expect.isFalse(f274 is F274<bool>);
+ Expect.isTrue(confuse(f274) is F274<int>);
+ Expect.isFalse(confuse(f274) is F274<bool>);
+ Expect.equals(tIsDynamic, m274 is F274<bool>);
+ Expect.equals(tIsDynamic, confuse(m274) is F274<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x274 = (f274 as dynamic); });
+ Expect.throws(() { x274 = confuse(f274); });
+ List<T> Function(int x1, [List<T> x2]) l274;
+ Expect.throws(() { l274 = (f274 as dynamic); });
+ Expect.throws(() { l274 = confuse(f274); });
+ }
+ List<T> Function(int x1, [List<T> x2]) l274 = m274;
+ // In checked mode, verifies the type.
+ x274 = m274;
+ x274 = confuse(m274);
+ }
+ }
+
+ void testF374() {
+ // List<T> Function<A>(A x)
+ Expect.isTrue(f374 is F374);
+ Expect.isTrue(confuse(f374) is F374);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(A x) l374;
+ // The static function f374 sets `T` to `int`.
+ if (!tIsBool) {
+ x374 = f374 as dynamic;
+ l374 = f374 as dynamic;
+ x374 = confuse(f374);
+ l374 = confuse(f374);
+ }
+
+ Expect.isTrue(m374 is F374);
+ Expect.isTrue(m374 is List<T> Function<A>(A x));
+ Expect.isTrue(confuse(m374) is F374);
+ // In checked mode, verifies the type.
+ x374 = m374;
+ l374 = m374;
+ x374 = confuse(m374);
+ l374 = confuse(m374);
+ if (!tIsBool) {
+ Expect.isTrue(f374 is F374<int>);
+ Expect.isFalse(f374 is F374<bool>);
+ Expect.isTrue(confuse(f374) is F374<int>);
+ Expect.isFalse(confuse(f374) is F374<bool>);
+ Expect.equals(tIsDynamic, m374 is F374<bool>);
+ Expect.equals(tIsDynamic, confuse(m374) is F374<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x374 = (f374 as dynamic); });
+ Expect.throws(() { x374 = confuse(f374); });
+ List<T> Function<A>(A x) l374;
+ Expect.throws(() { l374 = (f374 as dynamic); });
+ Expect.throws(() { l374 = confuse(f374); });
+ }
+ List<T> Function<A>(A x) l374 = m374;
+ // In checked mode, verifies the type.
+ x374 = m374;
+ x374 = confuse(m374);
+ }
+ }
+
+ void testF474() {
+ // int Function(int x, [Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f474 is F474);
+ Expect.isTrue(confuse(f474) is F474);
+ // In checked mode, verifies the type.
+ int Function(int x, [Function x1]) Function<B extends core.int>() l474;
+ // The static function f474 sets `T` to `int`.
+ if (!tIsBool) {
+ x474 = f474 as dynamic;
+ l474 = f474 as dynamic;
+ x474 = confuse(f474);
+ l474 = confuse(f474);
+ }
+
+ Expect.isTrue(m474 is F474);
+ Expect.isTrue(m474 is int Function(int x, [Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m474) is F474);
+ // In checked mode, verifies the type.
+ x474 = m474;
+ l474 = m474;
+ x474 = confuse(m474);
+ l474 = confuse(m474);
+
+ }
+
+ void testF574() {
+ // int Function(int y, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f574 is F574);
+ Expect.isTrue(confuse(f574) is F574);
+ // In checked mode, verifies the type.
+ int Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l574;
+ // The static function f574 sets `T` to `int`.
+ if (!tIsBool) {
+ x574 = f574 as dynamic;
+ l574 = f574 as dynamic;
+ x574 = confuse(f574);
+ l574 = confuse(f574);
+ }
+
+ Expect.isTrue(m574 is F574);
+ Expect.isTrue(m574 is int Function(int y, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m574) is F574);
+ // In checked mode, verifies the type.
+ x574 = m574;
+ l574 = m574;
+ x574 = confuse(m574);
+ l574 = confuse(m574);
+
+ }
+
+ void testF674() {
+ // Function Function([Function x]) Function<B extends core.int>()
+ Expect.isTrue(f674 is F674);
+ Expect.isTrue(confuse(f674) is F674);
+ // In checked mode, verifies the type.
+ Function Function([Function x]) Function<B extends core.int>() l674;
+ // The static function f674 sets `T` to `int`.
+ if (!tIsBool) {
+ x674 = f674 as dynamic;
+ l674 = f674 as dynamic;
+ x674 = confuse(f674);
+ l674 = confuse(f674);
+ }
+
+ Expect.isTrue(m674 is F674);
+ Expect.isTrue(m674 is Function Function([Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m674) is F674);
+ // In checked mode, verifies the type.
+ x674 = m674;
+ l674 = m674;
+ x674 = confuse(m674);
+ l674 = confuse(m674);
+
+ }
+
+ void testF774() {
+ // Function Function(core.List<core.int> x1) Function<B extends core.int>()
+ Expect.isTrue(f774 is F774);
+ Expect.isTrue(confuse(f774) is F774);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x1) Function<B extends core.int>() l774;
+ // The static function f774 sets `T` to `int`.
+ if (!tIsBool) {
+ x774 = f774 as dynamic;
+ l774 = f774 as dynamic;
+ x774 = confuse(f774);
+ l774 = confuse(f774);
+ }
+
+ Expect.isTrue(m774 is F774);
+ Expect.isTrue(m774 is Function Function(core.List<core.int> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m774) is F774);
+ // In checked mode, verifies the type.
+ x774 = m774;
+ l774 = m774;
+ x774 = confuse(m774);
+ l774 = confuse(m774);
+
+ }
+
+ void testF874() {
+ // List<Function> Function(int x2, [int x3]) Function<B extends core.int>()
+ Expect.isTrue(f874 is F874);
+ Expect.isTrue(confuse(f874) is F874);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [int x3]) Function<B extends core.int>() l874;
+ // The static function f874 sets `T` to `int`.
+ if (!tIsBool) {
+ x874 = f874 as dynamic;
+ l874 = f874 as dynamic;
+ x874 = confuse(f874);
+ l874 = confuse(f874);
+ }
+
+ Expect.isTrue(m874 is F874);
+ Expect.isTrue(m874 is List<Function> Function(int x2, [int x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m874) is F874);
+ // In checked mode, verifies the type.
+ x874 = m874;
+ l874 = m874;
+ x874 = confuse(m874);
+ l874 = confuse(m874);
+
+ }
+
+ void testF974() {
+ // List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f974 is F974);
+ Expect.isTrue(confuse(f974) is F974);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>() l974;
+ // The static function f974 sets `T` to `int`.
+ if (!tIsBool) {
+ x974 = f974 as dynamic;
+ l974 = f974 as dynamic;
+ x974 = confuse(f974);
+ l974 = confuse(f974);
+ }
+
+ Expect.isTrue(m974 is F974);
+ Expect.isTrue(m974 is List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m974) is F974);
+ // In checked mode, verifies the type.
+ x974 = m974;
+ l974 = m974;
+ x974 = confuse(m974);
+ l974 = confuse(m974);
+
+ }
+
+ void testF1074() {
+ // core.List<core.int> Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f1074 is F1074);
+ Expect.isTrue(confuse(f1074) is F1074);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x) Function<B extends core.int>() l1074;
+ // The static function f1074 sets `T` to `int`.
+ if (!tIsBool) {
+ x1074 = f1074 as dynamic;
+ l1074 = f1074 as dynamic;
+ x1074 = confuse(f1074);
+ l1074 = confuse(f1074);
+ }
+
+ Expect.isTrue(m1074 is F1074);
+ Expect.isTrue(m1074 is core.List<core.int> Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1074) is F1074);
+ // In checked mode, verifies the type.
+ x1074 = m1074;
+ l1074 = m1074;
+ x1074 = confuse(m1074);
+ l1074 = confuse(m1074);
+
+ }
+
+ void testF1174() {
+ // core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1174 is F1174);
+ Expect.isTrue(confuse(f1174) is F1174);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>() l1174;
+ // The static function f1174 sets `T` to `int`.
+ if (!tIsBool) {
+ x1174 = f1174 as dynamic;
+ l1174 = f1174 as dynamic;
+ x1174 = confuse(f1174);
+ l1174 = confuse(f1174);
+ }
+
+ Expect.isTrue(m1174 is F1174);
+ Expect.isTrue(m1174 is core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1174) is F1174);
+ // In checked mode, verifies the type.
+ x1174 = m1174;
+ l1174 = m1174;
+ x1174 = confuse(m1174);
+ l1174 = confuse(m1174);
+
+ }
+
+ void testF1274() {
+ // core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1274 is F1274);
+ Expect.isTrue(confuse(f1274) is F1274);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1274;
+ // The static function f1274 sets `T` to `int`.
+ if (!tIsBool) {
+ x1274 = f1274 as dynamic;
+ l1274 = f1274 as dynamic;
+ x1274 = confuse(f1274);
+ l1274 = confuse(f1274);
+ }
+
+ Expect.isTrue(m1274 is F1274);
+ Expect.isTrue(m1274 is core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1274) is F1274);
+ // In checked mode, verifies the type.
+ x1274 = m1274;
+ l1274 = m1274;
+ x1274 = confuse(m1274);
+ l1274 = confuse(m1274);
+ if (!tIsBool) {
+ Expect.isTrue(f1274 is F1274<int>);
+ Expect.isFalse(f1274 is F1274<bool>);
+ Expect.isTrue(confuse(f1274) is F1274<int>);
+ Expect.isFalse(confuse(f1274) is F1274<bool>);
+ Expect.equals(tIsDynamic, m1274 is F1274<bool>);
+ Expect.equals(tIsDynamic, confuse(m1274) is F1274<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1274 = (f1274 as dynamic); });
+ Expect.throws(() { x1274 = confuse(f1274); });
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1274;
+ Expect.throws(() { l1274 = (f1274 as dynamic); });
+ Expect.throws(() { l1274 = confuse(f1274); });
+ }
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1274 = m1274;
+ // In checked mode, verifies the type.
+ x1274 = m1274;
+ x1274 = confuse(m1274);
+ }
+ }
+
+ void testF1374() {
+ // List<T> Function({Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1374 is F1374);
+ Expect.isTrue(confuse(f1374) is F1374);
+ // In checked mode, verifies the type.
+ List<T> Function({Function x}) Function<B extends core.int>() l1374;
+ // The static function f1374 sets `T` to `int`.
+ if (!tIsBool) {
+ x1374 = f1374 as dynamic;
+ l1374 = f1374 as dynamic;
+ x1374 = confuse(f1374);
+ l1374 = confuse(f1374);
+ }
+
+ Expect.isTrue(m1374 is F1374);
+ Expect.isTrue(m1374 is List<T> Function({Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1374) is F1374);
+ // In checked mode, verifies the type.
+ x1374 = m1374;
+ l1374 = m1374;
+ x1374 = confuse(m1374);
+ l1374 = confuse(m1374);
+ if (!tIsBool) {
+ Expect.isTrue(f1374 is F1374<int>);
+ Expect.isFalse(f1374 is F1374<bool>);
+ Expect.isTrue(confuse(f1374) is F1374<int>);
+ Expect.isFalse(confuse(f1374) is F1374<bool>);
+ Expect.equals(tIsDynamic, m1374 is F1374<bool>);
+ Expect.equals(tIsDynamic, confuse(m1374) is F1374<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1374 = (f1374 as dynamic); });
+ Expect.throws(() { x1374 = confuse(f1374); });
+ List<T> Function({Function x}) Function<B extends core.int>() l1374;
+ Expect.throws(() { l1374 = (f1374 as dynamic); });
+ Expect.throws(() { l1374 = confuse(f1374); });
+ }
+ List<T> Function({Function x}) Function<B extends core.int>() l1374 = m1374;
+ // In checked mode, verifies the type.
+ x1374 = m1374;
+ x1374 = confuse(m1374);
+ }
+ }
+
+ void testF1474() {
+ // List<T> Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1474 is F1474);
+ Expect.isTrue(confuse(f1474) is F1474);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x) Function<B extends core.int>() l1474;
+ // The static function f1474 sets `T` to `int`.
+ if (!tIsBool) {
+ x1474 = f1474 as dynamic;
+ l1474 = f1474 as dynamic;
+ x1474 = confuse(f1474);
+ l1474 = confuse(f1474);
+ }
+
+ Expect.isTrue(m1474 is F1474);
+ Expect.isTrue(m1474 is List<T> Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1474) is F1474);
+ // In checked mode, verifies the type.
+ x1474 = m1474;
+ l1474 = m1474;
+ x1474 = confuse(m1474);
+ l1474 = confuse(m1474);
+ if (!tIsBool) {
+ Expect.isTrue(f1474 is F1474<int>);
+ Expect.isFalse(f1474 is F1474<bool>);
+ Expect.isTrue(confuse(f1474) is F1474<int>);
+ Expect.isFalse(confuse(f1474) is F1474<bool>);
+ Expect.equals(tIsDynamic, m1474 is F1474<bool>);
+ Expect.equals(tIsDynamic, confuse(m1474) is F1474<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1474 = (f1474 as dynamic); });
+ Expect.throws(() { x1474 = confuse(f1474); });
+ List<T> Function(List<T> x) Function<B extends core.int>() l1474;
+ Expect.throws(() { l1474 = (f1474 as dynamic); });
+ Expect.throws(() { l1474 = confuse(f1474); });
+ }
+ List<T> Function(List<T> x) Function<B extends core.int>() l1474 = m1474;
+ // In checked mode, verifies the type.
+ x1474 = m1474;
+ x1474 = confuse(m1474);
+ }
+ }
+
+ void testF1574() {
+ // Function(int x1, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1574 is F1574);
+ Expect.isTrue(confuse(f1574) is F1574);
+ // In checked mode, verifies the type.
+ Function(int x1, [Function x]) Function<B extends core.int>() l1574;
+ // The static function f1574 sets `T` to `int`.
+ if (!tIsBool) {
+ x1574 = f1574 as dynamic;
+ l1574 = f1574 as dynamic;
+ x1574 = confuse(f1574);
+ l1574 = confuse(f1574);
+ }
+
+ Expect.isTrue(m1574 is F1574);
+ Expect.isTrue(m1574 is Function(int x1, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1574) is F1574);
+ // In checked mode, verifies the type.
+ x1574 = m1574;
+ l1574 = m1574;
+ x1574 = confuse(m1574);
+ l1574 = confuse(m1574);
+
+ }
+
+ void testF1674() {
+ // Function([core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1674 is F1674);
+ Expect.isTrue(confuse(f1674) is F1674);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x1]) Function<B extends core.int>() l1674;
+ // The static function f1674 sets `T` to `int`.
+ if (!tIsBool) {
+ x1674 = f1674 as dynamic;
+ l1674 = f1674 as dynamic;
+ x1674 = confuse(f1674);
+ l1674 = confuse(f1674);
+ }
+
+ Expect.isTrue(m1674 is F1674);
+ Expect.isTrue(m1674 is Function([core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1674) is F1674);
+ // In checked mode, verifies the type.
+ x1674 = m1674;
+ l1674 = m1674;
+ x1674 = confuse(m1674);
+ l1674 = confuse(m1674);
+
+ }
+
+ void testF1774() {
+ // int Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1774 is F1774);
+ Expect.isTrue(confuse(f1774) is F1774);
+ // In checked mode, verifies the type.
+ int Function<A>(List<A> x) Function<B extends core.int>() l1774;
+ // The static function f1774 sets `T` to `int`.
+ if (!tIsBool) {
+ x1774 = f1774 as dynamic;
+ l1774 = f1774 as dynamic;
+ x1774 = confuse(f1774);
+ l1774 = confuse(f1774);
+ }
+
+ Expect.isTrue(m1774 is F1774);
+ Expect.isTrue(m1774 is int Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1774) is F1774);
+ // In checked mode, verifies the type.
+ x1774 = m1774;
+ l1774 = m1774;
+ x1774 = confuse(m1774);
+ l1774 = confuse(m1774);
+
+ }
+
+ void testF1874() {
+ // List<T> Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1874 is F1874);
+ Expect.isTrue(confuse(f1874) is F1874);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(int x) Function<B extends core.int>() l1874;
+ // The static function f1874 sets `T` to `int`.
+ if (!tIsBool) {
+ x1874 = f1874 as dynamic;
+ l1874 = f1874 as dynamic;
+ x1874 = confuse(f1874);
+ l1874 = confuse(f1874);
+ }
+
+ Expect.isTrue(m1874 is F1874);
+ Expect.isTrue(m1874 is List<T> Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1874) is F1874);
+ // In checked mode, verifies the type.
+ x1874 = m1874;
+ l1874 = m1874;
+ x1874 = confuse(m1874);
+ l1874 = confuse(m1874);
+ if (!tIsBool) {
+ Expect.isTrue(f1874 is F1874<int>);
+ Expect.isFalse(f1874 is F1874<bool>);
+ Expect.isTrue(confuse(f1874) is F1874<int>);
+ Expect.isFalse(confuse(f1874) is F1874<bool>);
+ Expect.equals(tIsDynamic, m1874 is F1874<bool>);
+ Expect.equals(tIsDynamic, confuse(m1874) is F1874<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1874 = (f1874 as dynamic); });
+ Expect.throws(() { x1874 = confuse(f1874); });
+ List<T> Function<A>(int x) Function<B extends core.int>() l1874;
+ Expect.throws(() { l1874 = (f1874 as dynamic); });
+ Expect.throws(() { l1874 = confuse(f1874); });
+ }
+ List<T> Function<A>(int x) Function<B extends core.int>() l1874 = m1874;
+ // In checked mode, verifies the type.
+ x1874 = m1874;
+ x1874 = confuse(m1874);
+ }
+ }
+
+ void testF1974() {
+ // List<A> Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1974 is F1974);
+ Expect.isTrue(confuse(f1974) is F1974);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(Function x) Function<B extends core.int>() l1974;
+ // The static function f1974 sets `T` to `int`.
+ if (!tIsBool) {
+ x1974 = f1974 as dynamic;
+ l1974 = f1974 as dynamic;
+ x1974 = confuse(f1974);
+ l1974 = confuse(f1974);
+ }
+
+ Expect.isTrue(m1974 is F1974);
+ Expect.isTrue(m1974 is List<A> Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1974) is F1974);
+ // In checked mode, verifies the type.
+ x1974 = m1974;
+ l1974 = m1974;
+ x1974 = confuse(m1974);
+ l1974 = confuse(m1974);
+
+ }
+
+
+}
+
+class C75<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function({Function x}) x75;
+ core.List<core.int> Function(int x, [int x2]) x175;
+ List<T> Function(int x, [List<T> x2]) x275;
+ List<T> Function<A>(List<A> x) x375;
+ int Function(int x, [Function x1]) Function<B extends core.int>(int x) x475;
+ int Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) x575;
+ Function Function([Function x]) Function<B extends core.int>(int x) x675;
+ Function Function(core.List<core.int> x1) Function<B extends core.int>(int x) x775;
+ List<Function> Function(int x2, [int x3]) Function<B extends core.int>(int x) x875;
+ List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) x975;
+ core.List<core.int> Function(int x) Function<B extends core.int>(int x) x1075;
+ core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) x1175;
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) x1275;
+ List<T> Function({Function x}) Function<B extends core.int>(int x) x1375;
+ List<T> Function(List<T> x) Function<B extends core.int>(int x) x1475;
+ Function(int x1, [Function x]) Function<B extends core.int>(int x) x1575;
+ Function([core.List<core.int> x1]) Function<B extends core.int>(int x) x1675;
+ int Function<A>(List<A> x) Function<B extends core.int>(int x) x1775;
+ List<T> Function<A>(int x) Function<B extends core.int>(int x) x1875;
+ List<A> Function<A>(Function x) Function<B extends core.int>(int x) x1975;
+
+
+ C75({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m75({Function x}) => null;
+ core.List<core.int> m175(int x, [int x0]) => null;
+ List<T> m275(int x, [List<T> x0]) => null;
+ List<T> m375<A>(List<A> x) => null;
+ int Function(int x, [Function x0]) m475<B extends core.int>(int x) => null;
+ int Function(int y, {core.List<core.int> x}) m575<B extends core.int>(int x) => null;
+ Function Function([Function x]) m675<B extends core.int>(int x) => null;
+ Function Function(core.List<core.int> x0) m775<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [int x1]) m875<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, {List<Function> x}) m975<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x) m1075<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, [List<Function> x]) m1175<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [List<T> x1]) m1275<B extends core.int>(int x) => null;
+ List<T> Function({Function x}) m1375<B extends core.int>(int x) => null;
+ List<T> Function(List<T> x) m1475<B extends core.int>(int x) => null;
+ Function(int x0, [Function x]) m1575<B extends core.int>(int x) => null;
+ Function([core.List<core.int> x0]) m1675<B extends core.int>(int x) => null;
+ int Function<A>(List<A> x) m1775<B extends core.int>(int x) => null;
+ List<T> Function<A>(int x) m1875<B extends core.int>(int x) => null;
+ List<A> Function<A>(Function x) m1975<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF75();
+ testF175();
+ testF275();
+ testF375();
+ testF475();
+ testF575();
+ testF675();
+ testF775();
+ testF875();
+ testF975();
+ testF1075();
+ testF1175();
+ testF1275();
+ testF1375();
+ testF1475();
+ testF1575();
+ testF1675();
+ testF1775();
+ testF1875();
+ testF1975();
+ }
+
+ void testF75() {
+ // Function Function({Function x})
+ Expect.isTrue(f75 is F75);
+ Expect.isTrue(confuse(f75) is F75);
+ // In checked mode, verifies the type.
+ Function Function({Function x}) l75;
+ // The static function f75 sets `T` to `int`.
+ if (!tIsBool) {
+ x75 = f75 as dynamic;
+ l75 = f75 as dynamic;
+ x75 = confuse(f75);
+ l75 = confuse(f75);
+ }
+
+ Expect.isTrue(m75 is F75);
+ Expect.isTrue(m75 is Function Function({Function x}));
+ Expect.isTrue(confuse(m75) is F75);
+ // In checked mode, verifies the type.
+ x75 = m75;
+ l75 = m75;
+ x75 = confuse(m75);
+ l75 = confuse(m75);
+
+ }
+
+ void testF175() {
+ // core.List<core.int> Function(int x, [int x2])
+ Expect.isTrue(f175 is F175);
+ Expect.isTrue(confuse(f175) is F175);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [int x2]) l175;
+ // The static function f175 sets `T` to `int`.
+ if (!tIsBool) {
+ x175 = f175 as dynamic;
+ l175 = f175 as dynamic;
+ x175 = confuse(f175);
+ l175 = confuse(f175);
+ }
+
+ Expect.isTrue(m175 is F175);
+ Expect.isTrue(m175 is core.List<core.int> Function(int x, [int x2]));
+ Expect.isTrue(confuse(m175) is F175);
+ // In checked mode, verifies the type.
+ x175 = m175;
+ l175 = m175;
+ x175 = confuse(m175);
+ l175 = confuse(m175);
+
+ }
+
+ void testF275() {
+ // List<T> Function(int x, [List<T> x2])
+ Expect.isTrue(f275 is F275);
+ Expect.isTrue(confuse(f275) is F275);
+ // In checked mode, verifies the type.
+ List<T> Function(int x, [List<T> x2]) l275;
+ // The static function f275 sets `T` to `int`.
+ if (!tIsBool) {
+ x275 = f275 as dynamic;
+ l275 = f275 as dynamic;
+ x275 = confuse(f275);
+ l275 = confuse(f275);
+ }
+
+ Expect.isTrue(m275 is F275);
+ Expect.isTrue(m275 is List<T> Function(int x, [List<T> x2]));
+ Expect.isTrue(confuse(m275) is F275);
+ // In checked mode, verifies the type.
+ x275 = m275;
+ l275 = m275;
+ x275 = confuse(m275);
+ l275 = confuse(m275);
+ if (!tIsBool) {
+ Expect.isTrue(f275 is F275<int>);
+ Expect.isFalse(f275 is F275<bool>);
+ Expect.isTrue(confuse(f275) is F275<int>);
+ Expect.isFalse(confuse(f275) is F275<bool>);
+ Expect.equals(tIsDynamic, m275 is F275<bool>);
+ Expect.equals(tIsDynamic, confuse(m275) is F275<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x275 = (f275 as dynamic); });
+ Expect.throws(() { x275 = confuse(f275); });
+ List<T> Function(int x, [List<T> x2]) l275;
+ Expect.throws(() { l275 = (f275 as dynamic); });
+ Expect.throws(() { l275 = confuse(f275); });
+ }
+ List<T> Function(int x, [List<T> x2]) l275 = m275;
+ // In checked mode, verifies the type.
+ x275 = m275;
+ x275 = confuse(m275);
+ }
+ }
+
+ void testF375() {
+ // List<T> Function<A>(List<A> x)
+ Expect.isTrue(f375 is F375);
+ Expect.isTrue(confuse(f375) is F375);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<A> x) l375;
+ // The static function f375 sets `T` to `int`.
+ if (!tIsBool) {
+ x375 = f375 as dynamic;
+ l375 = f375 as dynamic;
+ x375 = confuse(f375);
+ l375 = confuse(f375);
+ }
+
+ Expect.isTrue(m375 is F375);
+ Expect.isTrue(m375 is List<T> Function<A>(List<A> x));
+ Expect.isTrue(confuse(m375) is F375);
+ // In checked mode, verifies the type.
+ x375 = m375;
+ l375 = m375;
+ x375 = confuse(m375);
+ l375 = confuse(m375);
+ if (!tIsBool) {
+ Expect.isTrue(f375 is F375<int>);
+ Expect.isFalse(f375 is F375<bool>);
+ Expect.isTrue(confuse(f375) is F375<int>);
+ Expect.isFalse(confuse(f375) is F375<bool>);
+ Expect.equals(tIsDynamic, m375 is F375<bool>);
+ Expect.equals(tIsDynamic, confuse(m375) is F375<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x375 = (f375 as dynamic); });
+ Expect.throws(() { x375 = confuse(f375); });
+ List<T> Function<A>(List<A> x) l375;
+ Expect.throws(() { l375 = (f375 as dynamic); });
+ Expect.throws(() { l375 = confuse(f375); });
+ }
+ List<T> Function<A>(List<A> x) l375 = m375;
+ // In checked mode, verifies the type.
+ x375 = m375;
+ x375 = confuse(m375);
+ }
+ }
+
+ void testF475() {
+ // int Function(int x, [Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f475 is F475);
+ Expect.isTrue(confuse(f475) is F475);
+ // In checked mode, verifies the type.
+ int Function(int x, [Function x1]) Function<B extends core.int>(int x) l475;
+ // The static function f475 sets `T` to `int`.
+ if (!tIsBool) {
+ x475 = f475 as dynamic;
+ l475 = f475 as dynamic;
+ x475 = confuse(f475);
+ l475 = confuse(f475);
+ }
+
+ Expect.isTrue(m475 is F475);
+ Expect.isTrue(m475 is int Function(int x, [Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m475) is F475);
+ // In checked mode, verifies the type.
+ x475 = m475;
+ l475 = m475;
+ x475 = confuse(m475);
+ l475 = confuse(m475);
+
+ }
+
+ void testF575() {
+ // int Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f575 is F575);
+ Expect.isTrue(confuse(f575) is F575);
+ // In checked mode, verifies the type.
+ int Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l575;
+ // The static function f575 sets `T` to `int`.
+ if (!tIsBool) {
+ x575 = f575 as dynamic;
+ l575 = f575 as dynamic;
+ x575 = confuse(f575);
+ l575 = confuse(f575);
+ }
+
+ Expect.isTrue(m575 is F575);
+ Expect.isTrue(m575 is int Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m575) is F575);
+ // In checked mode, verifies the type.
+ x575 = m575;
+ l575 = m575;
+ x575 = confuse(m575);
+ l575 = confuse(m575);
+
+ }
+
+ void testF675() {
+ // Function Function([Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f675 is F675);
+ Expect.isTrue(confuse(f675) is F675);
+ // In checked mode, verifies the type.
+ Function Function([Function x]) Function<B extends core.int>(int x) l675;
+ // The static function f675 sets `T` to `int`.
+ if (!tIsBool) {
+ x675 = f675 as dynamic;
+ l675 = f675 as dynamic;
+ x675 = confuse(f675);
+ l675 = confuse(f675);
+ }
+
+ Expect.isTrue(m675 is F675);
+ Expect.isTrue(m675 is Function Function([Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m675) is F675);
+ // In checked mode, verifies the type.
+ x675 = m675;
+ l675 = m675;
+ x675 = confuse(m675);
+ l675 = confuse(m675);
+
+ }
+
+ void testF775() {
+ // Function Function(core.List<core.int> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f775 is F775);
+ Expect.isTrue(confuse(f775) is F775);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x1) Function<B extends core.int>(int x) l775;
+ // The static function f775 sets `T` to `int`.
+ if (!tIsBool) {
+ x775 = f775 as dynamic;
+ l775 = f775 as dynamic;
+ x775 = confuse(f775);
+ l775 = confuse(f775);
+ }
+
+ Expect.isTrue(m775 is F775);
+ Expect.isTrue(m775 is Function Function(core.List<core.int> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m775) is F775);
+ // In checked mode, verifies the type.
+ x775 = m775;
+ l775 = m775;
+ x775 = confuse(m775);
+ l775 = confuse(m775);
+
+ }
+
+ void testF875() {
+ // List<Function> Function(int x2, [int x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f875 is F875);
+ Expect.isTrue(confuse(f875) is F875);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x2, [int x3]) Function<B extends core.int>(int x) l875;
+ // The static function f875 sets `T` to `int`.
+ if (!tIsBool) {
+ x875 = f875 as dynamic;
+ l875 = f875 as dynamic;
+ x875 = confuse(f875);
+ l875 = confuse(f875);
+ }
+
+ Expect.isTrue(m875 is F875);
+ Expect.isTrue(m875 is List<Function> Function(int x2, [int x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m875) is F875);
+ // In checked mode, verifies the type.
+ x875 = m875;
+ l875 = m875;
+ x875 = confuse(m875);
+ l875 = confuse(m875);
+
+ }
+
+ void testF975() {
+ // List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f975 is F975);
+ Expect.isTrue(confuse(f975) is F975);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l975;
+ // The static function f975 sets `T` to `int`.
+ if (!tIsBool) {
+ x975 = f975 as dynamic;
+ l975 = f975 as dynamic;
+ x975 = confuse(f975);
+ l975 = confuse(f975);
+ }
+
+ Expect.isTrue(m975 is F975);
+ Expect.isTrue(m975 is List<Function> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m975) is F975);
+ // In checked mode, verifies the type.
+ x975 = m975;
+ l975 = m975;
+ x975 = confuse(m975);
+ l975 = confuse(m975);
+
+ }
+
+ void testF1075() {
+ // core.List<core.int> Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1075 is F1075);
+ Expect.isTrue(confuse(f1075) is F1075);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x) Function<B extends core.int>(int x) l1075;
+ // The static function f1075 sets `T` to `int`.
+ if (!tIsBool) {
+ x1075 = f1075 as dynamic;
+ l1075 = f1075 as dynamic;
+ x1075 = confuse(f1075);
+ l1075 = confuse(f1075);
+ }
+
+ Expect.isTrue(m1075 is F1075);
+ Expect.isTrue(m1075 is core.List<core.int> Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1075) is F1075);
+ // In checked mode, verifies the type.
+ x1075 = m1075;
+ l1075 = m1075;
+ x1075 = confuse(m1075);
+ l1075 = confuse(m1075);
+
+ }
+
+ void testF1175() {
+ // core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1175 is F1175);
+ Expect.isTrue(confuse(f1175) is F1175);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l1175;
+ // The static function f1175 sets `T` to `int`.
+ if (!tIsBool) {
+ x1175 = f1175 as dynamic;
+ l1175 = f1175 as dynamic;
+ x1175 = confuse(f1175);
+ l1175 = confuse(f1175);
+ }
+
+ Expect.isTrue(m1175 is F1175);
+ Expect.isTrue(m1175 is core.List<core.int> Function(int y, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1175) is F1175);
+ // In checked mode, verifies the type.
+ x1175 = m1175;
+ l1175 = m1175;
+ x1175 = confuse(m1175);
+ l1175 = confuse(m1175);
+
+ }
+
+ void testF1275() {
+ // core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1275 is F1275);
+ Expect.isTrue(confuse(f1275) is F1275);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1275;
+ // The static function f1275 sets `T` to `int`.
+ if (!tIsBool) {
+ x1275 = f1275 as dynamic;
+ l1275 = f1275 as dynamic;
+ x1275 = confuse(f1275);
+ l1275 = confuse(f1275);
+ }
+
+ Expect.isTrue(m1275 is F1275);
+ Expect.isTrue(m1275 is core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1275) is F1275);
+ // In checked mode, verifies the type.
+ x1275 = m1275;
+ l1275 = m1275;
+ x1275 = confuse(m1275);
+ l1275 = confuse(m1275);
+ if (!tIsBool) {
+ Expect.isTrue(f1275 is F1275<int>);
+ Expect.isFalse(f1275 is F1275<bool>);
+ Expect.isTrue(confuse(f1275) is F1275<int>);
+ Expect.isFalse(confuse(f1275) is F1275<bool>);
+ Expect.equals(tIsDynamic, m1275 is F1275<bool>);
+ Expect.equals(tIsDynamic, confuse(m1275) is F1275<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1275 = (f1275 as dynamic); });
+ Expect.throws(() { x1275 = confuse(f1275); });
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1275;
+ Expect.throws(() { l1275 = (f1275 as dynamic); });
+ Expect.throws(() { l1275 = confuse(f1275); });
+ }
+ core.List<core.int> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1275 = m1275;
+ // In checked mode, verifies the type.
+ x1275 = m1275;
+ x1275 = confuse(m1275);
+ }
+ }
+
+ void testF1375() {
+ // List<T> Function({Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1375 is F1375);
+ Expect.isTrue(confuse(f1375) is F1375);
+ // In checked mode, verifies the type.
+ List<T> Function({Function x}) Function<B extends core.int>(int x) l1375;
+ // The static function f1375 sets `T` to `int`.
+ if (!tIsBool) {
+ x1375 = f1375 as dynamic;
+ l1375 = f1375 as dynamic;
+ x1375 = confuse(f1375);
+ l1375 = confuse(f1375);
+ }
+
+ Expect.isTrue(m1375 is F1375);
+ Expect.isTrue(m1375 is List<T> Function({Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1375) is F1375);
+ // In checked mode, verifies the type.
+ x1375 = m1375;
+ l1375 = m1375;
+ x1375 = confuse(m1375);
+ l1375 = confuse(m1375);
+ if (!tIsBool) {
+ Expect.isTrue(f1375 is F1375<int>);
+ Expect.isFalse(f1375 is F1375<bool>);
+ Expect.isTrue(confuse(f1375) is F1375<int>);
+ Expect.isFalse(confuse(f1375) is F1375<bool>);
+ Expect.equals(tIsDynamic, m1375 is F1375<bool>);
+ Expect.equals(tIsDynamic, confuse(m1375) is F1375<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1375 = (f1375 as dynamic); });
+ Expect.throws(() { x1375 = confuse(f1375); });
+ List<T> Function({Function x}) Function<B extends core.int>(int x) l1375;
+ Expect.throws(() { l1375 = (f1375 as dynamic); });
+ Expect.throws(() { l1375 = confuse(f1375); });
+ }
+ List<T> Function({Function x}) Function<B extends core.int>(int x) l1375 = m1375;
+ // In checked mode, verifies the type.
+ x1375 = m1375;
+ x1375 = confuse(m1375);
+ }
+ }
+
+ void testF1475() {
+ // List<T> Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1475 is F1475);
+ Expect.isTrue(confuse(f1475) is F1475);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x) Function<B extends core.int>(int x) l1475;
+ // The static function f1475 sets `T` to `int`.
+ if (!tIsBool) {
+ x1475 = f1475 as dynamic;
+ l1475 = f1475 as dynamic;
+ x1475 = confuse(f1475);
+ l1475 = confuse(f1475);
+ }
+
+ Expect.isTrue(m1475 is F1475);
+ Expect.isTrue(m1475 is List<T> Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1475) is F1475);
+ // In checked mode, verifies the type.
+ x1475 = m1475;
+ l1475 = m1475;
+ x1475 = confuse(m1475);
+ l1475 = confuse(m1475);
+ if (!tIsBool) {
+ Expect.isTrue(f1475 is F1475<int>);
+ Expect.isFalse(f1475 is F1475<bool>);
+ Expect.isTrue(confuse(f1475) is F1475<int>);
+ Expect.isFalse(confuse(f1475) is F1475<bool>);
+ Expect.equals(tIsDynamic, m1475 is F1475<bool>);
+ Expect.equals(tIsDynamic, confuse(m1475) is F1475<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1475 = (f1475 as dynamic); });
+ Expect.throws(() { x1475 = confuse(f1475); });
+ List<T> Function(List<T> x) Function<B extends core.int>(int x) l1475;
+ Expect.throws(() { l1475 = (f1475 as dynamic); });
+ Expect.throws(() { l1475 = confuse(f1475); });
+ }
+ List<T> Function(List<T> x) Function<B extends core.int>(int x) l1475 = m1475;
+ // In checked mode, verifies the type.
+ x1475 = m1475;
+ x1475 = confuse(m1475);
+ }
+ }
+
+ void testF1575() {
+ // Function(int x1, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1575 is F1575);
+ Expect.isTrue(confuse(f1575) is F1575);
+ // In checked mode, verifies the type.
+ Function(int x1, [Function x]) Function<B extends core.int>(int x) l1575;
+ // The static function f1575 sets `T` to `int`.
+ if (!tIsBool) {
+ x1575 = f1575 as dynamic;
+ l1575 = f1575 as dynamic;
+ x1575 = confuse(f1575);
+ l1575 = confuse(f1575);
+ }
+
+ Expect.isTrue(m1575 is F1575);
+ Expect.isTrue(m1575 is Function(int x1, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1575) is F1575);
+ // In checked mode, verifies the type.
+ x1575 = m1575;
+ l1575 = m1575;
+ x1575 = confuse(m1575);
+ l1575 = confuse(m1575);
+
+ }
+
+ void testF1675() {
+ // Function([core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1675 is F1675);
+ Expect.isTrue(confuse(f1675) is F1675);
+ // In checked mode, verifies the type.
+ Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l1675;
+ // The static function f1675 sets `T` to `int`.
+ if (!tIsBool) {
+ x1675 = f1675 as dynamic;
+ l1675 = f1675 as dynamic;
+ x1675 = confuse(f1675);
+ l1675 = confuse(f1675);
+ }
+
+ Expect.isTrue(m1675 is F1675);
+ Expect.isTrue(m1675 is Function([core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1675) is F1675);
+ // In checked mode, verifies the type.
+ x1675 = m1675;
+ l1675 = m1675;
+ x1675 = confuse(m1675);
+ l1675 = confuse(m1675);
+
+ }
+
+ void testF1775() {
+ // int Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1775 is F1775);
+ Expect.isTrue(confuse(f1775) is F1775);
+ // In checked mode, verifies the type.
+ int Function<A>(List<A> x) Function<B extends core.int>(int x) l1775;
+ // The static function f1775 sets `T` to `int`.
+ if (!tIsBool) {
+ x1775 = f1775 as dynamic;
+ l1775 = f1775 as dynamic;
+ x1775 = confuse(f1775);
+ l1775 = confuse(f1775);
+ }
+
+ Expect.isTrue(m1775 is F1775);
+ Expect.isTrue(m1775 is int Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1775) is F1775);
+ // In checked mode, verifies the type.
+ x1775 = m1775;
+ l1775 = m1775;
+ x1775 = confuse(m1775);
+ l1775 = confuse(m1775);
+
+ }
+
+ void testF1875() {
+ // List<T> Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1875 is F1875);
+ Expect.isTrue(confuse(f1875) is F1875);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(int x) Function<B extends core.int>(int x) l1875;
+ // The static function f1875 sets `T` to `int`.
+ if (!tIsBool) {
+ x1875 = f1875 as dynamic;
+ l1875 = f1875 as dynamic;
+ x1875 = confuse(f1875);
+ l1875 = confuse(f1875);
+ }
+
+ Expect.isTrue(m1875 is F1875);
+ Expect.isTrue(m1875 is List<T> Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1875) is F1875);
+ // In checked mode, verifies the type.
+ x1875 = m1875;
+ l1875 = m1875;
+ x1875 = confuse(m1875);
+ l1875 = confuse(m1875);
+ if (!tIsBool) {
+ Expect.isTrue(f1875 is F1875<int>);
+ Expect.isFalse(f1875 is F1875<bool>);
+ Expect.isTrue(confuse(f1875) is F1875<int>);
+ Expect.isFalse(confuse(f1875) is F1875<bool>);
+ Expect.equals(tIsDynamic, m1875 is F1875<bool>);
+ Expect.equals(tIsDynamic, confuse(m1875) is F1875<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1875 = (f1875 as dynamic); });
+ Expect.throws(() { x1875 = confuse(f1875); });
+ List<T> Function<A>(int x) Function<B extends core.int>(int x) l1875;
+ Expect.throws(() { l1875 = (f1875 as dynamic); });
+ Expect.throws(() { l1875 = confuse(f1875); });
+ }
+ List<T> Function<A>(int x) Function<B extends core.int>(int x) l1875 = m1875;
+ // In checked mode, verifies the type.
+ x1875 = m1875;
+ x1875 = confuse(m1875);
+ }
+ }
+
+ void testF1975() {
+ // List<A> Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1975 is F1975);
+ Expect.isTrue(confuse(f1975) is F1975);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(Function x) Function<B extends core.int>(int x) l1975;
+ // The static function f1975 sets `T` to `int`.
+ if (!tIsBool) {
+ x1975 = f1975 as dynamic;
+ l1975 = f1975 as dynamic;
+ x1975 = confuse(f1975);
+ l1975 = confuse(f1975);
+ }
+
+ Expect.isTrue(m1975 is F1975);
+ Expect.isTrue(m1975 is List<A> Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1975) is F1975);
+ // In checked mode, verifies the type.
+ x1975 = m1975;
+ l1975 = m1975;
+ x1975 = confuse(m1975);
+ l1975 = confuse(m1975);
+
+ }
+
+
+}
+
+class C76<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, {Function x}) x76;
+ core.List<core.int> Function({int x}) x176;
+ List<T> Function({List<T> x}) x276;
+ Function<A>(int x) x376;
+ int Function({Function x}) Function() x476;
+ int Function(List<T> x) Function() x576;
+ Function Function(int x0, [Function x]) Function() x676;
+ Function Function([core.List<core.int> x1]) Function() x776;
+ List<Function> Function(int x, [int x2]) Function() x876;
+ List<Function> Function(int y, {List<Function> x}) Function() x976;
+ core.List<core.int> Function([int x]) Function() x1076;
+ core.List<core.int> Function(List<Function> x0) Function() x1176;
+ core.List<core.int> Function(int x, [List<T> x2]) Function() x1276;
+ List<T> Function(int x0, {Function x}) Function() x1376;
+ List<T> Function([List<T> x]) Function() x1476;
+ Function(int y, [Function x]) Function() x1576;
+ Function(int x1, [core.List<core.int> x2]) Function() x1676;
+ Function Function<A>(int x) Function() x1776;
+ List<T> Function<A>(Function x) Function() x1876;
+ List<A> Function<A>(List<Function> x) Function() x1976;
+
+
+ C76({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m76(int x0, {Function x}) => null;
+ core.List<core.int> m176({int x}) => null;
+ List<T> m276({List<T> x}) => null;
+ m376<A>(int x) => null;
+ int Function({Function x}) m476() => null;
+ int Function(List<T> x) m576() => null;
+ Function Function(int x0, [Function x]) m676() => null;
+ Function Function([core.List<core.int> x0]) m776() => null;
+ List<Function> Function(int x, [int x0]) m876() => null;
+ List<Function> Function(int y, {List<Function> x}) m976() => null;
+ core.List<core.int> Function([int x]) m1076() => null;
+ core.List<core.int> Function(List<Function> x0) m1176() => null;
+ core.List<core.int> Function(int x, [List<T> x0]) m1276() => null;
+ List<T> Function(int x0, {Function x}) m1376() => null;
+ List<T> Function([List<T> x]) m1476() => null;
+ Function(int y, [Function x]) m1576() => null;
+ Function(int x0, [core.List<core.int> x1]) m1676() => null;
+ Function Function<A>(int x) m1776() => null;
+ List<T> Function<A>(Function x) m1876() => null;
+ List<A> Function<A>(List<Function> x) m1976() => null;
+
+
+ runTests() {
+ testF76();
+ testF176();
+ testF276();
+ testF376();
+ testF476();
+ testF576();
+ testF676();
+ testF776();
+ testF876();
+ testF976();
+ testF1076();
+ testF1176();
+ testF1276();
+ testF1376();
+ testF1476();
+ testF1576();
+ testF1676();
+ testF1776();
+ testF1876();
+ testF1976();
+ }
+
+ void testF76() {
+ // Function Function(int x0, {Function x})
+ Expect.isTrue(f76 is F76);
+ Expect.isTrue(confuse(f76) is F76);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {Function x}) l76;
+ // The static function f76 sets `T` to `int`.
+ if (!tIsBool) {
+ x76 = f76 as dynamic;
+ l76 = f76 as dynamic;
+ x76 = confuse(f76);
+ l76 = confuse(f76);
+ }
+
+ Expect.isTrue(m76 is F76);
+ Expect.isTrue(m76 is Function Function(int x0, {Function x}));
+ Expect.isTrue(confuse(m76) is F76);
+ // In checked mode, verifies the type.
+ x76 = m76;
+ l76 = m76;
+ x76 = confuse(m76);
+ l76 = confuse(m76);
+
+ }
+
+ void testF176() {
+ // core.List<core.int> Function({int x})
+ Expect.isTrue(f176 is F176);
+ Expect.isTrue(confuse(f176) is F176);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({int x}) l176;
+ // The static function f176 sets `T` to `int`.
+ if (!tIsBool) {
+ x176 = f176 as dynamic;
+ l176 = f176 as dynamic;
+ x176 = confuse(f176);
+ l176 = confuse(f176);
+ }
+
+ Expect.isTrue(m176 is F176);
+ Expect.isTrue(m176 is core.List<core.int> Function({int x}));
+ Expect.isTrue(confuse(m176) is F176);
+ // In checked mode, verifies the type.
+ x176 = m176;
+ l176 = m176;
+ x176 = confuse(m176);
+ l176 = confuse(m176);
+
+ }
+
+ void testF276() {
+ // List<T> Function({List<T> x})
+ Expect.isTrue(f276 is F276);
+ Expect.isTrue(confuse(f276) is F276);
+ // In checked mode, verifies the type.
+ List<T> Function({List<T> x}) l276;
+ // The static function f276 sets `T` to `int`.
+ if (!tIsBool) {
+ x276 = f276 as dynamic;
+ l276 = f276 as dynamic;
+ x276 = confuse(f276);
+ l276 = confuse(f276);
+ }
+
+ Expect.isTrue(m276 is F276);
+ Expect.isTrue(m276 is List<T> Function({List<T> x}));
+ Expect.isTrue(confuse(m276) is F276);
+ // In checked mode, verifies the type.
+ x276 = m276;
+ l276 = m276;
+ x276 = confuse(m276);
+ l276 = confuse(m276);
+ if (!tIsBool) {
+ Expect.isTrue(f276 is F276<int>);
+ Expect.isFalse(f276 is F276<bool>);
+ Expect.isTrue(confuse(f276) is F276<int>);
+ Expect.isFalse(confuse(f276) is F276<bool>);
+ Expect.equals(tIsDynamic, m276 is F276<bool>);
+ Expect.equals(tIsDynamic, confuse(m276) is F276<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x276 = (f276 as dynamic); });
+ Expect.throws(() { x276 = confuse(f276); });
+ List<T> Function({List<T> x}) l276;
+ Expect.throws(() { l276 = (f276 as dynamic); });
+ Expect.throws(() { l276 = confuse(f276); });
+ }
+ List<T> Function({List<T> x}) l276 = m276;
+ // In checked mode, verifies the type.
+ x276 = m276;
+ x276 = confuse(m276);
+ }
+ }
+
+ void testF376() {
+ // Function<A>(int x)
+ Expect.isTrue(f376 is F376);
+ Expect.isTrue(confuse(f376) is F376);
+ // In checked mode, verifies the type.
+ Function<A>(int x) l376;
+ // The static function f376 sets `T` to `int`.
+ if (!tIsBool) {
+ x376 = f376 as dynamic;
+ l376 = f376 as dynamic;
+ x376 = confuse(f376);
+ l376 = confuse(f376);
+ }
+
+ Expect.isTrue(m376 is F376);
+ Expect.isTrue(m376 is Function<A>(int x));
+ Expect.isTrue(confuse(m376) is F376);
+ // In checked mode, verifies the type.
+ x376 = m376;
+ l376 = m376;
+ x376 = confuse(m376);
+ l376 = confuse(m376);
+
+ }
+
+ void testF476() {
+ // int Function({Function x}) Function()
+ Expect.isTrue(f476 is F476);
+ Expect.isTrue(confuse(f476) is F476);
+ // In checked mode, verifies the type.
+ int Function({Function x}) Function() l476;
+ // The static function f476 sets `T` to `int`.
+ if (!tIsBool) {
+ x476 = f476 as dynamic;
+ l476 = f476 as dynamic;
+ x476 = confuse(f476);
+ l476 = confuse(f476);
+ }
+
+ Expect.isTrue(m476 is F476);
+ Expect.isTrue(m476 is int Function({Function x}) Function());
+ Expect.isTrue(confuse(m476) is F476);
+ // In checked mode, verifies the type.
+ x476 = m476;
+ l476 = m476;
+ x476 = confuse(m476);
+ l476 = confuse(m476);
+
+ }
+
+ void testF576() {
+ // int Function(List<T> x) Function()
+ Expect.isTrue(f576 is F576);
+ Expect.isTrue(confuse(f576) is F576);
+ // In checked mode, verifies the type.
+ int Function(List<T> x) Function() l576;
+ // The static function f576 sets `T` to `int`.
+ if (!tIsBool) {
+ x576 = f576 as dynamic;
+ l576 = f576 as dynamic;
+ x576 = confuse(f576);
+ l576 = confuse(f576);
+ }
+
+ Expect.isTrue(m576 is F576);
+ Expect.isTrue(m576 is int Function(List<T> x) Function());
+ Expect.isTrue(confuse(m576) is F576);
+ // In checked mode, verifies the type.
+ x576 = m576;
+ l576 = m576;
+ x576 = confuse(m576);
+ l576 = confuse(m576);
+ if (!tIsBool) {
+ Expect.isTrue(f576 is F576<int>);
+ Expect.isFalse(f576 is F576<bool>);
+ Expect.isTrue(confuse(f576) is F576<int>);
+ Expect.isFalse(confuse(f576) is F576<bool>);
+ Expect.equals(tIsDynamic, m576 is F576<bool>);
+ Expect.equals(tIsDynamic, confuse(m576) is F576<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x576 = (f576 as dynamic); });
+ Expect.throws(() { x576 = confuse(f576); });
+ int Function(List<T> x) Function() l576;
+ Expect.throws(() { l576 = (f576 as dynamic); });
+ Expect.throws(() { l576 = confuse(f576); });
+ }
+ int Function(List<T> x) Function() l576 = m576;
+ // In checked mode, verifies the type.
+ x576 = m576;
+ x576 = confuse(m576);
+ }
+ }
+
+ void testF676() {
+ // Function Function(int x0, [Function x]) Function()
+ Expect.isTrue(f676 is F676);
+ Expect.isTrue(confuse(f676) is F676);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [Function x]) Function() l676;
+ // The static function f676 sets `T` to `int`.
+ if (!tIsBool) {
+ x676 = f676 as dynamic;
+ l676 = f676 as dynamic;
+ x676 = confuse(f676);
+ l676 = confuse(f676);
+ }
+
+ Expect.isTrue(m676 is F676);
+ Expect.isTrue(m676 is Function Function(int x0, [Function x]) Function());
+ Expect.isTrue(confuse(m676) is F676);
+ // In checked mode, verifies the type.
+ x676 = m676;
+ l676 = m676;
+ x676 = confuse(m676);
+ l676 = confuse(m676);
+
+ }
+
+ void testF776() {
+ // Function Function([core.List<core.int> x1]) Function()
+ Expect.isTrue(f776 is F776);
+ Expect.isTrue(confuse(f776) is F776);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x1]) Function() l776;
+ // The static function f776 sets `T` to `int`.
+ if (!tIsBool) {
+ x776 = f776 as dynamic;
+ l776 = f776 as dynamic;
+ x776 = confuse(f776);
+ l776 = confuse(f776);
+ }
+
+ Expect.isTrue(m776 is F776);
+ Expect.isTrue(m776 is Function Function([core.List<core.int> x1]) Function());
+ Expect.isTrue(confuse(m776) is F776);
+ // In checked mode, verifies the type.
+ x776 = m776;
+ l776 = m776;
+ x776 = confuse(m776);
+ l776 = confuse(m776);
+
+ }
+
+ void testF876() {
+ // List<Function> Function(int x, [int x2]) Function()
+ Expect.isTrue(f876 is F876);
+ Expect.isTrue(confuse(f876) is F876);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [int x2]) Function() l876;
+ // The static function f876 sets `T` to `int`.
+ if (!tIsBool) {
+ x876 = f876 as dynamic;
+ l876 = f876 as dynamic;
+ x876 = confuse(f876);
+ l876 = confuse(f876);
+ }
+
+ Expect.isTrue(m876 is F876);
+ Expect.isTrue(m876 is List<Function> Function(int x, [int x2]) Function());
+ Expect.isTrue(confuse(m876) is F876);
+ // In checked mode, verifies the type.
+ x876 = m876;
+ l876 = m876;
+ x876 = confuse(m876);
+ l876 = confuse(m876);
+
+ }
+
+ void testF976() {
+ // List<Function> Function(int y, {List<Function> x}) Function()
+ Expect.isTrue(f976 is F976);
+ Expect.isTrue(confuse(f976) is F976);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<Function> x}) Function() l976;
+ // The static function f976 sets `T` to `int`.
+ if (!tIsBool) {
+ x976 = f976 as dynamic;
+ l976 = f976 as dynamic;
+ x976 = confuse(f976);
+ l976 = confuse(f976);
+ }
+
+ Expect.isTrue(m976 is F976);
+ Expect.isTrue(m976 is List<Function> Function(int y, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m976) is F976);
+ // In checked mode, verifies the type.
+ x976 = m976;
+ l976 = m976;
+ x976 = confuse(m976);
+ l976 = confuse(m976);
+
+ }
+
+ void testF1076() {
+ // core.List<core.int> Function([int x]) Function()
+ Expect.isTrue(f1076 is F1076);
+ Expect.isTrue(confuse(f1076) is F1076);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x]) Function() l1076;
+ // The static function f1076 sets `T` to `int`.
+ if (!tIsBool) {
+ x1076 = f1076 as dynamic;
+ l1076 = f1076 as dynamic;
+ x1076 = confuse(f1076);
+ l1076 = confuse(f1076);
+ }
+
+ Expect.isTrue(m1076 is F1076);
+ Expect.isTrue(m1076 is core.List<core.int> Function([int x]) Function());
+ Expect.isTrue(confuse(m1076) is F1076);
+ // In checked mode, verifies the type.
+ x1076 = m1076;
+ l1076 = m1076;
+ x1076 = confuse(m1076);
+ l1076 = confuse(m1076);
+
+ }
+
+ void testF1176() {
+ // core.List<core.int> Function(List<Function> x0) Function()
+ Expect.isTrue(f1176 is F1176);
+ Expect.isTrue(confuse(f1176) is F1176);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x0) Function() l1176;
+ // The static function f1176 sets `T` to `int`.
+ if (!tIsBool) {
+ x1176 = f1176 as dynamic;
+ l1176 = f1176 as dynamic;
+ x1176 = confuse(f1176);
+ l1176 = confuse(f1176);
+ }
+
+ Expect.isTrue(m1176 is F1176);
+ Expect.isTrue(m1176 is core.List<core.int> Function(List<Function> x0) Function());
+ Expect.isTrue(confuse(m1176) is F1176);
+ // In checked mode, verifies the type.
+ x1176 = m1176;
+ l1176 = m1176;
+ x1176 = confuse(m1176);
+ l1176 = confuse(m1176);
+
+ }
+
+ void testF1276() {
+ // core.List<core.int> Function(int x, [List<T> x2]) Function()
+ Expect.isTrue(f1276 is F1276);
+ Expect.isTrue(confuse(f1276) is F1276);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<T> x2]) Function() l1276;
+ // The static function f1276 sets `T` to `int`.
+ if (!tIsBool) {
+ x1276 = f1276 as dynamic;
+ l1276 = f1276 as dynamic;
+ x1276 = confuse(f1276);
+ l1276 = confuse(f1276);
+ }
+
+ Expect.isTrue(m1276 is F1276);
+ Expect.isTrue(m1276 is core.List<core.int> Function(int x, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1276) is F1276);
+ // In checked mode, verifies the type.
+ x1276 = m1276;
+ l1276 = m1276;
+ x1276 = confuse(m1276);
+ l1276 = confuse(m1276);
+ if (!tIsBool) {
+ Expect.isTrue(f1276 is F1276<int>);
+ Expect.isFalse(f1276 is F1276<bool>);
+ Expect.isTrue(confuse(f1276) is F1276<int>);
+ Expect.isFalse(confuse(f1276) is F1276<bool>);
+ Expect.equals(tIsDynamic, m1276 is F1276<bool>);
+ Expect.equals(tIsDynamic, confuse(m1276) is F1276<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1276 = (f1276 as dynamic); });
+ Expect.throws(() { x1276 = confuse(f1276); });
+ core.List<core.int> Function(int x, [List<T> x2]) Function() l1276;
+ Expect.throws(() { l1276 = (f1276 as dynamic); });
+ Expect.throws(() { l1276 = confuse(f1276); });
+ }
+ core.List<core.int> Function(int x, [List<T> x2]) Function() l1276 = m1276;
+ // In checked mode, verifies the type.
+ x1276 = m1276;
+ x1276 = confuse(m1276);
+ }
+ }
+
+ void testF1376() {
+ // List<T> Function(int x0, {Function x}) Function()
+ Expect.isTrue(f1376 is F1376);
+ Expect.isTrue(confuse(f1376) is F1376);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {Function x}) Function() l1376;
+ // The static function f1376 sets `T` to `int`.
+ if (!tIsBool) {
+ x1376 = f1376 as dynamic;
+ l1376 = f1376 as dynamic;
+ x1376 = confuse(f1376);
+ l1376 = confuse(f1376);
+ }
+
+ Expect.isTrue(m1376 is F1376);
+ Expect.isTrue(m1376 is List<T> Function(int x0, {Function x}) Function());
+ Expect.isTrue(confuse(m1376) is F1376);
+ // In checked mode, verifies the type.
+ x1376 = m1376;
+ l1376 = m1376;
+ x1376 = confuse(m1376);
+ l1376 = confuse(m1376);
+ if (!tIsBool) {
+ Expect.isTrue(f1376 is F1376<int>);
+ Expect.isFalse(f1376 is F1376<bool>);
+ Expect.isTrue(confuse(f1376) is F1376<int>);
+ Expect.isFalse(confuse(f1376) is F1376<bool>);
+ Expect.equals(tIsDynamic, m1376 is F1376<bool>);
+ Expect.equals(tIsDynamic, confuse(m1376) is F1376<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1376 = (f1376 as dynamic); });
+ Expect.throws(() { x1376 = confuse(f1376); });
+ List<T> Function(int x0, {Function x}) Function() l1376;
+ Expect.throws(() { l1376 = (f1376 as dynamic); });
+ Expect.throws(() { l1376 = confuse(f1376); });
+ }
+ List<T> Function(int x0, {Function x}) Function() l1376 = m1376;
+ // In checked mode, verifies the type.
+ x1376 = m1376;
+ x1376 = confuse(m1376);
+ }
+ }
+
+ void testF1476() {
+ // List<T> Function([List<T> x]) Function()
+ Expect.isTrue(f1476 is F1476);
+ Expect.isTrue(confuse(f1476) is F1476);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x]) Function() l1476;
+ // The static function f1476 sets `T` to `int`.
+ if (!tIsBool) {
+ x1476 = f1476 as dynamic;
+ l1476 = f1476 as dynamic;
+ x1476 = confuse(f1476);
+ l1476 = confuse(f1476);
+ }
+
+ Expect.isTrue(m1476 is F1476);
+ Expect.isTrue(m1476 is List<T> Function([List<T> x]) Function());
+ Expect.isTrue(confuse(m1476) is F1476);
+ // In checked mode, verifies the type.
+ x1476 = m1476;
+ l1476 = m1476;
+ x1476 = confuse(m1476);
+ l1476 = confuse(m1476);
+ if (!tIsBool) {
+ Expect.isTrue(f1476 is F1476<int>);
+ Expect.isFalse(f1476 is F1476<bool>);
+ Expect.isTrue(confuse(f1476) is F1476<int>);
+ Expect.isFalse(confuse(f1476) is F1476<bool>);
+ Expect.equals(tIsDynamic, m1476 is F1476<bool>);
+ Expect.equals(tIsDynamic, confuse(m1476) is F1476<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1476 = (f1476 as dynamic); });
+ Expect.throws(() { x1476 = confuse(f1476); });
+ List<T> Function([List<T> x]) Function() l1476;
+ Expect.throws(() { l1476 = (f1476 as dynamic); });
+ Expect.throws(() { l1476 = confuse(f1476); });
+ }
+ List<T> Function([List<T> x]) Function() l1476 = m1476;
+ // In checked mode, verifies the type.
+ x1476 = m1476;
+ x1476 = confuse(m1476);
+ }
+ }
+
+ void testF1576() {
+ // Function(int y, [Function x]) Function()
+ Expect.isTrue(f1576 is F1576);
+ Expect.isTrue(confuse(f1576) is F1576);
+ // In checked mode, verifies the type.
+ Function(int y, [Function x]) Function() l1576;
+ // The static function f1576 sets `T` to `int`.
+ if (!tIsBool) {
+ x1576 = f1576 as dynamic;
+ l1576 = f1576 as dynamic;
+ x1576 = confuse(f1576);
+ l1576 = confuse(f1576);
+ }
+
+ Expect.isTrue(m1576 is F1576);
+ Expect.isTrue(m1576 is Function(int y, [Function x]) Function());
+ Expect.isTrue(confuse(m1576) is F1576);
+ // In checked mode, verifies the type.
+ x1576 = m1576;
+ l1576 = m1576;
+ x1576 = confuse(m1576);
+ l1576 = confuse(m1576);
+
+ }
+
+ void testF1676() {
+ // Function(int x1, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1676 is F1676);
+ Expect.isTrue(confuse(f1676) is F1676);
+ // In checked mode, verifies the type.
+ Function(int x1, [core.List<core.int> x2]) Function() l1676;
+ // The static function f1676 sets `T` to `int`.
+ if (!tIsBool) {
+ x1676 = f1676 as dynamic;
+ l1676 = f1676 as dynamic;
+ x1676 = confuse(f1676);
+ l1676 = confuse(f1676);
+ }
+
+ Expect.isTrue(m1676 is F1676);
+ Expect.isTrue(m1676 is Function(int x1, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1676) is F1676);
+ // In checked mode, verifies the type.
+ x1676 = m1676;
+ l1676 = m1676;
+ x1676 = confuse(m1676);
+ l1676 = confuse(m1676);
+
+ }
+
+ void testF1776() {
+ // Function Function<A>(int x) Function()
+ Expect.isTrue(f1776 is F1776);
+ Expect.isTrue(confuse(f1776) is F1776);
+ // In checked mode, verifies the type.
+ Function Function<A>(int x) Function() l1776;
+ // The static function f1776 sets `T` to `int`.
+ if (!tIsBool) {
+ x1776 = f1776 as dynamic;
+ l1776 = f1776 as dynamic;
+ x1776 = confuse(f1776);
+ l1776 = confuse(f1776);
+ }
+
+ Expect.isTrue(m1776 is F1776);
+ Expect.isTrue(m1776 is Function Function<A>(int x) Function());
+ Expect.isTrue(confuse(m1776) is F1776);
+ // In checked mode, verifies the type.
+ x1776 = m1776;
+ l1776 = m1776;
+ x1776 = confuse(m1776);
+ l1776 = confuse(m1776);
+
+ }
+
+ void testF1876() {
+ // List<T> Function<A>(Function x) Function()
+ Expect.isTrue(f1876 is F1876);
+ Expect.isTrue(confuse(f1876) is F1876);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(Function x) Function() l1876;
+ // The static function f1876 sets `T` to `int`.
+ if (!tIsBool) {
+ x1876 = f1876 as dynamic;
+ l1876 = f1876 as dynamic;
+ x1876 = confuse(f1876);
+ l1876 = confuse(f1876);
+ }
+
+ Expect.isTrue(m1876 is F1876);
+ Expect.isTrue(m1876 is List<T> Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1876) is F1876);
+ // In checked mode, verifies the type.
+ x1876 = m1876;
+ l1876 = m1876;
+ x1876 = confuse(m1876);
+ l1876 = confuse(m1876);
+ if (!tIsBool) {
+ Expect.isTrue(f1876 is F1876<int>);
+ Expect.isFalse(f1876 is F1876<bool>);
+ Expect.isTrue(confuse(f1876) is F1876<int>);
+ Expect.isFalse(confuse(f1876) is F1876<bool>);
+ Expect.equals(tIsDynamic, m1876 is F1876<bool>);
+ Expect.equals(tIsDynamic, confuse(m1876) is F1876<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1876 = (f1876 as dynamic); });
+ Expect.throws(() { x1876 = confuse(f1876); });
+ List<T> Function<A>(Function x) Function() l1876;
+ Expect.throws(() { l1876 = (f1876 as dynamic); });
+ Expect.throws(() { l1876 = confuse(f1876); });
+ }
+ List<T> Function<A>(Function x) Function() l1876 = m1876;
+ // In checked mode, verifies the type.
+ x1876 = m1876;
+ x1876 = confuse(m1876);
+ }
+ }
+
+ void testF1976() {
+ // List<A> Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1976 is F1976);
+ Expect.isTrue(confuse(f1976) is F1976);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<Function> x) Function() l1976;
+ // The static function f1976 sets `T` to `int`.
+ if (!tIsBool) {
+ x1976 = f1976 as dynamic;
+ l1976 = f1976 as dynamic;
+ x1976 = confuse(f1976);
+ l1976 = confuse(f1976);
+ }
+
+ Expect.isTrue(m1976 is F1976);
+ Expect.isTrue(m1976 is List<A> Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1976) is F1976);
+ // In checked mode, verifies the type.
+ x1976 = m1976;
+ l1976 = m1976;
+ x1976 = confuse(m1976);
+ l1976 = confuse(m1976);
+
+ }
+
+
+}
+
+class C77<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, {Function x}) x77;
+ core.List<core.int> Function(int x0, {int x}) x177;
+ List<T> Function(int x0, {List<T> x}) x277;
+ Function<A>(Function x) x377;
+ int Function({Function x}) Function(int x) x477;
+ int Function(List<T> x) Function(int x) x577;
+ Function Function(int x1, [Function x]) Function(int x) x677;
+ Function Function([core.List<core.int> x1]) Function(int x) x777;
+ List<Function> Function(int x, [int x1]) Function(int x) x877;
+ List<Function> Function(int y, {List<Function> x}) Function(int x) x977;
+ core.List<core.int> Function([int x]) Function(int x) x1077;
+ core.List<core.int> Function(List<Function> x1) Function(int x) x1177;
+ core.List<core.int> Function(int x, [List<T> x1]) Function(int x) x1277;
+ List<T> Function(int x1, {Function x}) Function(int x) x1377;
+ List<T> Function([List<T> x]) Function(int x) x1477;
+ Function(int y, [Function x]) Function(int x) x1577;
+ Function(int x2, [core.List<core.int> x3]) Function(int x) x1677;
+ Function Function<A>(int x) Function(int x) x1777;
+ List<T> Function<A>(Function x) Function(int x) x1877;
+ List<A> Function<A>(List<Function> x) Function(int x) x1977;
+
+
+ C77({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m77(int y, {Function x}) => null;
+ core.List<core.int> m177(int x0, {int x}) => null;
+ List<T> m277(int x0, {List<T> x}) => null;
+ m377<A>(Function x) => null;
+ int Function({Function x}) m477(int x) => null;
+ int Function(List<T> x) m577(int x) => null;
+ Function Function(int x0, [Function x]) m677(int x) => null;
+ Function Function([core.List<core.int> x0]) m777(int x) => null;
+ List<Function> Function(int x, [int x0]) m877(int x) => null;
+ List<Function> Function(int y, {List<Function> x}) m977(int x) => null;
+ core.List<core.int> Function([int x]) m1077(int x) => null;
+ core.List<core.int> Function(List<Function> x0) m1177(int x) => null;
+ core.List<core.int> Function(int x, [List<T> x0]) m1277(int x) => null;
+ List<T> Function(int x0, {Function x}) m1377(int x) => null;
+ List<T> Function([List<T> x]) m1477(int x) => null;
+ Function(int y, [Function x]) m1577(int x) => null;
+ Function(int x0, [core.List<core.int> x1]) m1677(int x) => null;
+ Function Function<A>(int x) m1777(int x) => null;
+ List<T> Function<A>(Function x) m1877(int x) => null;
+ List<A> Function<A>(List<Function> x) m1977(int x) => null;
+
+
+ runTests() {
+ testF77();
+ testF177();
+ testF277();
+ testF377();
+ testF477();
+ testF577();
+ testF677();
+ testF777();
+ testF877();
+ testF977();
+ testF1077();
+ testF1177();
+ testF1277();
+ testF1377();
+ testF1477();
+ testF1577();
+ testF1677();
+ testF1777();
+ testF1877();
+ testF1977();
+ }
+
+ void testF77() {
+ // Function Function(int y, {Function x})
+ Expect.isTrue(f77 is F77);
+ Expect.isTrue(confuse(f77) is F77);
+ // In checked mode, verifies the type.
+ Function Function(int y, {Function x}) l77;
+ // The static function f77 sets `T` to `int`.
+ if (!tIsBool) {
+ x77 = f77 as dynamic;
+ l77 = f77 as dynamic;
+ x77 = confuse(f77);
+ l77 = confuse(f77);
+ }
+
+ Expect.isTrue(m77 is F77);
+ Expect.isTrue(m77 is Function Function(int y, {Function x}));
+ Expect.isTrue(confuse(m77) is F77);
+ // In checked mode, verifies the type.
+ x77 = m77;
+ l77 = m77;
+ x77 = confuse(m77);
+ l77 = confuse(m77);
+
+ }
+
+ void testF177() {
+ // core.List<core.int> Function(int x0, {int x})
+ Expect.isTrue(f177 is F177);
+ Expect.isTrue(confuse(f177) is F177);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {int x}) l177;
+ // The static function f177 sets `T` to `int`.
+ if (!tIsBool) {
+ x177 = f177 as dynamic;
+ l177 = f177 as dynamic;
+ x177 = confuse(f177);
+ l177 = confuse(f177);
+ }
+
+ Expect.isTrue(m177 is F177);
+ Expect.isTrue(m177 is core.List<core.int> Function(int x0, {int x}));
+ Expect.isTrue(confuse(m177) is F177);
+ // In checked mode, verifies the type.
+ x177 = m177;
+ l177 = m177;
+ x177 = confuse(m177);
+ l177 = confuse(m177);
+
+ }
+
+ void testF277() {
+ // List<T> Function(int x0, {List<T> x})
+ Expect.isTrue(f277 is F277);
+ Expect.isTrue(confuse(f277) is F277);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, {List<T> x}) l277;
+ // The static function f277 sets `T` to `int`.
+ if (!tIsBool) {
+ x277 = f277 as dynamic;
+ l277 = f277 as dynamic;
+ x277 = confuse(f277);
+ l277 = confuse(f277);
+ }
+
+ Expect.isTrue(m277 is F277);
+ Expect.isTrue(m277 is List<T> Function(int x0, {List<T> x}));
+ Expect.isTrue(confuse(m277) is F277);
+ // In checked mode, verifies the type.
+ x277 = m277;
+ l277 = m277;
+ x277 = confuse(m277);
+ l277 = confuse(m277);
+ if (!tIsBool) {
+ Expect.isTrue(f277 is F277<int>);
+ Expect.isFalse(f277 is F277<bool>);
+ Expect.isTrue(confuse(f277) is F277<int>);
+ Expect.isFalse(confuse(f277) is F277<bool>);
+ Expect.equals(tIsDynamic, m277 is F277<bool>);
+ Expect.equals(tIsDynamic, confuse(m277) is F277<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x277 = (f277 as dynamic); });
+ Expect.throws(() { x277 = confuse(f277); });
+ List<T> Function(int x0, {List<T> x}) l277;
+ Expect.throws(() { l277 = (f277 as dynamic); });
+ Expect.throws(() { l277 = confuse(f277); });
+ }
+ List<T> Function(int x0, {List<T> x}) l277 = m277;
+ // In checked mode, verifies the type.
+ x277 = m277;
+ x277 = confuse(m277);
+ }
+ }
+
+ void testF377() {
+ // Function<A>(Function x)
+ Expect.isTrue(f377 is F377);
+ Expect.isTrue(confuse(f377) is F377);
+ // In checked mode, verifies the type.
+ Function<A>(Function x) l377;
+ // The static function f377 sets `T` to `int`.
+ if (!tIsBool) {
+ x377 = f377 as dynamic;
+ l377 = f377 as dynamic;
+ x377 = confuse(f377);
+ l377 = confuse(f377);
+ }
+
+ Expect.isTrue(m377 is F377);
+ Expect.isTrue(m377 is Function<A>(Function x));
+ Expect.isTrue(confuse(m377) is F377);
+ // In checked mode, verifies the type.
+ x377 = m377;
+ l377 = m377;
+ x377 = confuse(m377);
+ l377 = confuse(m377);
+
+ }
+
+ void testF477() {
+ // int Function({Function x}) Function(int x)
+ Expect.isTrue(f477 is F477);
+ Expect.isTrue(confuse(f477) is F477);
+ // In checked mode, verifies the type.
+ int Function({Function x}) Function(int x) l477;
+ // The static function f477 sets `T` to `int`.
+ if (!tIsBool) {
+ x477 = f477 as dynamic;
+ l477 = f477 as dynamic;
+ x477 = confuse(f477);
+ l477 = confuse(f477);
+ }
+
+ Expect.isTrue(m477 is F477);
+ Expect.isTrue(m477 is int Function({Function x}) Function(int x));
+ Expect.isTrue(confuse(m477) is F477);
+ // In checked mode, verifies the type.
+ x477 = m477;
+ l477 = m477;
+ x477 = confuse(m477);
+ l477 = confuse(m477);
+
+ }
+
+ void testF577() {
+ // int Function(List<T> x) Function(int x)
+ Expect.isTrue(f577 is F577);
+ Expect.isTrue(confuse(f577) is F577);
+ // In checked mode, verifies the type.
+ int Function(List<T> x) Function(int x) l577;
+ // The static function f577 sets `T` to `int`.
+ if (!tIsBool) {
+ x577 = f577 as dynamic;
+ l577 = f577 as dynamic;
+ x577 = confuse(f577);
+ l577 = confuse(f577);
+ }
+
+ Expect.isTrue(m577 is F577);
+ Expect.isTrue(m577 is int Function(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m577) is F577);
+ // In checked mode, verifies the type.
+ x577 = m577;
+ l577 = m577;
+ x577 = confuse(m577);
+ l577 = confuse(m577);
+ if (!tIsBool) {
+ Expect.isTrue(f577 is F577<int>);
+ Expect.isFalse(f577 is F577<bool>);
+ Expect.isTrue(confuse(f577) is F577<int>);
+ Expect.isFalse(confuse(f577) is F577<bool>);
+ Expect.equals(tIsDynamic, m577 is F577<bool>);
+ Expect.equals(tIsDynamic, confuse(m577) is F577<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x577 = (f577 as dynamic); });
+ Expect.throws(() { x577 = confuse(f577); });
+ int Function(List<T> x) Function(int x) l577;
+ Expect.throws(() { l577 = (f577 as dynamic); });
+ Expect.throws(() { l577 = confuse(f577); });
+ }
+ int Function(List<T> x) Function(int x) l577 = m577;
+ // In checked mode, verifies the type.
+ x577 = m577;
+ x577 = confuse(m577);
+ }
+ }
+
+ void testF677() {
+ // Function Function(int x1, [Function x]) Function(int x)
+ Expect.isTrue(f677 is F677);
+ Expect.isTrue(confuse(f677) is F677);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [Function x]) Function(int x) l677;
+ // The static function f677 sets `T` to `int`.
+ if (!tIsBool) {
+ x677 = f677 as dynamic;
+ l677 = f677 as dynamic;
+ x677 = confuse(f677);
+ l677 = confuse(f677);
+ }
+
+ Expect.isTrue(m677 is F677);
+ Expect.isTrue(m677 is Function Function(int x1, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m677) is F677);
+ // In checked mode, verifies the type.
+ x677 = m677;
+ l677 = m677;
+ x677 = confuse(m677);
+ l677 = confuse(m677);
+
+ }
+
+ void testF777() {
+ // Function Function([core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f777 is F777);
+ Expect.isTrue(confuse(f777) is F777);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x1]) Function(int x) l777;
+ // The static function f777 sets `T` to `int`.
+ if (!tIsBool) {
+ x777 = f777 as dynamic;
+ l777 = f777 as dynamic;
+ x777 = confuse(f777);
+ l777 = confuse(f777);
+ }
+
+ Expect.isTrue(m777 is F777);
+ Expect.isTrue(m777 is Function Function([core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m777) is F777);
+ // In checked mode, verifies the type.
+ x777 = m777;
+ l777 = m777;
+ x777 = confuse(m777);
+ l777 = confuse(m777);
+
+ }
+
+ void testF877() {
+ // List<Function> Function(int x, [int x1]) Function(int x)
+ Expect.isTrue(f877 is F877);
+ Expect.isTrue(confuse(f877) is F877);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [int x1]) Function(int x) l877;
+ // The static function f877 sets `T` to `int`.
+ if (!tIsBool) {
+ x877 = f877 as dynamic;
+ l877 = f877 as dynamic;
+ x877 = confuse(f877);
+ l877 = confuse(f877);
+ }
+
+ Expect.isTrue(m877 is F877);
+ Expect.isTrue(m877 is List<Function> Function(int x, [int x1]) Function(int x));
+ Expect.isTrue(confuse(m877) is F877);
+ // In checked mode, verifies the type.
+ x877 = m877;
+ l877 = m877;
+ x877 = confuse(m877);
+ l877 = confuse(m877);
+
+ }
+
+ void testF977() {
+ // List<Function> Function(int y, {List<Function> x}) Function(int x)
+ Expect.isTrue(f977 is F977);
+ Expect.isTrue(confuse(f977) is F977);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<Function> x}) Function(int x) l977;
+ // The static function f977 sets `T` to `int`.
+ if (!tIsBool) {
+ x977 = f977 as dynamic;
+ l977 = f977 as dynamic;
+ x977 = confuse(f977);
+ l977 = confuse(f977);
+ }
+
+ Expect.isTrue(m977 is F977);
+ Expect.isTrue(m977 is List<Function> Function(int y, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m977) is F977);
+ // In checked mode, verifies the type.
+ x977 = m977;
+ l977 = m977;
+ x977 = confuse(m977);
+ l977 = confuse(m977);
+
+ }
+
+ void testF1077() {
+ // core.List<core.int> Function([int x]) Function(int x)
+ Expect.isTrue(f1077 is F1077);
+ Expect.isTrue(confuse(f1077) is F1077);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x]) Function(int x) l1077;
+ // The static function f1077 sets `T` to `int`.
+ if (!tIsBool) {
+ x1077 = f1077 as dynamic;
+ l1077 = f1077 as dynamic;
+ x1077 = confuse(f1077);
+ l1077 = confuse(f1077);
+ }
+
+ Expect.isTrue(m1077 is F1077);
+ Expect.isTrue(m1077 is core.List<core.int> Function([int x]) Function(int x));
+ Expect.isTrue(confuse(m1077) is F1077);
+ // In checked mode, verifies the type.
+ x1077 = m1077;
+ l1077 = m1077;
+ x1077 = confuse(m1077);
+ l1077 = confuse(m1077);
+
+ }
+
+ void testF1177() {
+ // core.List<core.int> Function(List<Function> x1) Function(int x)
+ Expect.isTrue(f1177 is F1177);
+ Expect.isTrue(confuse(f1177) is F1177);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x1) Function(int x) l1177;
+ // The static function f1177 sets `T` to `int`.
+ if (!tIsBool) {
+ x1177 = f1177 as dynamic;
+ l1177 = f1177 as dynamic;
+ x1177 = confuse(f1177);
+ l1177 = confuse(f1177);
+ }
+
+ Expect.isTrue(m1177 is F1177);
+ Expect.isTrue(m1177 is core.List<core.int> Function(List<Function> x1) Function(int x));
+ Expect.isTrue(confuse(m1177) is F1177);
+ // In checked mode, verifies the type.
+ x1177 = m1177;
+ l1177 = m1177;
+ x1177 = confuse(m1177);
+ l1177 = confuse(m1177);
+
+ }
+
+ void testF1277() {
+ // core.List<core.int> Function(int x, [List<T> x1]) Function(int x)
+ Expect.isTrue(f1277 is F1277);
+ Expect.isTrue(confuse(f1277) is F1277);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<T> x1]) Function(int x) l1277;
+ // The static function f1277 sets `T` to `int`.
+ if (!tIsBool) {
+ x1277 = f1277 as dynamic;
+ l1277 = f1277 as dynamic;
+ x1277 = confuse(f1277);
+ l1277 = confuse(f1277);
+ }
+
+ Expect.isTrue(m1277 is F1277);
+ Expect.isTrue(m1277 is core.List<core.int> Function(int x, [List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1277) is F1277);
+ // In checked mode, verifies the type.
+ x1277 = m1277;
+ l1277 = m1277;
+ x1277 = confuse(m1277);
+ l1277 = confuse(m1277);
+ if (!tIsBool) {
+ Expect.isTrue(f1277 is F1277<int>);
+ Expect.isFalse(f1277 is F1277<bool>);
+ Expect.isTrue(confuse(f1277) is F1277<int>);
+ Expect.isFalse(confuse(f1277) is F1277<bool>);
+ Expect.equals(tIsDynamic, m1277 is F1277<bool>);
+ Expect.equals(tIsDynamic, confuse(m1277) is F1277<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1277 = (f1277 as dynamic); });
+ Expect.throws(() { x1277 = confuse(f1277); });
+ core.List<core.int> Function(int x, [List<T> x1]) Function(int x) l1277;
+ Expect.throws(() { l1277 = (f1277 as dynamic); });
+ Expect.throws(() { l1277 = confuse(f1277); });
+ }
+ core.List<core.int> Function(int x, [List<T> x1]) Function(int x) l1277 = m1277;
+ // In checked mode, verifies the type.
+ x1277 = m1277;
+ x1277 = confuse(m1277);
+ }
+ }
+
+ void testF1377() {
+ // List<T> Function(int x1, {Function x}) Function(int x)
+ Expect.isTrue(f1377 is F1377);
+ Expect.isTrue(confuse(f1377) is F1377);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {Function x}) Function(int x) l1377;
+ // The static function f1377 sets `T` to `int`.
+ if (!tIsBool) {
+ x1377 = f1377 as dynamic;
+ l1377 = f1377 as dynamic;
+ x1377 = confuse(f1377);
+ l1377 = confuse(f1377);
+ }
+
+ Expect.isTrue(m1377 is F1377);
+ Expect.isTrue(m1377 is List<T> Function(int x1, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m1377) is F1377);
+ // In checked mode, verifies the type.
+ x1377 = m1377;
+ l1377 = m1377;
+ x1377 = confuse(m1377);
+ l1377 = confuse(m1377);
+ if (!tIsBool) {
+ Expect.isTrue(f1377 is F1377<int>);
+ Expect.isFalse(f1377 is F1377<bool>);
+ Expect.isTrue(confuse(f1377) is F1377<int>);
+ Expect.isFalse(confuse(f1377) is F1377<bool>);
+ Expect.equals(tIsDynamic, m1377 is F1377<bool>);
+ Expect.equals(tIsDynamic, confuse(m1377) is F1377<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1377 = (f1377 as dynamic); });
+ Expect.throws(() { x1377 = confuse(f1377); });
+ List<T> Function(int x1, {Function x}) Function(int x) l1377;
+ Expect.throws(() { l1377 = (f1377 as dynamic); });
+ Expect.throws(() { l1377 = confuse(f1377); });
+ }
+ List<T> Function(int x1, {Function x}) Function(int x) l1377 = m1377;
+ // In checked mode, verifies the type.
+ x1377 = m1377;
+ x1377 = confuse(m1377);
+ }
+ }
+
+ void testF1477() {
+ // List<T> Function([List<T> x]) Function(int x)
+ Expect.isTrue(f1477 is F1477);
+ Expect.isTrue(confuse(f1477) is F1477);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x]) Function(int x) l1477;
+ // The static function f1477 sets `T` to `int`.
+ if (!tIsBool) {
+ x1477 = f1477 as dynamic;
+ l1477 = f1477 as dynamic;
+ x1477 = confuse(f1477);
+ l1477 = confuse(f1477);
+ }
+
+ Expect.isTrue(m1477 is F1477);
+ Expect.isTrue(m1477 is List<T> Function([List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1477) is F1477);
+ // In checked mode, verifies the type.
+ x1477 = m1477;
+ l1477 = m1477;
+ x1477 = confuse(m1477);
+ l1477 = confuse(m1477);
+ if (!tIsBool) {
+ Expect.isTrue(f1477 is F1477<int>);
+ Expect.isFalse(f1477 is F1477<bool>);
+ Expect.isTrue(confuse(f1477) is F1477<int>);
+ Expect.isFalse(confuse(f1477) is F1477<bool>);
+ Expect.equals(tIsDynamic, m1477 is F1477<bool>);
+ Expect.equals(tIsDynamic, confuse(m1477) is F1477<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1477 = (f1477 as dynamic); });
+ Expect.throws(() { x1477 = confuse(f1477); });
+ List<T> Function([List<T> x]) Function(int x) l1477;
+ Expect.throws(() { l1477 = (f1477 as dynamic); });
+ Expect.throws(() { l1477 = confuse(f1477); });
+ }
+ List<T> Function([List<T> x]) Function(int x) l1477 = m1477;
+ // In checked mode, verifies the type.
+ x1477 = m1477;
+ x1477 = confuse(m1477);
+ }
+ }
+
+ void testF1577() {
+ // Function(int y, [Function x]) Function(int x)
+ Expect.isTrue(f1577 is F1577);
+ Expect.isTrue(confuse(f1577) is F1577);
+ // In checked mode, verifies the type.
+ Function(int y, [Function x]) Function(int x) l1577;
+ // The static function f1577 sets `T` to `int`.
+ if (!tIsBool) {
+ x1577 = f1577 as dynamic;
+ l1577 = f1577 as dynamic;
+ x1577 = confuse(f1577);
+ l1577 = confuse(f1577);
+ }
+
+ Expect.isTrue(m1577 is F1577);
+ Expect.isTrue(m1577 is Function(int y, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m1577) is F1577);
+ // In checked mode, verifies the type.
+ x1577 = m1577;
+ l1577 = m1577;
+ x1577 = confuse(m1577);
+ l1577 = confuse(m1577);
+
+ }
+
+ void testF1677() {
+ // Function(int x2, [core.List<core.int> x3]) Function(int x)
+ Expect.isTrue(f1677 is F1677);
+ Expect.isTrue(confuse(f1677) is F1677);
+ // In checked mode, verifies the type.
+ Function(int x2, [core.List<core.int> x3]) Function(int x) l1677;
+ // The static function f1677 sets `T` to `int`.
+ if (!tIsBool) {
+ x1677 = f1677 as dynamic;
+ l1677 = f1677 as dynamic;
+ x1677 = confuse(f1677);
+ l1677 = confuse(f1677);
+ }
+
+ Expect.isTrue(m1677 is F1677);
+ Expect.isTrue(m1677 is Function(int x2, [core.List<core.int> x3]) Function(int x));
+ Expect.isTrue(confuse(m1677) is F1677);
+ // In checked mode, verifies the type.
+ x1677 = m1677;
+ l1677 = m1677;
+ x1677 = confuse(m1677);
+ l1677 = confuse(m1677);
+
+ }
+
+ void testF1777() {
+ // Function Function<A>(int x) Function(int x)
+ Expect.isTrue(f1777 is F1777);
+ Expect.isTrue(confuse(f1777) is F1777);
+ // In checked mode, verifies the type.
+ Function Function<A>(int x) Function(int x) l1777;
+ // The static function f1777 sets `T` to `int`.
+ if (!tIsBool) {
+ x1777 = f1777 as dynamic;
+ l1777 = f1777 as dynamic;
+ x1777 = confuse(f1777);
+ l1777 = confuse(f1777);
+ }
+
+ Expect.isTrue(m1777 is F1777);
+ Expect.isTrue(m1777 is Function Function<A>(int x) Function(int x));
+ Expect.isTrue(confuse(m1777) is F1777);
+ // In checked mode, verifies the type.
+ x1777 = m1777;
+ l1777 = m1777;
+ x1777 = confuse(m1777);
+ l1777 = confuse(m1777);
+
+ }
+
+ void testF1877() {
+ // List<T> Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1877 is F1877);
+ Expect.isTrue(confuse(f1877) is F1877);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(Function x) Function(int x) l1877;
+ // The static function f1877 sets `T` to `int`.
+ if (!tIsBool) {
+ x1877 = f1877 as dynamic;
+ l1877 = f1877 as dynamic;
+ x1877 = confuse(f1877);
+ l1877 = confuse(f1877);
+ }
+
+ Expect.isTrue(m1877 is F1877);
+ Expect.isTrue(m1877 is List<T> Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1877) is F1877);
+ // In checked mode, verifies the type.
+ x1877 = m1877;
+ l1877 = m1877;
+ x1877 = confuse(m1877);
+ l1877 = confuse(m1877);
+ if (!tIsBool) {
+ Expect.isTrue(f1877 is F1877<int>);
+ Expect.isFalse(f1877 is F1877<bool>);
+ Expect.isTrue(confuse(f1877) is F1877<int>);
+ Expect.isFalse(confuse(f1877) is F1877<bool>);
+ Expect.equals(tIsDynamic, m1877 is F1877<bool>);
+ Expect.equals(tIsDynamic, confuse(m1877) is F1877<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1877 = (f1877 as dynamic); });
+ Expect.throws(() { x1877 = confuse(f1877); });
+ List<T> Function<A>(Function x) Function(int x) l1877;
+ Expect.throws(() { l1877 = (f1877 as dynamic); });
+ Expect.throws(() { l1877 = confuse(f1877); });
+ }
+ List<T> Function<A>(Function x) Function(int x) l1877 = m1877;
+ // In checked mode, verifies the type.
+ x1877 = m1877;
+ x1877 = confuse(m1877);
+ }
+ }
+
+ void testF1977() {
+ // List<A> Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1977 is F1977);
+ Expect.isTrue(confuse(f1977) is F1977);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<Function> x) Function(int x) l1977;
+ // The static function f1977 sets `T` to `int`.
+ if (!tIsBool) {
+ x1977 = f1977 as dynamic;
+ l1977 = f1977 as dynamic;
+ x1977 = confuse(f1977);
+ l1977 = confuse(f1977);
+ }
+
+ Expect.isTrue(m1977 is F1977);
+ Expect.isTrue(m1977 is List<A> Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1977) is F1977);
+ // In checked mode, verifies the type.
+ x1977 = m1977;
+ l1977 = m1977;
+ x1977 = confuse(m1977);
+ l1977 = confuse(m1977);
+
+ }
+
+
+}
+
+class C78<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(List<Function> x) x78;
+ core.List<core.int> Function(int y, {int x}) x178;
+ List<T> Function(int y, {List<T> x}) x278;
+ Function<A>(List<Function> x) x378;
+ int Function({Function x}) Function<B extends core.int>() x478;
+ int Function(List<T> x) Function<B extends core.int>() x578;
+ Function Function(int x1, [Function x]) Function<B extends core.int>() x678;
+ Function Function([core.List<core.int> x1]) Function<B extends core.int>() x778;
+ List<Function> Function(int x, [int x1]) Function<B extends core.int>() x878;
+ List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>() x978;
+ core.List<core.int> Function([int x]) Function<B extends core.int>() x1078;
+ core.List<core.int> Function(List<Function> x1) Function<B extends core.int>() x1178;
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>() x1278;
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>() x1378;
+ List<T> Function([List<T> x]) Function<B extends core.int>() x1478;
+ Function(int y, [Function x]) Function<B extends core.int>() x1578;
+ Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() x1678;
+ Function Function<A>(int x) Function<B extends core.int>() x1778;
+ List<T> Function<A>(Function x) Function<B extends core.int>() x1878;
+ List<A> Function<A>(List<Function> x) Function<B extends core.int>() x1978;
+
+
+ C78({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m78(List<Function> x) => null;
+ core.List<core.int> m178(int y, {int x}) => null;
+ List<T> m278(int y, {List<T> x}) => null;
+ m378<A>(List<Function> x) => null;
+ int Function({Function x}) m478<B extends core.int>() => null;
+ int Function(List<T> x) m578<B extends core.int>() => null;
+ Function Function(int x0, [Function x]) m678<B extends core.int>() => null;
+ Function Function([core.List<core.int> x0]) m778<B extends core.int>() => null;
+ List<Function> Function(int x, [int x0]) m878<B extends core.int>() => null;
+ List<Function> Function(int y, {List<Function> x}) m978<B extends core.int>() => null;
+ core.List<core.int> Function([int x]) m1078<B extends core.int>() => null;
+ core.List<core.int> Function(List<Function> x0) m1178<B extends core.int>() => null;
+ core.List<core.int> Function(int x, [List<T> x0]) m1278<B extends core.int>() => null;
+ List<T> Function(int x0, {Function x}) m1378<B extends core.int>() => null;
+ List<T> Function([List<T> x]) m1478<B extends core.int>() => null;
+ Function(int y, [Function x]) m1578<B extends core.int>() => null;
+ Function(int x0, [core.List<core.int> x1]) m1678<B extends core.int>() => null;
+ Function Function<A>(int x) m1778<B extends core.int>() => null;
+ List<T> Function<A>(Function x) m1878<B extends core.int>() => null;
+ List<A> Function<A>(List<Function> x) m1978<B extends core.int>() => null;
+
+
+ runTests() {
+ testF78();
+ testF178();
+ testF278();
+ testF378();
+ testF478();
+ testF578();
+ testF678();
+ testF778();
+ testF878();
+ testF978();
+ testF1078();
+ testF1178();
+ testF1278();
+ testF1378();
+ testF1478();
+ testF1578();
+ testF1678();
+ testF1778();
+ testF1878();
+ testF1978();
+ }
+
+ void testF78() {
+ // Function Function(List<Function> x)
+ Expect.isTrue(f78 is F78);
+ Expect.isTrue(confuse(f78) is F78);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x) l78;
+ // The static function f78 sets `T` to `int`.
+ if (!tIsBool) {
+ x78 = f78 as dynamic;
+ l78 = f78 as dynamic;
+ x78 = confuse(f78);
+ l78 = confuse(f78);
+ }
+
+ Expect.isTrue(m78 is F78);
+ Expect.isTrue(m78 is Function Function(List<Function> x));
+ Expect.isTrue(confuse(m78) is F78);
+ // In checked mode, verifies the type.
+ x78 = m78;
+ l78 = m78;
+ x78 = confuse(m78);
+ l78 = confuse(m78);
+
+ }
+
+ void testF178() {
+ // core.List<core.int> Function(int y, {int x})
+ Expect.isTrue(f178 is F178);
+ Expect.isTrue(confuse(f178) is F178);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {int x}) l178;
+ // The static function f178 sets `T` to `int`.
+ if (!tIsBool) {
+ x178 = f178 as dynamic;
+ l178 = f178 as dynamic;
+ x178 = confuse(f178);
+ l178 = confuse(f178);
+ }
+
+ Expect.isTrue(m178 is F178);
+ Expect.isTrue(m178 is core.List<core.int> Function(int y, {int x}));
+ Expect.isTrue(confuse(m178) is F178);
+ // In checked mode, verifies the type.
+ x178 = m178;
+ l178 = m178;
+ x178 = confuse(m178);
+ l178 = confuse(m178);
+
+ }
+
+ void testF278() {
+ // List<T> Function(int y, {List<T> x})
+ Expect.isTrue(f278 is F278);
+ Expect.isTrue(confuse(f278) is F278);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {List<T> x}) l278;
+ // The static function f278 sets `T` to `int`.
+ if (!tIsBool) {
+ x278 = f278 as dynamic;
+ l278 = f278 as dynamic;
+ x278 = confuse(f278);
+ l278 = confuse(f278);
+ }
+
+ Expect.isTrue(m278 is F278);
+ Expect.isTrue(m278 is List<T> Function(int y, {List<T> x}));
+ Expect.isTrue(confuse(m278) is F278);
+ // In checked mode, verifies the type.
+ x278 = m278;
+ l278 = m278;
+ x278 = confuse(m278);
+ l278 = confuse(m278);
+ if (!tIsBool) {
+ Expect.isTrue(f278 is F278<int>);
+ Expect.isFalse(f278 is F278<bool>);
+ Expect.isTrue(confuse(f278) is F278<int>);
+ Expect.isFalse(confuse(f278) is F278<bool>);
+ Expect.equals(tIsDynamic, m278 is F278<bool>);
+ Expect.equals(tIsDynamic, confuse(m278) is F278<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x278 = (f278 as dynamic); });
+ Expect.throws(() { x278 = confuse(f278); });
+ List<T> Function(int y, {List<T> x}) l278;
+ Expect.throws(() { l278 = (f278 as dynamic); });
+ Expect.throws(() { l278 = confuse(f278); });
+ }
+ List<T> Function(int y, {List<T> x}) l278 = m278;
+ // In checked mode, verifies the type.
+ x278 = m278;
+ x278 = confuse(m278);
+ }
+ }
+
+ void testF378() {
+ // Function<A>(List<Function> x)
+ Expect.isTrue(f378 is F378);
+ Expect.isTrue(confuse(f378) is F378);
+ // In checked mode, verifies the type.
+ Function<A>(List<Function> x) l378;
+ // The static function f378 sets `T` to `int`.
+ if (!tIsBool) {
+ x378 = f378 as dynamic;
+ l378 = f378 as dynamic;
+ x378 = confuse(f378);
+ l378 = confuse(f378);
+ }
+
+ Expect.isTrue(m378 is F378);
+ Expect.isTrue(m378 is Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m378) is F378);
+ // In checked mode, verifies the type.
+ x378 = m378;
+ l378 = m378;
+ x378 = confuse(m378);
+ l378 = confuse(m378);
+
+ }
+
+ void testF478() {
+ // int Function({Function x}) Function<B extends core.int>()
+ Expect.isTrue(f478 is F478);
+ Expect.isTrue(confuse(f478) is F478);
+ // In checked mode, verifies the type.
+ int Function({Function x}) Function<B extends core.int>() l478;
+ // The static function f478 sets `T` to `int`.
+ if (!tIsBool) {
+ x478 = f478 as dynamic;
+ l478 = f478 as dynamic;
+ x478 = confuse(f478);
+ l478 = confuse(f478);
+ }
+
+ Expect.isTrue(m478 is F478);
+ Expect.isTrue(m478 is int Function({Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m478) is F478);
+ // In checked mode, verifies the type.
+ x478 = m478;
+ l478 = m478;
+ x478 = confuse(m478);
+ l478 = confuse(m478);
+
+ }
+
+ void testF578() {
+ // int Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f578 is F578);
+ Expect.isTrue(confuse(f578) is F578);
+ // In checked mode, verifies the type.
+ int Function(List<T> x) Function<B extends core.int>() l578;
+ // The static function f578 sets `T` to `int`.
+ if (!tIsBool) {
+ x578 = f578 as dynamic;
+ l578 = f578 as dynamic;
+ x578 = confuse(f578);
+ l578 = confuse(f578);
+ }
+
+ Expect.isTrue(m578 is F578);
+ Expect.isTrue(m578 is int Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m578) is F578);
+ // In checked mode, verifies the type.
+ x578 = m578;
+ l578 = m578;
+ x578 = confuse(m578);
+ l578 = confuse(m578);
+ if (!tIsBool) {
+ Expect.isTrue(f578 is F578<int>);
+ Expect.isFalse(f578 is F578<bool>);
+ Expect.isTrue(confuse(f578) is F578<int>);
+ Expect.isFalse(confuse(f578) is F578<bool>);
+ Expect.equals(tIsDynamic, m578 is F578<bool>);
+ Expect.equals(tIsDynamic, confuse(m578) is F578<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x578 = (f578 as dynamic); });
+ Expect.throws(() { x578 = confuse(f578); });
+ int Function(List<T> x) Function<B extends core.int>() l578;
+ Expect.throws(() { l578 = (f578 as dynamic); });
+ Expect.throws(() { l578 = confuse(f578); });
+ }
+ int Function(List<T> x) Function<B extends core.int>() l578 = m578;
+ // In checked mode, verifies the type.
+ x578 = m578;
+ x578 = confuse(m578);
+ }
+ }
+
+ void testF678() {
+ // Function Function(int x1, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f678 is F678);
+ Expect.isTrue(confuse(f678) is F678);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [Function x]) Function<B extends core.int>() l678;
+ // The static function f678 sets `T` to `int`.
+ if (!tIsBool) {
+ x678 = f678 as dynamic;
+ l678 = f678 as dynamic;
+ x678 = confuse(f678);
+ l678 = confuse(f678);
+ }
+
+ Expect.isTrue(m678 is F678);
+ Expect.isTrue(m678 is Function Function(int x1, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m678) is F678);
+ // In checked mode, verifies the type.
+ x678 = m678;
+ l678 = m678;
+ x678 = confuse(m678);
+ l678 = confuse(m678);
+
+ }
+
+ void testF778() {
+ // Function Function([core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f778 is F778);
+ Expect.isTrue(confuse(f778) is F778);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x1]) Function<B extends core.int>() l778;
+ // The static function f778 sets `T` to `int`.
+ if (!tIsBool) {
+ x778 = f778 as dynamic;
+ l778 = f778 as dynamic;
+ x778 = confuse(f778);
+ l778 = confuse(f778);
+ }
+
+ Expect.isTrue(m778 is F778);
+ Expect.isTrue(m778 is Function Function([core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m778) is F778);
+ // In checked mode, verifies the type.
+ x778 = m778;
+ l778 = m778;
+ x778 = confuse(m778);
+ l778 = confuse(m778);
+
+ }
+
+ void testF878() {
+ // List<Function> Function(int x, [int x1]) Function<B extends core.int>()
+ Expect.isTrue(f878 is F878);
+ Expect.isTrue(confuse(f878) is F878);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [int x1]) Function<B extends core.int>() l878;
+ // The static function f878 sets `T` to `int`.
+ if (!tIsBool) {
+ x878 = f878 as dynamic;
+ l878 = f878 as dynamic;
+ x878 = confuse(f878);
+ l878 = confuse(f878);
+ }
+
+ Expect.isTrue(m878 is F878);
+ Expect.isTrue(m878 is List<Function> Function(int x, [int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m878) is F878);
+ // In checked mode, verifies the type.
+ x878 = m878;
+ l878 = m878;
+ x878 = confuse(m878);
+ l878 = confuse(m878);
+
+ }
+
+ void testF978() {
+ // List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f978 is F978);
+ Expect.isTrue(confuse(f978) is F978);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>() l978;
+ // The static function f978 sets `T` to `int`.
+ if (!tIsBool) {
+ x978 = f978 as dynamic;
+ l978 = f978 as dynamic;
+ x978 = confuse(f978);
+ l978 = confuse(f978);
+ }
+
+ Expect.isTrue(m978 is F978);
+ Expect.isTrue(m978 is List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m978) is F978);
+ // In checked mode, verifies the type.
+ x978 = m978;
+ l978 = m978;
+ x978 = confuse(m978);
+ l978 = confuse(m978);
+
+ }
+
+ void testF1078() {
+ // core.List<core.int> Function([int x]) Function<B extends core.int>()
+ Expect.isTrue(f1078 is F1078);
+ Expect.isTrue(confuse(f1078) is F1078);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x]) Function<B extends core.int>() l1078;
+ // The static function f1078 sets `T` to `int`.
+ if (!tIsBool) {
+ x1078 = f1078 as dynamic;
+ l1078 = f1078 as dynamic;
+ x1078 = confuse(f1078);
+ l1078 = confuse(f1078);
+ }
+
+ Expect.isTrue(m1078 is F1078);
+ Expect.isTrue(m1078 is core.List<core.int> Function([int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1078) is F1078);
+ // In checked mode, verifies the type.
+ x1078 = m1078;
+ l1078 = m1078;
+ x1078 = confuse(m1078);
+ l1078 = confuse(m1078);
+
+ }
+
+ void testF1178() {
+ // core.List<core.int> Function(List<Function> x1) Function<B extends core.int>()
+ Expect.isTrue(f1178 is F1178);
+ Expect.isTrue(confuse(f1178) is F1178);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x1) Function<B extends core.int>() l1178;
+ // The static function f1178 sets `T` to `int`.
+ if (!tIsBool) {
+ x1178 = f1178 as dynamic;
+ l1178 = f1178 as dynamic;
+ x1178 = confuse(f1178);
+ l1178 = confuse(f1178);
+ }
+
+ Expect.isTrue(m1178 is F1178);
+ Expect.isTrue(m1178 is core.List<core.int> Function(List<Function> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1178) is F1178);
+ // In checked mode, verifies the type.
+ x1178 = m1178;
+ l1178 = m1178;
+ x1178 = confuse(m1178);
+ l1178 = confuse(m1178);
+
+ }
+
+ void testF1278() {
+ // core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1278 is F1278);
+ Expect.isTrue(confuse(f1278) is F1278);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>() l1278;
+ // The static function f1278 sets `T` to `int`.
+ if (!tIsBool) {
+ x1278 = f1278 as dynamic;
+ l1278 = f1278 as dynamic;
+ x1278 = confuse(f1278);
+ l1278 = confuse(f1278);
+ }
+
+ Expect.isTrue(m1278 is F1278);
+ Expect.isTrue(m1278 is core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1278) is F1278);
+ // In checked mode, verifies the type.
+ x1278 = m1278;
+ l1278 = m1278;
+ x1278 = confuse(m1278);
+ l1278 = confuse(m1278);
+ if (!tIsBool) {
+ Expect.isTrue(f1278 is F1278<int>);
+ Expect.isFalse(f1278 is F1278<bool>);
+ Expect.isTrue(confuse(f1278) is F1278<int>);
+ Expect.isFalse(confuse(f1278) is F1278<bool>);
+ Expect.equals(tIsDynamic, m1278 is F1278<bool>);
+ Expect.equals(tIsDynamic, confuse(m1278) is F1278<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1278 = (f1278 as dynamic); });
+ Expect.throws(() { x1278 = confuse(f1278); });
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>() l1278;
+ Expect.throws(() { l1278 = (f1278 as dynamic); });
+ Expect.throws(() { l1278 = confuse(f1278); });
+ }
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>() l1278 = m1278;
+ // In checked mode, verifies the type.
+ x1278 = m1278;
+ x1278 = confuse(m1278);
+ }
+ }
+
+ void testF1378() {
+ // List<T> Function(int x1, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1378 is F1378);
+ Expect.isTrue(confuse(f1378) is F1378);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>() l1378;
+ // The static function f1378 sets `T` to `int`.
+ if (!tIsBool) {
+ x1378 = f1378 as dynamic;
+ l1378 = f1378 as dynamic;
+ x1378 = confuse(f1378);
+ l1378 = confuse(f1378);
+ }
+
+ Expect.isTrue(m1378 is F1378);
+ Expect.isTrue(m1378 is List<T> Function(int x1, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1378) is F1378);
+ // In checked mode, verifies the type.
+ x1378 = m1378;
+ l1378 = m1378;
+ x1378 = confuse(m1378);
+ l1378 = confuse(m1378);
+ if (!tIsBool) {
+ Expect.isTrue(f1378 is F1378<int>);
+ Expect.isFalse(f1378 is F1378<bool>);
+ Expect.isTrue(confuse(f1378) is F1378<int>);
+ Expect.isFalse(confuse(f1378) is F1378<bool>);
+ Expect.equals(tIsDynamic, m1378 is F1378<bool>);
+ Expect.equals(tIsDynamic, confuse(m1378) is F1378<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1378 = (f1378 as dynamic); });
+ Expect.throws(() { x1378 = confuse(f1378); });
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>() l1378;
+ Expect.throws(() { l1378 = (f1378 as dynamic); });
+ Expect.throws(() { l1378 = confuse(f1378); });
+ }
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>() l1378 = m1378;
+ // In checked mode, verifies the type.
+ x1378 = m1378;
+ x1378 = confuse(m1378);
+ }
+ }
+
+ void testF1478() {
+ // List<T> Function([List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1478 is F1478);
+ Expect.isTrue(confuse(f1478) is F1478);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x]) Function<B extends core.int>() l1478;
+ // The static function f1478 sets `T` to `int`.
+ if (!tIsBool) {
+ x1478 = f1478 as dynamic;
+ l1478 = f1478 as dynamic;
+ x1478 = confuse(f1478);
+ l1478 = confuse(f1478);
+ }
+
+ Expect.isTrue(m1478 is F1478);
+ Expect.isTrue(m1478 is List<T> Function([List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1478) is F1478);
+ // In checked mode, verifies the type.
+ x1478 = m1478;
+ l1478 = m1478;
+ x1478 = confuse(m1478);
+ l1478 = confuse(m1478);
+ if (!tIsBool) {
+ Expect.isTrue(f1478 is F1478<int>);
+ Expect.isFalse(f1478 is F1478<bool>);
+ Expect.isTrue(confuse(f1478) is F1478<int>);
+ Expect.isFalse(confuse(f1478) is F1478<bool>);
+ Expect.equals(tIsDynamic, m1478 is F1478<bool>);
+ Expect.equals(tIsDynamic, confuse(m1478) is F1478<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1478 = (f1478 as dynamic); });
+ Expect.throws(() { x1478 = confuse(f1478); });
+ List<T> Function([List<T> x]) Function<B extends core.int>() l1478;
+ Expect.throws(() { l1478 = (f1478 as dynamic); });
+ Expect.throws(() { l1478 = confuse(f1478); });
+ }
+ List<T> Function([List<T> x]) Function<B extends core.int>() l1478 = m1478;
+ // In checked mode, verifies the type.
+ x1478 = m1478;
+ x1478 = confuse(m1478);
+ }
+ }
+
+ void testF1578() {
+ // Function(int y, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f1578 is F1578);
+ Expect.isTrue(confuse(f1578) is F1578);
+ // In checked mode, verifies the type.
+ Function(int y, [Function x]) Function<B extends core.int>() l1578;
+ // The static function f1578 sets `T` to `int`.
+ if (!tIsBool) {
+ x1578 = f1578 as dynamic;
+ l1578 = f1578 as dynamic;
+ x1578 = confuse(f1578);
+ l1578 = confuse(f1578);
+ }
+
+ Expect.isTrue(m1578 is F1578);
+ Expect.isTrue(m1578 is Function(int y, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1578) is F1578);
+ // In checked mode, verifies the type.
+ x1578 = m1578;
+ l1578 = m1578;
+ x1578 = confuse(m1578);
+ l1578 = confuse(m1578);
+
+ }
+
+ void testF1678() {
+ // Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1678 is F1678);
+ Expect.isTrue(confuse(f1678) is F1678);
+ // In checked mode, verifies the type.
+ Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l1678;
+ // The static function f1678 sets `T` to `int`.
+ if (!tIsBool) {
+ x1678 = f1678 as dynamic;
+ l1678 = f1678 as dynamic;
+ x1678 = confuse(f1678);
+ l1678 = confuse(f1678);
+ }
+
+ Expect.isTrue(m1678 is F1678);
+ Expect.isTrue(m1678 is Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1678) is F1678);
+ // In checked mode, verifies the type.
+ x1678 = m1678;
+ l1678 = m1678;
+ x1678 = confuse(m1678);
+ l1678 = confuse(m1678);
+
+ }
+
+ void testF1778() {
+ // Function Function<A>(int x) Function<B extends core.int>()
+ Expect.isTrue(f1778 is F1778);
+ Expect.isTrue(confuse(f1778) is F1778);
+ // In checked mode, verifies the type.
+ Function Function<A>(int x) Function<B extends core.int>() l1778;
+ // The static function f1778 sets `T` to `int`.
+ if (!tIsBool) {
+ x1778 = f1778 as dynamic;
+ l1778 = f1778 as dynamic;
+ x1778 = confuse(f1778);
+ l1778 = confuse(f1778);
+ }
+
+ Expect.isTrue(m1778 is F1778);
+ Expect.isTrue(m1778 is Function Function<A>(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1778) is F1778);
+ // In checked mode, verifies the type.
+ x1778 = m1778;
+ l1778 = m1778;
+ x1778 = confuse(m1778);
+ l1778 = confuse(m1778);
+
+ }
+
+ void testF1878() {
+ // List<T> Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1878 is F1878);
+ Expect.isTrue(confuse(f1878) is F1878);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(Function x) Function<B extends core.int>() l1878;
+ // The static function f1878 sets `T` to `int`.
+ if (!tIsBool) {
+ x1878 = f1878 as dynamic;
+ l1878 = f1878 as dynamic;
+ x1878 = confuse(f1878);
+ l1878 = confuse(f1878);
+ }
+
+ Expect.isTrue(m1878 is F1878);
+ Expect.isTrue(m1878 is List<T> Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1878) is F1878);
+ // In checked mode, verifies the type.
+ x1878 = m1878;
+ l1878 = m1878;
+ x1878 = confuse(m1878);
+ l1878 = confuse(m1878);
+ if (!tIsBool) {
+ Expect.isTrue(f1878 is F1878<int>);
+ Expect.isFalse(f1878 is F1878<bool>);
+ Expect.isTrue(confuse(f1878) is F1878<int>);
+ Expect.isFalse(confuse(f1878) is F1878<bool>);
+ Expect.equals(tIsDynamic, m1878 is F1878<bool>);
+ Expect.equals(tIsDynamic, confuse(m1878) is F1878<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1878 = (f1878 as dynamic); });
+ Expect.throws(() { x1878 = confuse(f1878); });
+ List<T> Function<A>(Function x) Function<B extends core.int>() l1878;
+ Expect.throws(() { l1878 = (f1878 as dynamic); });
+ Expect.throws(() { l1878 = confuse(f1878); });
+ }
+ List<T> Function<A>(Function x) Function<B extends core.int>() l1878 = m1878;
+ // In checked mode, verifies the type.
+ x1878 = m1878;
+ x1878 = confuse(m1878);
+ }
+ }
+
+ void testF1978() {
+ // List<A> Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1978 is F1978);
+ Expect.isTrue(confuse(f1978) is F1978);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<Function> x) Function<B extends core.int>() l1978;
+ // The static function f1978 sets `T` to `int`.
+ if (!tIsBool) {
+ x1978 = f1978 as dynamic;
+ l1978 = f1978 as dynamic;
+ x1978 = confuse(f1978);
+ l1978 = confuse(f1978);
+ }
+
+ Expect.isTrue(m1978 is F1978);
+ Expect.isTrue(m1978 is List<A> Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1978) is F1978);
+ // In checked mode, verifies the type.
+ x1978 = m1978;
+ l1978 = m1978;
+ x1978 = confuse(m1978);
+ l1978 = confuse(m1978);
+
+ }
+
+
+}
+
+class C79<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([List<Function> x]) x79;
+ core.List<core.int> Function(Function x) x179;
+ List<T> Function() x279;
+ Function<A>(core.List<core.int> x) x379;
+ int Function({Function x}) Function<B extends core.int>(int x) x479;
+ int Function(List<T> x) Function<B extends core.int>(int x) x579;
+ Function Function(int x1, [Function x]) Function<B extends core.int>(int x) x679;
+ Function Function([core.List<core.int> x1]) Function<B extends core.int>(int x) x779;
+ List<Function> Function(int x, [int x1]) Function<B extends core.int>(int x) x879;
+ List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) x979;
+ core.List<core.int> Function([int x]) Function<B extends core.int>(int x) x1079;
+ core.List<core.int> Function(List<Function> x1) Function<B extends core.int>(int x) x1179;
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) x1279;
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x) x1379;
+ List<T> Function([List<T> x]) Function<B extends core.int>(int x) x1479;
+ Function(int y, [Function x]) Function<B extends core.int>(int x) x1579;
+ Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) x1679;
+ Function Function<A>(int x) Function<B extends core.int>(int x) x1779;
+ List<T> Function<A>(Function x) Function<B extends core.int>(int x) x1879;
+ List<A> Function<A>(List<Function> x) Function<B extends core.int>(int x) x1979;
+
+
+ C79({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m79([List<Function> x]) => null;
+ core.List<core.int> m179(Function x) => null;
+ List<T> m279() => null;
+ m379<A>(core.List<core.int> x) => null;
+ int Function({Function x}) m479<B extends core.int>(int x) => null;
+ int Function(List<T> x) m579<B extends core.int>(int x) => null;
+ Function Function(int x0, [Function x]) m679<B extends core.int>(int x) => null;
+ Function Function([core.List<core.int> x0]) m779<B extends core.int>(int x) => null;
+ List<Function> Function(int x, [int x0]) m879<B extends core.int>(int x) => null;
+ List<Function> Function(int y, {List<Function> x}) m979<B extends core.int>(int x) => null;
+ core.List<core.int> Function([int x]) m1079<B extends core.int>(int x) => null;
+ core.List<core.int> Function(List<Function> x0) m1179<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x, [List<T> x0]) m1279<B extends core.int>(int x) => null;
+ List<T> Function(int x0, {Function x}) m1379<B extends core.int>(int x) => null;
+ List<T> Function([List<T> x]) m1479<B extends core.int>(int x) => null;
+ Function(int y, [Function x]) m1579<B extends core.int>(int x) => null;
+ Function(int x0, [core.List<core.int> x1]) m1679<B extends core.int>(int x) => null;
+ Function Function<A>(int x) m1779<B extends core.int>(int x) => null;
+ List<T> Function<A>(Function x) m1879<B extends core.int>(int x) => null;
+ List<A> Function<A>(List<Function> x) m1979<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF79();
+ testF179();
+ testF279();
+ testF379();
+ testF479();
+ testF579();
+ testF679();
+ testF779();
+ testF879();
+ testF979();
+ testF1079();
+ testF1179();
+ testF1279();
+ testF1379();
+ testF1479();
+ testF1579();
+ testF1679();
+ testF1779();
+ testF1879();
+ testF1979();
+ }
+
+ void testF79() {
+ // Function Function([List<Function> x])
+ Expect.isTrue(f79 is F79);
+ Expect.isTrue(confuse(f79) is F79);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x]) l79;
+ // The static function f79 sets `T` to `int`.
+ if (!tIsBool) {
+ x79 = f79 as dynamic;
+ l79 = f79 as dynamic;
+ x79 = confuse(f79);
+ l79 = confuse(f79);
+ }
+
+ Expect.isTrue(m79 is F79);
+ Expect.isTrue(m79 is Function Function([List<Function> x]));
+ Expect.isTrue(confuse(m79) is F79);
+ // In checked mode, verifies the type.
+ x79 = m79;
+ l79 = m79;
+ x79 = confuse(m79);
+ l79 = confuse(m79);
+
+ }
+
+ void testF179() {
+ // core.List<core.int> Function(Function x)
+ Expect.isTrue(f179 is F179);
+ Expect.isTrue(confuse(f179) is F179);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x) l179;
+ // The static function f179 sets `T` to `int`.
+ if (!tIsBool) {
+ x179 = f179 as dynamic;
+ l179 = f179 as dynamic;
+ x179 = confuse(f179);
+ l179 = confuse(f179);
+ }
+
+ Expect.isTrue(m179 is F179);
+ Expect.isTrue(m179 is core.List<core.int> Function(Function x));
+ Expect.isTrue(confuse(m179) is F179);
+ // In checked mode, verifies the type.
+ x179 = m179;
+ l179 = m179;
+ x179 = confuse(m179);
+ l179 = confuse(m179);
+
+ }
+
+ void testF279() {
+ // List<T> Function()
+ Expect.isTrue(f279 is F279);
+ Expect.isTrue(confuse(f279) is F279);
+ // In checked mode, verifies the type.
+ List<T> Function() l279;
+ // The static function f279 sets `T` to `int`.
+ if (!tIsBool) {
+ x279 = f279 as dynamic;
+ l279 = f279 as dynamic;
+ x279 = confuse(f279);
+ l279 = confuse(f279);
+ }
+
+ Expect.isTrue(m279 is F279);
+ Expect.isTrue(m279 is List<T> Function());
+ Expect.isTrue(confuse(m279) is F279);
+ // In checked mode, verifies the type.
+ x279 = m279;
+ l279 = m279;
+ x279 = confuse(m279);
+ l279 = confuse(m279);
+ if (!tIsBool) {
+ Expect.isTrue(f279 is F279<int>);
+ Expect.isFalse(f279 is F279<bool>);
+ Expect.isTrue(confuse(f279) is F279<int>);
+ Expect.isFalse(confuse(f279) is F279<bool>);
+ Expect.equals(tIsDynamic, m279 is F279<bool>);
+ Expect.equals(tIsDynamic, confuse(m279) is F279<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x279 = (f279 as dynamic); });
+ Expect.throws(() { x279 = confuse(f279); });
+ List<T> Function() l279;
+ Expect.throws(() { l279 = (f279 as dynamic); });
+ Expect.throws(() { l279 = confuse(f279); });
+ }
+ List<T> Function() l279 = m279;
+ // In checked mode, verifies the type.
+ x279 = m279;
+ x279 = confuse(m279);
+ }
+ }
+
+ void testF379() {
+ // Function<A>(core.List<core.int> x)
+ Expect.isTrue(f379 is F379);
+ Expect.isTrue(confuse(f379) is F379);
+ // In checked mode, verifies the type.
+ Function<A>(core.List<core.int> x) l379;
+ // The static function f379 sets `T` to `int`.
+ if (!tIsBool) {
+ x379 = f379 as dynamic;
+ l379 = f379 as dynamic;
+ x379 = confuse(f379);
+ l379 = confuse(f379);
+ }
+
+ Expect.isTrue(m379 is F379);
+ Expect.isTrue(m379 is Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m379) is F379);
+ // In checked mode, verifies the type.
+ x379 = m379;
+ l379 = m379;
+ x379 = confuse(m379);
+ l379 = confuse(m379);
+
+ }
+
+ void testF479() {
+ // int Function({Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f479 is F479);
+ Expect.isTrue(confuse(f479) is F479);
+ // In checked mode, verifies the type.
+ int Function({Function x}) Function<B extends core.int>(int x) l479;
+ // The static function f479 sets `T` to `int`.
+ if (!tIsBool) {
+ x479 = f479 as dynamic;
+ l479 = f479 as dynamic;
+ x479 = confuse(f479);
+ l479 = confuse(f479);
+ }
+
+ Expect.isTrue(m479 is F479);
+ Expect.isTrue(m479 is int Function({Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m479) is F479);
+ // In checked mode, verifies the type.
+ x479 = m479;
+ l479 = m479;
+ x479 = confuse(m479);
+ l479 = confuse(m479);
+
+ }
+
+ void testF579() {
+ // int Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f579 is F579);
+ Expect.isTrue(confuse(f579) is F579);
+ // In checked mode, verifies the type.
+ int Function(List<T> x) Function<B extends core.int>(int x) l579;
+ // The static function f579 sets `T` to `int`.
+ if (!tIsBool) {
+ x579 = f579 as dynamic;
+ l579 = f579 as dynamic;
+ x579 = confuse(f579);
+ l579 = confuse(f579);
+ }
+
+ Expect.isTrue(m579 is F579);
+ Expect.isTrue(m579 is int Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m579) is F579);
+ // In checked mode, verifies the type.
+ x579 = m579;
+ l579 = m579;
+ x579 = confuse(m579);
+ l579 = confuse(m579);
+ if (!tIsBool) {
+ Expect.isTrue(f579 is F579<int>);
+ Expect.isFalse(f579 is F579<bool>);
+ Expect.isTrue(confuse(f579) is F579<int>);
+ Expect.isFalse(confuse(f579) is F579<bool>);
+ Expect.equals(tIsDynamic, m579 is F579<bool>);
+ Expect.equals(tIsDynamic, confuse(m579) is F579<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x579 = (f579 as dynamic); });
+ Expect.throws(() { x579 = confuse(f579); });
+ int Function(List<T> x) Function<B extends core.int>(int x) l579;
+ Expect.throws(() { l579 = (f579 as dynamic); });
+ Expect.throws(() { l579 = confuse(f579); });
+ }
+ int Function(List<T> x) Function<B extends core.int>(int x) l579 = m579;
+ // In checked mode, verifies the type.
+ x579 = m579;
+ x579 = confuse(m579);
+ }
+ }
+
+ void testF679() {
+ // Function Function(int x1, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f679 is F679);
+ Expect.isTrue(confuse(f679) is F679);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [Function x]) Function<B extends core.int>(int x) l679;
+ // The static function f679 sets `T` to `int`.
+ if (!tIsBool) {
+ x679 = f679 as dynamic;
+ l679 = f679 as dynamic;
+ x679 = confuse(f679);
+ l679 = confuse(f679);
+ }
+
+ Expect.isTrue(m679 is F679);
+ Expect.isTrue(m679 is Function Function(int x1, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m679) is F679);
+ // In checked mode, verifies the type.
+ x679 = m679;
+ l679 = m679;
+ x679 = confuse(m679);
+ l679 = confuse(m679);
+
+ }
+
+ void testF779() {
+ // Function Function([core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f779 is F779);
+ Expect.isTrue(confuse(f779) is F779);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x1]) Function<B extends core.int>(int x) l779;
+ // The static function f779 sets `T` to `int`.
+ if (!tIsBool) {
+ x779 = f779 as dynamic;
+ l779 = f779 as dynamic;
+ x779 = confuse(f779);
+ l779 = confuse(f779);
+ }
+
+ Expect.isTrue(m779 is F779);
+ Expect.isTrue(m779 is Function Function([core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m779) is F779);
+ // In checked mode, verifies the type.
+ x779 = m779;
+ l779 = m779;
+ x779 = confuse(m779);
+ l779 = confuse(m779);
+
+ }
+
+ void testF879() {
+ // List<Function> Function(int x, [int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f879 is F879);
+ Expect.isTrue(confuse(f879) is F879);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x, [int x1]) Function<B extends core.int>(int x) l879;
+ // The static function f879 sets `T` to `int`.
+ if (!tIsBool) {
+ x879 = f879 as dynamic;
+ l879 = f879 as dynamic;
+ x879 = confuse(f879);
+ l879 = confuse(f879);
+ }
+
+ Expect.isTrue(m879 is F879);
+ Expect.isTrue(m879 is List<Function> Function(int x, [int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m879) is F879);
+ // In checked mode, verifies the type.
+ x879 = m879;
+ l879 = m879;
+ x879 = confuse(m879);
+ l879 = confuse(m879);
+
+ }
+
+ void testF979() {
+ // List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f979 is F979);
+ Expect.isTrue(confuse(f979) is F979);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>(int x) l979;
+ // The static function f979 sets `T` to `int`.
+ if (!tIsBool) {
+ x979 = f979 as dynamic;
+ l979 = f979 as dynamic;
+ x979 = confuse(f979);
+ l979 = confuse(f979);
+ }
+
+ Expect.isTrue(m979 is F979);
+ Expect.isTrue(m979 is List<Function> Function(int y, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m979) is F979);
+ // In checked mode, verifies the type.
+ x979 = m979;
+ l979 = m979;
+ x979 = confuse(m979);
+ l979 = confuse(m979);
+
+ }
+
+ void testF1079() {
+ // core.List<core.int> Function([int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1079 is F1079);
+ Expect.isTrue(confuse(f1079) is F1079);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x]) Function<B extends core.int>(int x) l1079;
+ // The static function f1079 sets `T` to `int`.
+ if (!tIsBool) {
+ x1079 = f1079 as dynamic;
+ l1079 = f1079 as dynamic;
+ x1079 = confuse(f1079);
+ l1079 = confuse(f1079);
+ }
+
+ Expect.isTrue(m1079 is F1079);
+ Expect.isTrue(m1079 is core.List<core.int> Function([int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1079) is F1079);
+ // In checked mode, verifies the type.
+ x1079 = m1079;
+ l1079 = m1079;
+ x1079 = confuse(m1079);
+ l1079 = confuse(m1079);
+
+ }
+
+ void testF1179() {
+ // core.List<core.int> Function(List<Function> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1179 is F1179);
+ Expect.isTrue(confuse(f1179) is F1179);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x1) Function<B extends core.int>(int x) l1179;
+ // The static function f1179 sets `T` to `int`.
+ if (!tIsBool) {
+ x1179 = f1179 as dynamic;
+ l1179 = f1179 as dynamic;
+ x1179 = confuse(f1179);
+ l1179 = confuse(f1179);
+ }
+
+ Expect.isTrue(m1179 is F1179);
+ Expect.isTrue(m1179 is core.List<core.int> Function(List<Function> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1179) is F1179);
+ // In checked mode, verifies the type.
+ x1179 = m1179;
+ l1179 = m1179;
+ x1179 = confuse(m1179);
+ l1179 = confuse(m1179);
+
+ }
+
+ void testF1279() {
+ // core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1279 is F1279);
+ Expect.isTrue(confuse(f1279) is F1279);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1279;
+ // The static function f1279 sets `T` to `int`.
+ if (!tIsBool) {
+ x1279 = f1279 as dynamic;
+ l1279 = f1279 as dynamic;
+ x1279 = confuse(f1279);
+ l1279 = confuse(f1279);
+ }
+
+ Expect.isTrue(m1279 is F1279);
+ Expect.isTrue(m1279 is core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1279) is F1279);
+ // In checked mode, verifies the type.
+ x1279 = m1279;
+ l1279 = m1279;
+ x1279 = confuse(m1279);
+ l1279 = confuse(m1279);
+ if (!tIsBool) {
+ Expect.isTrue(f1279 is F1279<int>);
+ Expect.isFalse(f1279 is F1279<bool>);
+ Expect.isTrue(confuse(f1279) is F1279<int>);
+ Expect.isFalse(confuse(f1279) is F1279<bool>);
+ Expect.equals(tIsDynamic, m1279 is F1279<bool>);
+ Expect.equals(tIsDynamic, confuse(m1279) is F1279<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1279 = (f1279 as dynamic); });
+ Expect.throws(() { x1279 = confuse(f1279); });
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1279;
+ Expect.throws(() { l1279 = (f1279 as dynamic); });
+ Expect.throws(() { l1279 = confuse(f1279); });
+ }
+ core.List<core.int> Function(int x, [List<T> x1]) Function<B extends core.int>(int x) l1279 = m1279;
+ // In checked mode, verifies the type.
+ x1279 = m1279;
+ x1279 = confuse(m1279);
+ }
+ }
+
+ void testF1379() {
+ // List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1379 is F1379);
+ Expect.isTrue(confuse(f1379) is F1379);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x) l1379;
+ // The static function f1379 sets `T` to `int`.
+ if (!tIsBool) {
+ x1379 = f1379 as dynamic;
+ l1379 = f1379 as dynamic;
+ x1379 = confuse(f1379);
+ l1379 = confuse(f1379);
+ }
+
+ Expect.isTrue(m1379 is F1379);
+ Expect.isTrue(m1379 is List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1379) is F1379);
+ // In checked mode, verifies the type.
+ x1379 = m1379;
+ l1379 = m1379;
+ x1379 = confuse(m1379);
+ l1379 = confuse(m1379);
+ if (!tIsBool) {
+ Expect.isTrue(f1379 is F1379<int>);
+ Expect.isFalse(f1379 is F1379<bool>);
+ Expect.isTrue(confuse(f1379) is F1379<int>);
+ Expect.isFalse(confuse(f1379) is F1379<bool>);
+ Expect.equals(tIsDynamic, m1379 is F1379<bool>);
+ Expect.equals(tIsDynamic, confuse(m1379) is F1379<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1379 = (f1379 as dynamic); });
+ Expect.throws(() { x1379 = confuse(f1379); });
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x) l1379;
+ Expect.throws(() { l1379 = (f1379 as dynamic); });
+ Expect.throws(() { l1379 = confuse(f1379); });
+ }
+ List<T> Function(int x1, {Function x}) Function<B extends core.int>(int x) l1379 = m1379;
+ // In checked mode, verifies the type.
+ x1379 = m1379;
+ x1379 = confuse(m1379);
+ }
+ }
+
+ void testF1479() {
+ // List<T> Function([List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1479 is F1479);
+ Expect.isTrue(confuse(f1479) is F1479);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x]) Function<B extends core.int>(int x) l1479;
+ // The static function f1479 sets `T` to `int`.
+ if (!tIsBool) {
+ x1479 = f1479 as dynamic;
+ l1479 = f1479 as dynamic;
+ x1479 = confuse(f1479);
+ l1479 = confuse(f1479);
+ }
+
+ Expect.isTrue(m1479 is F1479);
+ Expect.isTrue(m1479 is List<T> Function([List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1479) is F1479);
+ // In checked mode, verifies the type.
+ x1479 = m1479;
+ l1479 = m1479;
+ x1479 = confuse(m1479);
+ l1479 = confuse(m1479);
+ if (!tIsBool) {
+ Expect.isTrue(f1479 is F1479<int>);
+ Expect.isFalse(f1479 is F1479<bool>);
+ Expect.isTrue(confuse(f1479) is F1479<int>);
+ Expect.isFalse(confuse(f1479) is F1479<bool>);
+ Expect.equals(tIsDynamic, m1479 is F1479<bool>);
+ Expect.equals(tIsDynamic, confuse(m1479) is F1479<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1479 = (f1479 as dynamic); });
+ Expect.throws(() { x1479 = confuse(f1479); });
+ List<T> Function([List<T> x]) Function<B extends core.int>(int x) l1479;
+ Expect.throws(() { l1479 = (f1479 as dynamic); });
+ Expect.throws(() { l1479 = confuse(f1479); });
+ }
+ List<T> Function([List<T> x]) Function<B extends core.int>(int x) l1479 = m1479;
+ // In checked mode, verifies the type.
+ x1479 = m1479;
+ x1479 = confuse(m1479);
+ }
+ }
+
+ void testF1579() {
+ // Function(int y, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1579 is F1579);
+ Expect.isTrue(confuse(f1579) is F1579);
+ // In checked mode, verifies the type.
+ Function(int y, [Function x]) Function<B extends core.int>(int x) l1579;
+ // The static function f1579 sets `T` to `int`.
+ if (!tIsBool) {
+ x1579 = f1579 as dynamic;
+ l1579 = f1579 as dynamic;
+ x1579 = confuse(f1579);
+ l1579 = confuse(f1579);
+ }
+
+ Expect.isTrue(m1579 is F1579);
+ Expect.isTrue(m1579 is Function(int y, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1579) is F1579);
+ // In checked mode, verifies the type.
+ x1579 = m1579;
+ l1579 = m1579;
+ x1579 = confuse(m1579);
+ l1579 = confuse(m1579);
+
+ }
+
+ void testF1679() {
+ // Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1679 is F1679);
+ Expect.isTrue(confuse(f1679) is F1679);
+ // In checked mode, verifies the type.
+ Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l1679;
+ // The static function f1679 sets `T` to `int`.
+ if (!tIsBool) {
+ x1679 = f1679 as dynamic;
+ l1679 = f1679 as dynamic;
+ x1679 = confuse(f1679);
+ l1679 = confuse(f1679);
+ }
+
+ Expect.isTrue(m1679 is F1679);
+ Expect.isTrue(m1679 is Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1679) is F1679);
+ // In checked mode, verifies the type.
+ x1679 = m1679;
+ l1679 = m1679;
+ x1679 = confuse(m1679);
+ l1679 = confuse(m1679);
+
+ }
+
+ void testF1779() {
+ // Function Function<A>(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1779 is F1779);
+ Expect.isTrue(confuse(f1779) is F1779);
+ // In checked mode, verifies the type.
+ Function Function<A>(int x) Function<B extends core.int>(int x) l1779;
+ // The static function f1779 sets `T` to `int`.
+ if (!tIsBool) {
+ x1779 = f1779 as dynamic;
+ l1779 = f1779 as dynamic;
+ x1779 = confuse(f1779);
+ l1779 = confuse(f1779);
+ }
+
+ Expect.isTrue(m1779 is F1779);
+ Expect.isTrue(m1779 is Function Function<A>(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1779) is F1779);
+ // In checked mode, verifies the type.
+ x1779 = m1779;
+ l1779 = m1779;
+ x1779 = confuse(m1779);
+ l1779 = confuse(m1779);
+
+ }
+
+ void testF1879() {
+ // List<T> Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1879 is F1879);
+ Expect.isTrue(confuse(f1879) is F1879);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(Function x) Function<B extends core.int>(int x) l1879;
+ // The static function f1879 sets `T` to `int`.
+ if (!tIsBool) {
+ x1879 = f1879 as dynamic;
+ l1879 = f1879 as dynamic;
+ x1879 = confuse(f1879);
+ l1879 = confuse(f1879);
+ }
+
+ Expect.isTrue(m1879 is F1879);
+ Expect.isTrue(m1879 is List<T> Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1879) is F1879);
+ // In checked mode, verifies the type.
+ x1879 = m1879;
+ l1879 = m1879;
+ x1879 = confuse(m1879);
+ l1879 = confuse(m1879);
+ if (!tIsBool) {
+ Expect.isTrue(f1879 is F1879<int>);
+ Expect.isFalse(f1879 is F1879<bool>);
+ Expect.isTrue(confuse(f1879) is F1879<int>);
+ Expect.isFalse(confuse(f1879) is F1879<bool>);
+ Expect.equals(tIsDynamic, m1879 is F1879<bool>);
+ Expect.equals(tIsDynamic, confuse(m1879) is F1879<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1879 = (f1879 as dynamic); });
+ Expect.throws(() { x1879 = confuse(f1879); });
+ List<T> Function<A>(Function x) Function<B extends core.int>(int x) l1879;
+ Expect.throws(() { l1879 = (f1879 as dynamic); });
+ Expect.throws(() { l1879 = confuse(f1879); });
+ }
+ List<T> Function<A>(Function x) Function<B extends core.int>(int x) l1879 = m1879;
+ // In checked mode, verifies the type.
+ x1879 = m1879;
+ x1879 = confuse(m1879);
+ }
+ }
+
+ void testF1979() {
+ // List<A> Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1979 is F1979);
+ Expect.isTrue(confuse(f1979) is F1979);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<Function> x) Function<B extends core.int>(int x) l1979;
+ // The static function f1979 sets `T` to `int`.
+ if (!tIsBool) {
+ x1979 = f1979 as dynamic;
+ l1979 = f1979 as dynamic;
+ x1979 = confuse(f1979);
+ l1979 = confuse(f1979);
+ }
+
+ Expect.isTrue(m1979 is F1979);
+ Expect.isTrue(m1979 is List<A> Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1979) is F1979);
+ // In checked mode, verifies the type.
+ x1979 = m1979;
+ l1979 = m1979;
+ x1979 = confuse(m1979);
+ l1979 = confuse(m1979);
+
+ }
+
+
+}
+
+class C80<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, [List<Function> x]) x80;
+ core.List<core.int> Function([Function x]) x180;
+ Function(int x) x280;
+ Function<A>(List<T> x) x380;
+ int Function(int x0, {Function x}) Function() x480;
+ int Function([List<T> x]) Function() x580;
+ Function Function(int y, [Function x]) Function() x680;
+ Function Function(int x1, [core.List<core.int> x2]) Function() x780;
+ List<Function> Function({int x}) Function() x880;
+ List<Function> Function(core.List<core.int> x) Function() x980;
+ core.List<core.int> Function(int x0, [int x]) Function() x1080;
+ core.List<core.int> Function([List<Function> x1]) Function() x1180;
+ core.List<core.int> Function({List<T> x}) Function() x1280;
+ List<T> Function(int y, {Function x}) Function() x1380;
+ List<T> Function(int x0, [List<T> x]) Function() x1480;
+ Function(Function x0) Function() x1580;
+ Function(int x, [core.List<core.int> x2]) Function() x1680;
+ Function Function<A>(Function x) Function() x1780;
+ List<T> Function<A>(List<Function> x) Function() x1880;
+ List<A> Function<A>(core.List<core.int> x) Function() x1980;
+
+
+ C80({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m80(int x0, [List<Function> x]) => null;
+ core.List<core.int> m180([Function x]) => null;
+ m280(int x) => null;
+ m380<A>(List<T> x) => null;
+ int Function(int x0, {Function x}) m480() => null;
+ int Function([List<T> x]) m580() => null;
+ Function Function(int y, [Function x]) m680() => null;
+ Function Function(int x0, [core.List<core.int> x1]) m780() => null;
+ List<Function> Function({int x}) m880() => null;
+ List<Function> Function(core.List<core.int> x) m980() => null;
+ core.List<core.int> Function(int x0, [int x]) m1080() => null;
+ core.List<core.int> Function([List<Function> x0]) m1180() => null;
+ core.List<core.int> Function({List<T> x}) m1280() => null;
+ List<T> Function(int y, {Function x}) m1380() => null;
+ List<T> Function(int x0, [List<T> x]) m1480() => null;
+ Function(Function x0) m1580() => null;
+ Function(int x, [core.List<core.int> x0]) m1680() => null;
+ Function Function<A>(Function x) m1780() => null;
+ List<T> Function<A>(List<Function> x) m1880() => null;
+ List<A> Function<A>(core.List<core.int> x) m1980() => null;
+
+
+ runTests() {
+ testF80();
+ testF180();
+ testF280();
+ testF380();
+ testF480();
+ testF580();
+ testF680();
+ testF780();
+ testF880();
+ testF980();
+ testF1080();
+ testF1180();
+ testF1280();
+ testF1380();
+ testF1480();
+ testF1580();
+ testF1680();
+ testF1780();
+ testF1880();
+ testF1980();
+ }
+
+ void testF80() {
+ // Function Function(int x0, [List<Function> x])
+ Expect.isTrue(f80 is F80);
+ Expect.isTrue(confuse(f80) is F80);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [List<Function> x]) l80;
+ // The static function f80 sets `T` to `int`.
+ if (!tIsBool) {
+ x80 = f80 as dynamic;
+ l80 = f80 as dynamic;
+ x80 = confuse(f80);
+ l80 = confuse(f80);
+ }
+
+ Expect.isTrue(m80 is F80);
+ Expect.isTrue(m80 is Function Function(int x0, [List<Function> x]));
+ Expect.isTrue(confuse(m80) is F80);
+ // In checked mode, verifies the type.
+ x80 = m80;
+ l80 = m80;
+ x80 = confuse(m80);
+ l80 = confuse(m80);
+
+ }
+
+ void testF180() {
+ // core.List<core.int> Function([Function x])
+ Expect.isTrue(f180 is F180);
+ Expect.isTrue(confuse(f180) is F180);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x]) l180;
+ // The static function f180 sets `T` to `int`.
+ if (!tIsBool) {
+ x180 = f180 as dynamic;
+ l180 = f180 as dynamic;
+ x180 = confuse(f180);
+ l180 = confuse(f180);
+ }
+
+ Expect.isTrue(m180 is F180);
+ Expect.isTrue(m180 is core.List<core.int> Function([Function x]));
+ Expect.isTrue(confuse(m180) is F180);
+ // In checked mode, verifies the type.
+ x180 = m180;
+ l180 = m180;
+ x180 = confuse(m180);
+ l180 = confuse(m180);
+
+ }
+
+ void testF280() {
+ // Function(int x)
+ Expect.isTrue(f280 is F280);
+ Expect.isTrue(confuse(f280) is F280);
+ // In checked mode, verifies the type.
+ Function(int x) l280;
+ // The static function f280 sets `T` to `int`.
+ if (!tIsBool) {
+ x280 = f280 as dynamic;
+ l280 = f280 as dynamic;
+ x280 = confuse(f280);
+ l280 = confuse(f280);
+ }
+
+ Expect.isTrue(m280 is F280);
+ Expect.isTrue(m280 is Function(int x));
+ Expect.isTrue(confuse(m280) is F280);
+ // In checked mode, verifies the type.
+ x280 = m280;
+ l280 = m280;
+ x280 = confuse(m280);
+ l280 = confuse(m280);
+
+ }
+
+ void testF380() {
+ // Function<A>(List<T> x)
+ Expect.isTrue(f380 is F380);
+ Expect.isTrue(confuse(f380) is F380);
+ // In checked mode, verifies the type.
+ Function<A>(List<T> x) l380;
+ // The static function f380 sets `T` to `int`.
+ if (!tIsBool) {
+ x380 = f380 as dynamic;
+ l380 = f380 as dynamic;
+ x380 = confuse(f380);
+ l380 = confuse(f380);
+ }
+
+ Expect.isTrue(m380 is F380);
+ Expect.isTrue(m380 is Function<A>(List<T> x));
+ Expect.isTrue(confuse(m380) is F380);
+ // In checked mode, verifies the type.
+ x380 = m380;
+ l380 = m380;
+ x380 = confuse(m380);
+ l380 = confuse(m380);
+ if (!tIsBool) {
+ Expect.isTrue(f380 is F380<int>);
+ Expect.isFalse(f380 is F380<bool>);
+ Expect.isTrue(confuse(f380) is F380<int>);
+ Expect.isFalse(confuse(f380) is F380<bool>);
+ Expect.equals(tIsDynamic, m380 is F380<bool>);
+ Expect.equals(tIsDynamic, confuse(m380) is F380<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x380 = (f380 as dynamic); });
+ Expect.throws(() { x380 = confuse(f380); });
+ Function<A>(List<T> x) l380;
+ Expect.throws(() { l380 = (f380 as dynamic); });
+ Expect.throws(() { l380 = confuse(f380); });
+ }
+ Function<A>(List<T> x) l380 = m380;
+ // In checked mode, verifies the type.
+ x380 = m380;
+ x380 = confuse(m380);
+ }
+ }
+
+ void testF480() {
+ // int Function(int x0, {Function x}) Function()
+ Expect.isTrue(f480 is F480);
+ Expect.isTrue(confuse(f480) is F480);
+ // In checked mode, verifies the type.
+ int Function(int x0, {Function x}) Function() l480;
+ // The static function f480 sets `T` to `int`.
+ if (!tIsBool) {
+ x480 = f480 as dynamic;
+ l480 = f480 as dynamic;
+ x480 = confuse(f480);
+ l480 = confuse(f480);
+ }
+
+ Expect.isTrue(m480 is F480);
+ Expect.isTrue(m480 is int Function(int x0, {Function x}) Function());
+ Expect.isTrue(confuse(m480) is F480);
+ // In checked mode, verifies the type.
+ x480 = m480;
+ l480 = m480;
+ x480 = confuse(m480);
+ l480 = confuse(m480);
+
+ }
+
+ void testF580() {
+ // int Function([List<T> x]) Function()
+ Expect.isTrue(f580 is F580);
+ Expect.isTrue(confuse(f580) is F580);
+ // In checked mode, verifies the type.
+ int Function([List<T> x]) Function() l580;
+ // The static function f580 sets `T` to `int`.
+ if (!tIsBool) {
+ x580 = f580 as dynamic;
+ l580 = f580 as dynamic;
+ x580 = confuse(f580);
+ l580 = confuse(f580);
+ }
+
+ Expect.isTrue(m580 is F580);
+ Expect.isTrue(m580 is int Function([List<T> x]) Function());
+ Expect.isTrue(confuse(m580) is F580);
+ // In checked mode, verifies the type.
+ x580 = m580;
+ l580 = m580;
+ x580 = confuse(m580);
+ l580 = confuse(m580);
+ if (!tIsBool) {
+ Expect.isTrue(f580 is F580<int>);
+ Expect.isFalse(f580 is F580<bool>);
+ Expect.isTrue(confuse(f580) is F580<int>);
+ Expect.isFalse(confuse(f580) is F580<bool>);
+ Expect.equals(tIsDynamic, m580 is F580<bool>);
+ Expect.equals(tIsDynamic, confuse(m580) is F580<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x580 = (f580 as dynamic); });
+ Expect.throws(() { x580 = confuse(f580); });
+ int Function([List<T> x]) Function() l580;
+ Expect.throws(() { l580 = (f580 as dynamic); });
+ Expect.throws(() { l580 = confuse(f580); });
+ }
+ int Function([List<T> x]) Function() l580 = m580;
+ // In checked mode, verifies the type.
+ x580 = m580;
+ x580 = confuse(m580);
+ }
+ }
+
+ void testF680() {
+ // Function Function(int y, [Function x]) Function()
+ Expect.isTrue(f680 is F680);
+ Expect.isTrue(confuse(f680) is F680);
+ // In checked mode, verifies the type.
+ Function Function(int y, [Function x]) Function() l680;
+ // The static function f680 sets `T` to `int`.
+ if (!tIsBool) {
+ x680 = f680 as dynamic;
+ l680 = f680 as dynamic;
+ x680 = confuse(f680);
+ l680 = confuse(f680);
+ }
+
+ Expect.isTrue(m680 is F680);
+ Expect.isTrue(m680 is Function Function(int y, [Function x]) Function());
+ Expect.isTrue(confuse(m680) is F680);
+ // In checked mode, verifies the type.
+ x680 = m680;
+ l680 = m680;
+ x680 = confuse(m680);
+ l680 = confuse(m680);
+
+ }
+
+ void testF780() {
+ // Function Function(int x1, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f780 is F780);
+ Expect.isTrue(confuse(f780) is F780);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [core.List<core.int> x2]) Function() l780;
+ // The static function f780 sets `T` to `int`.
+ if (!tIsBool) {
+ x780 = f780 as dynamic;
+ l780 = f780 as dynamic;
+ x780 = confuse(f780);
+ l780 = confuse(f780);
+ }
+
+ Expect.isTrue(m780 is F780);
+ Expect.isTrue(m780 is Function Function(int x1, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m780) is F780);
+ // In checked mode, verifies the type.
+ x780 = m780;
+ l780 = m780;
+ x780 = confuse(m780);
+ l780 = confuse(m780);
+
+ }
+
+ void testF880() {
+ // List<Function> Function({int x}) Function()
+ Expect.isTrue(f880 is F880);
+ Expect.isTrue(confuse(f880) is F880);
+ // In checked mode, verifies the type.
+ List<Function> Function({int x}) Function() l880;
+ // The static function f880 sets `T` to `int`.
+ if (!tIsBool) {
+ x880 = f880 as dynamic;
+ l880 = f880 as dynamic;
+ x880 = confuse(f880);
+ l880 = confuse(f880);
+ }
+
+ Expect.isTrue(m880 is F880);
+ Expect.isTrue(m880 is List<Function> Function({int x}) Function());
+ Expect.isTrue(confuse(m880) is F880);
+ // In checked mode, verifies the type.
+ x880 = m880;
+ l880 = m880;
+ x880 = confuse(m880);
+ l880 = confuse(m880);
+
+ }
+
+ void testF980() {
+ // List<Function> Function(core.List<core.int> x) Function()
+ Expect.isTrue(f980 is F980);
+ Expect.isTrue(confuse(f980) is F980);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x) Function() l980;
+ // The static function f980 sets `T` to `int`.
+ if (!tIsBool) {
+ x980 = f980 as dynamic;
+ l980 = f980 as dynamic;
+ x980 = confuse(f980);
+ l980 = confuse(f980);
+ }
+
+ Expect.isTrue(m980 is F980);
+ Expect.isTrue(m980 is List<Function> Function(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m980) is F980);
+ // In checked mode, verifies the type.
+ x980 = m980;
+ l980 = m980;
+ x980 = confuse(m980);
+ l980 = confuse(m980);
+
+ }
+
+ void testF1080() {
+ // core.List<core.int> Function(int x0, [int x]) Function()
+ Expect.isTrue(f1080 is F1080);
+ Expect.isTrue(confuse(f1080) is F1080);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [int x]) Function() l1080;
+ // The static function f1080 sets `T` to `int`.
+ if (!tIsBool) {
+ x1080 = f1080 as dynamic;
+ l1080 = f1080 as dynamic;
+ x1080 = confuse(f1080);
+ l1080 = confuse(f1080);
+ }
+
+ Expect.isTrue(m1080 is F1080);
+ Expect.isTrue(m1080 is core.List<core.int> Function(int x0, [int x]) Function());
+ Expect.isTrue(confuse(m1080) is F1080);
+ // In checked mode, verifies the type.
+ x1080 = m1080;
+ l1080 = m1080;
+ x1080 = confuse(m1080);
+ l1080 = confuse(m1080);
+
+ }
+
+ void testF1180() {
+ // core.List<core.int> Function([List<Function> x1]) Function()
+ Expect.isTrue(f1180 is F1180);
+ Expect.isTrue(confuse(f1180) is F1180);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x1]) Function() l1180;
+ // The static function f1180 sets `T` to `int`.
+ if (!tIsBool) {
+ x1180 = f1180 as dynamic;
+ l1180 = f1180 as dynamic;
+ x1180 = confuse(f1180);
+ l1180 = confuse(f1180);
+ }
+
+ Expect.isTrue(m1180 is F1180);
+ Expect.isTrue(m1180 is core.List<core.int> Function([List<Function> x1]) Function());
+ Expect.isTrue(confuse(m1180) is F1180);
+ // In checked mode, verifies the type.
+ x1180 = m1180;
+ l1180 = m1180;
+ x1180 = confuse(m1180);
+ l1180 = confuse(m1180);
+
+ }
+
+ void testF1280() {
+ // core.List<core.int> Function({List<T> x}) Function()
+ Expect.isTrue(f1280 is F1280);
+ Expect.isTrue(confuse(f1280) is F1280);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<T> x}) Function() l1280;
+ // The static function f1280 sets `T` to `int`.
+ if (!tIsBool) {
+ x1280 = f1280 as dynamic;
+ l1280 = f1280 as dynamic;
+ x1280 = confuse(f1280);
+ l1280 = confuse(f1280);
+ }
+
+ Expect.isTrue(m1280 is F1280);
+ Expect.isTrue(m1280 is core.List<core.int> Function({List<T> x}) Function());
+ Expect.isTrue(confuse(m1280) is F1280);
+ // In checked mode, verifies the type.
+ x1280 = m1280;
+ l1280 = m1280;
+ x1280 = confuse(m1280);
+ l1280 = confuse(m1280);
+ if (!tIsBool) {
+ Expect.isTrue(f1280 is F1280<int>);
+ Expect.isFalse(f1280 is F1280<bool>);
+ Expect.isTrue(confuse(f1280) is F1280<int>);
+ Expect.isFalse(confuse(f1280) is F1280<bool>);
+ Expect.equals(tIsDynamic, m1280 is F1280<bool>);
+ Expect.equals(tIsDynamic, confuse(m1280) is F1280<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1280 = (f1280 as dynamic); });
+ Expect.throws(() { x1280 = confuse(f1280); });
+ core.List<core.int> Function({List<T> x}) Function() l1280;
+ Expect.throws(() { l1280 = (f1280 as dynamic); });
+ Expect.throws(() { l1280 = confuse(f1280); });
+ }
+ core.List<core.int> Function({List<T> x}) Function() l1280 = m1280;
+ // In checked mode, verifies the type.
+ x1280 = m1280;
+ x1280 = confuse(m1280);
+ }
+ }
+
+ void testF1380() {
+ // List<T> Function(int y, {Function x}) Function()
+ Expect.isTrue(f1380 is F1380);
+ Expect.isTrue(confuse(f1380) is F1380);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {Function x}) Function() l1380;
+ // The static function f1380 sets `T` to `int`.
+ if (!tIsBool) {
+ x1380 = f1380 as dynamic;
+ l1380 = f1380 as dynamic;
+ x1380 = confuse(f1380);
+ l1380 = confuse(f1380);
+ }
+
+ Expect.isTrue(m1380 is F1380);
+ Expect.isTrue(m1380 is List<T> Function(int y, {Function x}) Function());
+ Expect.isTrue(confuse(m1380) is F1380);
+ // In checked mode, verifies the type.
+ x1380 = m1380;
+ l1380 = m1380;
+ x1380 = confuse(m1380);
+ l1380 = confuse(m1380);
+ if (!tIsBool) {
+ Expect.isTrue(f1380 is F1380<int>);
+ Expect.isFalse(f1380 is F1380<bool>);
+ Expect.isTrue(confuse(f1380) is F1380<int>);
+ Expect.isFalse(confuse(f1380) is F1380<bool>);
+ Expect.equals(tIsDynamic, m1380 is F1380<bool>);
+ Expect.equals(tIsDynamic, confuse(m1380) is F1380<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1380 = (f1380 as dynamic); });
+ Expect.throws(() { x1380 = confuse(f1380); });
+ List<T> Function(int y, {Function x}) Function() l1380;
+ Expect.throws(() { l1380 = (f1380 as dynamic); });
+ Expect.throws(() { l1380 = confuse(f1380); });
+ }
+ List<T> Function(int y, {Function x}) Function() l1380 = m1380;
+ // In checked mode, verifies the type.
+ x1380 = m1380;
+ x1380 = confuse(m1380);
+ }
+ }
+
+ void testF1480() {
+ // List<T> Function(int x0, [List<T> x]) Function()
+ Expect.isTrue(f1480 is F1480);
+ Expect.isTrue(confuse(f1480) is F1480);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [List<T> x]) Function() l1480;
+ // The static function f1480 sets `T` to `int`.
+ if (!tIsBool) {
+ x1480 = f1480 as dynamic;
+ l1480 = f1480 as dynamic;
+ x1480 = confuse(f1480);
+ l1480 = confuse(f1480);
+ }
+
+ Expect.isTrue(m1480 is F1480);
+ Expect.isTrue(m1480 is List<T> Function(int x0, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1480) is F1480);
+ // In checked mode, verifies the type.
+ x1480 = m1480;
+ l1480 = m1480;
+ x1480 = confuse(m1480);
+ l1480 = confuse(m1480);
+ if (!tIsBool) {
+ Expect.isTrue(f1480 is F1480<int>);
+ Expect.isFalse(f1480 is F1480<bool>);
+ Expect.isTrue(confuse(f1480) is F1480<int>);
+ Expect.isFalse(confuse(f1480) is F1480<bool>);
+ Expect.equals(tIsDynamic, m1480 is F1480<bool>);
+ Expect.equals(tIsDynamic, confuse(m1480) is F1480<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1480 = (f1480 as dynamic); });
+ Expect.throws(() { x1480 = confuse(f1480); });
+ List<T> Function(int x0, [List<T> x]) Function() l1480;
+ Expect.throws(() { l1480 = (f1480 as dynamic); });
+ Expect.throws(() { l1480 = confuse(f1480); });
+ }
+ List<T> Function(int x0, [List<T> x]) Function() l1480 = m1480;
+ // In checked mode, verifies the type.
+ x1480 = m1480;
+ x1480 = confuse(m1480);
+ }
+ }
+
+ void testF1580() {
+ // Function(Function x0) Function()
+ Expect.isTrue(f1580 is F1580);
+ Expect.isTrue(confuse(f1580) is F1580);
+ // In checked mode, verifies the type.
+ Function(Function x0) Function() l1580;
+ // The static function f1580 sets `T` to `int`.
+ if (!tIsBool) {
+ x1580 = f1580 as dynamic;
+ l1580 = f1580 as dynamic;
+ x1580 = confuse(f1580);
+ l1580 = confuse(f1580);
+ }
+
+ Expect.isTrue(m1580 is F1580);
+ Expect.isTrue(m1580 is Function(Function x0) Function());
+ Expect.isTrue(confuse(m1580) is F1580);
+ // In checked mode, verifies the type.
+ x1580 = m1580;
+ l1580 = m1580;
+ x1580 = confuse(m1580);
+ l1580 = confuse(m1580);
+
+ }
+
+ void testF1680() {
+ // Function(int x, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f1680 is F1680);
+ Expect.isTrue(confuse(f1680) is F1680);
+ // In checked mode, verifies the type.
+ Function(int x, [core.List<core.int> x2]) Function() l1680;
+ // The static function f1680 sets `T` to `int`.
+ if (!tIsBool) {
+ x1680 = f1680 as dynamic;
+ l1680 = f1680 as dynamic;
+ x1680 = confuse(f1680);
+ l1680 = confuse(f1680);
+ }
+
+ Expect.isTrue(m1680 is F1680);
+ Expect.isTrue(m1680 is Function(int x, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m1680) is F1680);
+ // In checked mode, verifies the type.
+ x1680 = m1680;
+ l1680 = m1680;
+ x1680 = confuse(m1680);
+ l1680 = confuse(m1680);
+
+ }
+
+ void testF1780() {
+ // Function Function<A>(Function x) Function()
+ Expect.isTrue(f1780 is F1780);
+ Expect.isTrue(confuse(f1780) is F1780);
+ // In checked mode, verifies the type.
+ Function Function<A>(Function x) Function() l1780;
+ // The static function f1780 sets `T` to `int`.
+ if (!tIsBool) {
+ x1780 = f1780 as dynamic;
+ l1780 = f1780 as dynamic;
+ x1780 = confuse(f1780);
+ l1780 = confuse(f1780);
+ }
+
+ Expect.isTrue(m1780 is F1780);
+ Expect.isTrue(m1780 is Function Function<A>(Function x) Function());
+ Expect.isTrue(confuse(m1780) is F1780);
+ // In checked mode, verifies the type.
+ x1780 = m1780;
+ l1780 = m1780;
+ x1780 = confuse(m1780);
+ l1780 = confuse(m1780);
+
+ }
+
+ void testF1880() {
+ // List<T> Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1880 is F1880);
+ Expect.isTrue(confuse(f1880) is F1880);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<Function> x) Function() l1880;
+ // The static function f1880 sets `T` to `int`.
+ if (!tIsBool) {
+ x1880 = f1880 as dynamic;
+ l1880 = f1880 as dynamic;
+ x1880 = confuse(f1880);
+ l1880 = confuse(f1880);
+ }
+
+ Expect.isTrue(m1880 is F1880);
+ Expect.isTrue(m1880 is List<T> Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1880) is F1880);
+ // In checked mode, verifies the type.
+ x1880 = m1880;
+ l1880 = m1880;
+ x1880 = confuse(m1880);
+ l1880 = confuse(m1880);
+ if (!tIsBool) {
+ Expect.isTrue(f1880 is F1880<int>);
+ Expect.isFalse(f1880 is F1880<bool>);
+ Expect.isTrue(confuse(f1880) is F1880<int>);
+ Expect.isFalse(confuse(f1880) is F1880<bool>);
+ Expect.equals(tIsDynamic, m1880 is F1880<bool>);
+ Expect.equals(tIsDynamic, confuse(m1880) is F1880<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1880 = (f1880 as dynamic); });
+ Expect.throws(() { x1880 = confuse(f1880); });
+ List<T> Function<A>(List<Function> x) Function() l1880;
+ Expect.throws(() { l1880 = (f1880 as dynamic); });
+ Expect.throws(() { l1880 = confuse(f1880); });
+ }
+ List<T> Function<A>(List<Function> x) Function() l1880 = m1880;
+ // In checked mode, verifies the type.
+ x1880 = m1880;
+ x1880 = confuse(m1880);
+ }
+ }
+
+ void testF1980() {
+ // List<A> Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1980 is F1980);
+ Expect.isTrue(confuse(f1980) is F1980);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(core.List<core.int> x) Function() l1980;
+ // The static function f1980 sets `T` to `int`.
+ if (!tIsBool) {
+ x1980 = f1980 as dynamic;
+ l1980 = f1980 as dynamic;
+ x1980 = confuse(f1980);
+ l1980 = confuse(f1980);
+ }
+
+ Expect.isTrue(m1980 is F1980);
+ Expect.isTrue(m1980 is List<A> Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1980) is F1980);
+ // In checked mode, verifies the type.
+ x1980 = m1980;
+ l1980 = m1980;
+ x1980 = confuse(m1980);
+ l1980 = confuse(m1980);
+
+ }
+
+
+}
+
+class C81<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, [List<Function> x]) x81;
+ core.List<core.int> Function(int x0, [Function x]) x181;
+ Function([int x]) x281;
+ Function<A>() x381;
+ int Function(int x1, {Function x}) Function(int x) x481;
+ int Function([List<T> x]) Function(int x) x581;
+ Function Function(int y, [Function x]) Function(int x) x681;
+ Function Function(int x2, [core.List<core.int> x3]) Function(int x) x781;
+ List<Function> Function({int x}) Function(int x) x881;
+ List<Function> Function(core.List<core.int> x) Function(int x) x981;
+ core.List<core.int> Function(int x1, [int x]) Function(int x) x1081;
+ core.List<core.int> Function([List<Function> x1]) Function(int x) x1181;
+ core.List<core.int> Function({List<T> x}) Function(int x) x1281;
+ List<T> Function(int y, {Function x}) Function(int x) x1381;
+ List<T> Function(int x1, [List<T> x]) Function(int x) x1481;
+ Function(Function x1) Function(int x) x1581;
+ Function(int x, [core.List<core.int> x1]) Function(int x) x1681;
+ Function Function<A>(Function x) Function(int x) x1781;
+ List<T> Function<A>(List<Function> x) Function(int x) x1881;
+ List<A> Function<A>(core.List<core.int> x) Function(int x) x1981;
+
+
+ C81({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m81(int y, [List<Function> x]) => null;
+ core.List<core.int> m181(int x0, [Function x]) => null;
+ m281([int x]) => null;
+ m381<A>() => null;
+ int Function(int x0, {Function x}) m481(int x) => null;
+ int Function([List<T> x]) m581(int x) => null;
+ Function Function(int y, [Function x]) m681(int x) => null;
+ Function Function(int x0, [core.List<core.int> x1]) m781(int x) => null;
+ List<Function> Function({int x}) m881(int x) => null;
+ List<Function> Function(core.List<core.int> x) m981(int x) => null;
+ core.List<core.int> Function(int x0, [int x]) m1081(int x) => null;
+ core.List<core.int> Function([List<Function> x0]) m1181(int x) => null;
+ core.List<core.int> Function({List<T> x}) m1281(int x) => null;
+ List<T> Function(int y, {Function x}) m1381(int x) => null;
+ List<T> Function(int x0, [List<T> x]) m1481(int x) => null;
+ Function(Function x0) m1581(int x) => null;
+ Function(int x, [core.List<core.int> x0]) m1681(int x) => null;
+ Function Function<A>(Function x) m1781(int x) => null;
+ List<T> Function<A>(List<Function> x) m1881(int x) => null;
+ List<A> Function<A>(core.List<core.int> x) m1981(int x) => null;
+
+
+ runTests() {
+ testF81();
+ testF181();
+ testF281();
+ testF381();
+ testF481();
+ testF581();
+ testF681();
+ testF781();
+ testF881();
+ testF981();
+ testF1081();
+ testF1181();
+ testF1281();
+ testF1381();
+ testF1481();
+ testF1581();
+ testF1681();
+ testF1781();
+ testF1881();
+ testF1981();
+ }
+
+ void testF81() {
+ // Function Function(int y, [List<Function> x])
+ Expect.isTrue(f81 is F81);
+ Expect.isTrue(confuse(f81) is F81);
+ // In checked mode, verifies the type.
+ Function Function(int y, [List<Function> x]) l81;
+ // The static function f81 sets `T` to `int`.
+ if (!tIsBool) {
+ x81 = f81 as dynamic;
+ l81 = f81 as dynamic;
+ x81 = confuse(f81);
+ l81 = confuse(f81);
+ }
+
+ Expect.isTrue(m81 is F81);
+ Expect.isTrue(m81 is Function Function(int y, [List<Function> x]));
+ Expect.isTrue(confuse(m81) is F81);
+ // In checked mode, verifies the type.
+ x81 = m81;
+ l81 = m81;
+ x81 = confuse(m81);
+ l81 = confuse(m81);
+
+ }
+
+ void testF181() {
+ // core.List<core.int> Function(int x0, [Function x])
+ Expect.isTrue(f181 is F181);
+ Expect.isTrue(confuse(f181) is F181);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [Function x]) l181;
+ // The static function f181 sets `T` to `int`.
+ if (!tIsBool) {
+ x181 = f181 as dynamic;
+ l181 = f181 as dynamic;
+ x181 = confuse(f181);
+ l181 = confuse(f181);
+ }
+
+ Expect.isTrue(m181 is F181);
+ Expect.isTrue(m181 is core.List<core.int> Function(int x0, [Function x]));
+ Expect.isTrue(confuse(m181) is F181);
+ // In checked mode, verifies the type.
+ x181 = m181;
+ l181 = m181;
+ x181 = confuse(m181);
+ l181 = confuse(m181);
+
+ }
+
+ void testF281() {
+ // Function([int x])
+ Expect.isTrue(f281 is F281);
+ Expect.isTrue(confuse(f281) is F281);
+ // In checked mode, verifies the type.
+ Function([int x]) l281;
+ // The static function f281 sets `T` to `int`.
+ if (!tIsBool) {
+ x281 = f281 as dynamic;
+ l281 = f281 as dynamic;
+ x281 = confuse(f281);
+ l281 = confuse(f281);
+ }
+
+ Expect.isTrue(m281 is F281);
+ Expect.isTrue(m281 is Function([int x]));
+ Expect.isTrue(confuse(m281) is F281);
+ // In checked mode, verifies the type.
+ x281 = m281;
+ l281 = m281;
+ x281 = confuse(m281);
+ l281 = confuse(m281);
+
+ }
+
+ void testF381() {
+ // Function<A>()
+ Expect.isTrue(f381 is F381);
+ Expect.isTrue(confuse(f381) is F381);
+ // In checked mode, verifies the type.
+ Function<A>() l381;
+ // The static function f381 sets `T` to `int`.
+ if (!tIsBool) {
+ x381 = f381 as dynamic;
+ l381 = f381 as dynamic;
+ x381 = confuse(f381);
+ l381 = confuse(f381);
+ }
+
+ Expect.isTrue(m381 is F381);
+ Expect.isTrue(m381 is Function<A>());
+ Expect.isTrue(confuse(m381) is F381);
+ // In checked mode, verifies the type.
+ x381 = m381;
+ l381 = m381;
+ x381 = confuse(m381);
+ l381 = confuse(m381);
+
+ }
+
+ void testF481() {
+ // int Function(int x1, {Function x}) Function(int x)
+ Expect.isTrue(f481 is F481);
+ Expect.isTrue(confuse(f481) is F481);
+ // In checked mode, verifies the type.
+ int Function(int x1, {Function x}) Function(int x) l481;
+ // The static function f481 sets `T` to `int`.
+ if (!tIsBool) {
+ x481 = f481 as dynamic;
+ l481 = f481 as dynamic;
+ x481 = confuse(f481);
+ l481 = confuse(f481);
+ }
+
+ Expect.isTrue(m481 is F481);
+ Expect.isTrue(m481 is int Function(int x1, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m481) is F481);
+ // In checked mode, verifies the type.
+ x481 = m481;
+ l481 = m481;
+ x481 = confuse(m481);
+ l481 = confuse(m481);
+
+ }
+
+ void testF581() {
+ // int Function([List<T> x]) Function(int x)
+ Expect.isTrue(f581 is F581);
+ Expect.isTrue(confuse(f581) is F581);
+ // In checked mode, verifies the type.
+ int Function([List<T> x]) Function(int x) l581;
+ // The static function f581 sets `T` to `int`.
+ if (!tIsBool) {
+ x581 = f581 as dynamic;
+ l581 = f581 as dynamic;
+ x581 = confuse(f581);
+ l581 = confuse(f581);
+ }
+
+ Expect.isTrue(m581 is F581);
+ Expect.isTrue(m581 is int Function([List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m581) is F581);
+ // In checked mode, verifies the type.
+ x581 = m581;
+ l581 = m581;
+ x581 = confuse(m581);
+ l581 = confuse(m581);
+ if (!tIsBool) {
+ Expect.isTrue(f581 is F581<int>);
+ Expect.isFalse(f581 is F581<bool>);
+ Expect.isTrue(confuse(f581) is F581<int>);
+ Expect.isFalse(confuse(f581) is F581<bool>);
+ Expect.equals(tIsDynamic, m581 is F581<bool>);
+ Expect.equals(tIsDynamic, confuse(m581) is F581<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x581 = (f581 as dynamic); });
+ Expect.throws(() { x581 = confuse(f581); });
+ int Function([List<T> x]) Function(int x) l581;
+ Expect.throws(() { l581 = (f581 as dynamic); });
+ Expect.throws(() { l581 = confuse(f581); });
+ }
+ int Function([List<T> x]) Function(int x) l581 = m581;
+ // In checked mode, verifies the type.
+ x581 = m581;
+ x581 = confuse(m581);
+ }
+ }
+
+ void testF681() {
+ // Function Function(int y, [Function x]) Function(int x)
+ Expect.isTrue(f681 is F681);
+ Expect.isTrue(confuse(f681) is F681);
+ // In checked mode, verifies the type.
+ Function Function(int y, [Function x]) Function(int x) l681;
+ // The static function f681 sets `T` to `int`.
+ if (!tIsBool) {
+ x681 = f681 as dynamic;
+ l681 = f681 as dynamic;
+ x681 = confuse(f681);
+ l681 = confuse(f681);
+ }
+
+ Expect.isTrue(m681 is F681);
+ Expect.isTrue(m681 is Function Function(int y, [Function x]) Function(int x));
+ Expect.isTrue(confuse(m681) is F681);
+ // In checked mode, verifies the type.
+ x681 = m681;
+ l681 = m681;
+ x681 = confuse(m681);
+ l681 = confuse(m681);
+
+ }
+
+ void testF781() {
+ // Function Function(int x2, [core.List<core.int> x3]) Function(int x)
+ Expect.isTrue(f781 is F781);
+ Expect.isTrue(confuse(f781) is F781);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [core.List<core.int> x3]) Function(int x) l781;
+ // The static function f781 sets `T` to `int`.
+ if (!tIsBool) {
+ x781 = f781 as dynamic;
+ l781 = f781 as dynamic;
+ x781 = confuse(f781);
+ l781 = confuse(f781);
+ }
+
+ Expect.isTrue(m781 is F781);
+ Expect.isTrue(m781 is Function Function(int x2, [core.List<core.int> x3]) Function(int x));
+ Expect.isTrue(confuse(m781) is F781);
+ // In checked mode, verifies the type.
+ x781 = m781;
+ l781 = m781;
+ x781 = confuse(m781);
+ l781 = confuse(m781);
+
+ }
+
+ void testF881() {
+ // List<Function> Function({int x}) Function(int x)
+ Expect.isTrue(f881 is F881);
+ Expect.isTrue(confuse(f881) is F881);
+ // In checked mode, verifies the type.
+ List<Function> Function({int x}) Function(int x) l881;
+ // The static function f881 sets `T` to `int`.
+ if (!tIsBool) {
+ x881 = f881 as dynamic;
+ l881 = f881 as dynamic;
+ x881 = confuse(f881);
+ l881 = confuse(f881);
+ }
+
+ Expect.isTrue(m881 is F881);
+ Expect.isTrue(m881 is List<Function> Function({int x}) Function(int x));
+ Expect.isTrue(confuse(m881) is F881);
+ // In checked mode, verifies the type.
+ x881 = m881;
+ l881 = m881;
+ x881 = confuse(m881);
+ l881 = confuse(m881);
+
+ }
+
+ void testF981() {
+ // List<Function> Function(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f981 is F981);
+ Expect.isTrue(confuse(f981) is F981);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x) Function(int x) l981;
+ // The static function f981 sets `T` to `int`.
+ if (!tIsBool) {
+ x981 = f981 as dynamic;
+ l981 = f981 as dynamic;
+ x981 = confuse(f981);
+ l981 = confuse(f981);
+ }
+
+ Expect.isTrue(m981 is F981);
+ Expect.isTrue(m981 is List<Function> Function(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m981) is F981);
+ // In checked mode, verifies the type.
+ x981 = m981;
+ l981 = m981;
+ x981 = confuse(m981);
+ l981 = confuse(m981);
+
+ }
+
+ void testF1081() {
+ // core.List<core.int> Function(int x1, [int x]) Function(int x)
+ Expect.isTrue(f1081 is F1081);
+ Expect.isTrue(confuse(f1081) is F1081);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [int x]) Function(int x) l1081;
+ // The static function f1081 sets `T` to `int`.
+ if (!tIsBool) {
+ x1081 = f1081 as dynamic;
+ l1081 = f1081 as dynamic;
+ x1081 = confuse(f1081);
+ l1081 = confuse(f1081);
+ }
+
+ Expect.isTrue(m1081 is F1081);
+ Expect.isTrue(m1081 is core.List<core.int> Function(int x1, [int x]) Function(int x));
+ Expect.isTrue(confuse(m1081) is F1081);
+ // In checked mode, verifies the type.
+ x1081 = m1081;
+ l1081 = m1081;
+ x1081 = confuse(m1081);
+ l1081 = confuse(m1081);
+
+ }
+
+ void testF1181() {
+ // core.List<core.int> Function([List<Function> x1]) Function(int x)
+ Expect.isTrue(f1181 is F1181);
+ Expect.isTrue(confuse(f1181) is F1181);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x1]) Function(int x) l1181;
+ // The static function f1181 sets `T` to `int`.
+ if (!tIsBool) {
+ x1181 = f1181 as dynamic;
+ l1181 = f1181 as dynamic;
+ x1181 = confuse(f1181);
+ l1181 = confuse(f1181);
+ }
+
+ Expect.isTrue(m1181 is F1181);
+ Expect.isTrue(m1181 is core.List<core.int> Function([List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m1181) is F1181);
+ // In checked mode, verifies the type.
+ x1181 = m1181;
+ l1181 = m1181;
+ x1181 = confuse(m1181);
+ l1181 = confuse(m1181);
+
+ }
+
+ void testF1281() {
+ // core.List<core.int> Function({List<T> x}) Function(int x)
+ Expect.isTrue(f1281 is F1281);
+ Expect.isTrue(confuse(f1281) is F1281);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<T> x}) Function(int x) l1281;
+ // The static function f1281 sets `T` to `int`.
+ if (!tIsBool) {
+ x1281 = f1281 as dynamic;
+ l1281 = f1281 as dynamic;
+ x1281 = confuse(f1281);
+ l1281 = confuse(f1281);
+ }
+
+ Expect.isTrue(m1281 is F1281);
+ Expect.isTrue(m1281 is core.List<core.int> Function({List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1281) is F1281);
+ // In checked mode, verifies the type.
+ x1281 = m1281;
+ l1281 = m1281;
+ x1281 = confuse(m1281);
+ l1281 = confuse(m1281);
+ if (!tIsBool) {
+ Expect.isTrue(f1281 is F1281<int>);
+ Expect.isFalse(f1281 is F1281<bool>);
+ Expect.isTrue(confuse(f1281) is F1281<int>);
+ Expect.isFalse(confuse(f1281) is F1281<bool>);
+ Expect.equals(tIsDynamic, m1281 is F1281<bool>);
+ Expect.equals(tIsDynamic, confuse(m1281) is F1281<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1281 = (f1281 as dynamic); });
+ Expect.throws(() { x1281 = confuse(f1281); });
+ core.List<core.int> Function({List<T> x}) Function(int x) l1281;
+ Expect.throws(() { l1281 = (f1281 as dynamic); });
+ Expect.throws(() { l1281 = confuse(f1281); });
+ }
+ core.List<core.int> Function({List<T> x}) Function(int x) l1281 = m1281;
+ // In checked mode, verifies the type.
+ x1281 = m1281;
+ x1281 = confuse(m1281);
+ }
+ }
+
+ void testF1381() {
+ // List<T> Function(int y, {Function x}) Function(int x)
+ Expect.isTrue(f1381 is F1381);
+ Expect.isTrue(confuse(f1381) is F1381);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {Function x}) Function(int x) l1381;
+ // The static function f1381 sets `T` to `int`.
+ if (!tIsBool) {
+ x1381 = f1381 as dynamic;
+ l1381 = f1381 as dynamic;
+ x1381 = confuse(f1381);
+ l1381 = confuse(f1381);
+ }
+
+ Expect.isTrue(m1381 is F1381);
+ Expect.isTrue(m1381 is List<T> Function(int y, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m1381) is F1381);
+ // In checked mode, verifies the type.
+ x1381 = m1381;
+ l1381 = m1381;
+ x1381 = confuse(m1381);
+ l1381 = confuse(m1381);
+ if (!tIsBool) {
+ Expect.isTrue(f1381 is F1381<int>);
+ Expect.isFalse(f1381 is F1381<bool>);
+ Expect.isTrue(confuse(f1381) is F1381<int>);
+ Expect.isFalse(confuse(f1381) is F1381<bool>);
+ Expect.equals(tIsDynamic, m1381 is F1381<bool>);
+ Expect.equals(tIsDynamic, confuse(m1381) is F1381<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1381 = (f1381 as dynamic); });
+ Expect.throws(() { x1381 = confuse(f1381); });
+ List<T> Function(int y, {Function x}) Function(int x) l1381;
+ Expect.throws(() { l1381 = (f1381 as dynamic); });
+ Expect.throws(() { l1381 = confuse(f1381); });
+ }
+ List<T> Function(int y, {Function x}) Function(int x) l1381 = m1381;
+ // In checked mode, verifies the type.
+ x1381 = m1381;
+ x1381 = confuse(m1381);
+ }
+ }
+
+ void testF1481() {
+ // List<T> Function(int x1, [List<T> x]) Function(int x)
+ Expect.isTrue(f1481 is F1481);
+ Expect.isTrue(confuse(f1481) is F1481);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<T> x]) Function(int x) l1481;
+ // The static function f1481 sets `T` to `int`.
+ if (!tIsBool) {
+ x1481 = f1481 as dynamic;
+ l1481 = f1481 as dynamic;
+ x1481 = confuse(f1481);
+ l1481 = confuse(f1481);
+ }
+
+ Expect.isTrue(m1481 is F1481);
+ Expect.isTrue(m1481 is List<T> Function(int x1, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1481) is F1481);
+ // In checked mode, verifies the type.
+ x1481 = m1481;
+ l1481 = m1481;
+ x1481 = confuse(m1481);
+ l1481 = confuse(m1481);
+ if (!tIsBool) {
+ Expect.isTrue(f1481 is F1481<int>);
+ Expect.isFalse(f1481 is F1481<bool>);
+ Expect.isTrue(confuse(f1481) is F1481<int>);
+ Expect.isFalse(confuse(f1481) is F1481<bool>);
+ Expect.equals(tIsDynamic, m1481 is F1481<bool>);
+ Expect.equals(tIsDynamic, confuse(m1481) is F1481<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1481 = (f1481 as dynamic); });
+ Expect.throws(() { x1481 = confuse(f1481); });
+ List<T> Function(int x1, [List<T> x]) Function(int x) l1481;
+ Expect.throws(() { l1481 = (f1481 as dynamic); });
+ Expect.throws(() { l1481 = confuse(f1481); });
+ }
+ List<T> Function(int x1, [List<T> x]) Function(int x) l1481 = m1481;
+ // In checked mode, verifies the type.
+ x1481 = m1481;
+ x1481 = confuse(m1481);
+ }
+ }
+
+ void testF1581() {
+ // Function(Function x1) Function(int x)
+ Expect.isTrue(f1581 is F1581);
+ Expect.isTrue(confuse(f1581) is F1581);
+ // In checked mode, verifies the type.
+ Function(Function x1) Function(int x) l1581;
+ // The static function f1581 sets `T` to `int`.
+ if (!tIsBool) {
+ x1581 = f1581 as dynamic;
+ l1581 = f1581 as dynamic;
+ x1581 = confuse(f1581);
+ l1581 = confuse(f1581);
+ }
+
+ Expect.isTrue(m1581 is F1581);
+ Expect.isTrue(m1581 is Function(Function x1) Function(int x));
+ Expect.isTrue(confuse(m1581) is F1581);
+ // In checked mode, verifies the type.
+ x1581 = m1581;
+ l1581 = m1581;
+ x1581 = confuse(m1581);
+ l1581 = confuse(m1581);
+
+ }
+
+ void testF1681() {
+ // Function(int x, [core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f1681 is F1681);
+ Expect.isTrue(confuse(f1681) is F1681);
+ // In checked mode, verifies the type.
+ Function(int x, [core.List<core.int> x1]) Function(int x) l1681;
+ // The static function f1681 sets `T` to `int`.
+ if (!tIsBool) {
+ x1681 = f1681 as dynamic;
+ l1681 = f1681 as dynamic;
+ x1681 = confuse(f1681);
+ l1681 = confuse(f1681);
+ }
+
+ Expect.isTrue(m1681 is F1681);
+ Expect.isTrue(m1681 is Function(int x, [core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m1681) is F1681);
+ // In checked mode, verifies the type.
+ x1681 = m1681;
+ l1681 = m1681;
+ x1681 = confuse(m1681);
+ l1681 = confuse(m1681);
+
+ }
+
+ void testF1781() {
+ // Function Function<A>(Function x) Function(int x)
+ Expect.isTrue(f1781 is F1781);
+ Expect.isTrue(confuse(f1781) is F1781);
+ // In checked mode, verifies the type.
+ Function Function<A>(Function x) Function(int x) l1781;
+ // The static function f1781 sets `T` to `int`.
+ if (!tIsBool) {
+ x1781 = f1781 as dynamic;
+ l1781 = f1781 as dynamic;
+ x1781 = confuse(f1781);
+ l1781 = confuse(f1781);
+ }
+
+ Expect.isTrue(m1781 is F1781);
+ Expect.isTrue(m1781 is Function Function<A>(Function x) Function(int x));
+ Expect.isTrue(confuse(m1781) is F1781);
+ // In checked mode, verifies the type.
+ x1781 = m1781;
+ l1781 = m1781;
+ x1781 = confuse(m1781);
+ l1781 = confuse(m1781);
+
+ }
+
+ void testF1881() {
+ // List<T> Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1881 is F1881);
+ Expect.isTrue(confuse(f1881) is F1881);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<Function> x) Function(int x) l1881;
+ // The static function f1881 sets `T` to `int`.
+ if (!tIsBool) {
+ x1881 = f1881 as dynamic;
+ l1881 = f1881 as dynamic;
+ x1881 = confuse(f1881);
+ l1881 = confuse(f1881);
+ }
+
+ Expect.isTrue(m1881 is F1881);
+ Expect.isTrue(m1881 is List<T> Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1881) is F1881);
+ // In checked mode, verifies the type.
+ x1881 = m1881;
+ l1881 = m1881;
+ x1881 = confuse(m1881);
+ l1881 = confuse(m1881);
+ if (!tIsBool) {
+ Expect.isTrue(f1881 is F1881<int>);
+ Expect.isFalse(f1881 is F1881<bool>);
+ Expect.isTrue(confuse(f1881) is F1881<int>);
+ Expect.isFalse(confuse(f1881) is F1881<bool>);
+ Expect.equals(tIsDynamic, m1881 is F1881<bool>);
+ Expect.equals(tIsDynamic, confuse(m1881) is F1881<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1881 = (f1881 as dynamic); });
+ Expect.throws(() { x1881 = confuse(f1881); });
+ List<T> Function<A>(List<Function> x) Function(int x) l1881;
+ Expect.throws(() { l1881 = (f1881 as dynamic); });
+ Expect.throws(() { l1881 = confuse(f1881); });
+ }
+ List<T> Function<A>(List<Function> x) Function(int x) l1881 = m1881;
+ // In checked mode, verifies the type.
+ x1881 = m1881;
+ x1881 = confuse(m1881);
+ }
+ }
+
+ void testF1981() {
+ // List<A> Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1981 is F1981);
+ Expect.isTrue(confuse(f1981) is F1981);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(core.List<core.int> x) Function(int x) l1981;
+ // The static function f1981 sets `T` to `int`.
+ if (!tIsBool) {
+ x1981 = f1981 as dynamic;
+ l1981 = f1981 as dynamic;
+ x1981 = confuse(f1981);
+ l1981 = confuse(f1981);
+ }
+
+ Expect.isTrue(m1981 is F1981);
+ Expect.isTrue(m1981 is List<A> Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1981) is F1981);
+ // In checked mode, verifies the type.
+ x1981 = m1981;
+ l1981 = m1981;
+ x1981 = confuse(m1981);
+ l1981 = confuse(m1981);
+
+ }
+
+
+}
+
+class C82<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(List<Function> x0) x82;
+ core.List<core.int> Function(int y, [Function x]) x182;
+ Function(int x0, [int x]) x282;
+ Function<A>(A x) x382;
+ int Function(int x1, {Function x}) Function<B extends core.int>() x482;
+ int Function([List<T> x]) Function<B extends core.int>() x582;
+ Function Function(int y, [Function x]) Function<B extends core.int>() x682;
+ Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() x782;
+ List<Function> Function({int x}) Function<B extends core.int>() x882;
+ List<Function> Function(core.List<core.int> x) Function<B extends core.int>() x982;
+ core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>() x1082;
+ core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>() x1182;
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>() x1282;
+ List<T> Function(int y, {Function x}) Function<B extends core.int>() x1382;
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>() x1482;
+ Function(Function x1) Function<B extends core.int>() x1582;
+ Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() x1682;
+ Function Function<A>(Function x) Function<B extends core.int>() x1782;
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>() x1882;
+ List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>() x1982;
+
+
+ C82({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m82(List<Function> x0) => null;
+ core.List<core.int> m182(int y, [Function x]) => null;
+ m282(int x0, [int x]) => null;
+ m382<A>(A x) => null;
+ int Function(int x0, {Function x}) m482<B extends core.int>() => null;
+ int Function([List<T> x]) m582<B extends core.int>() => null;
+ Function Function(int y, [Function x]) m682<B extends core.int>() => null;
+ Function Function(int x0, [core.List<core.int> x1]) m782<B extends core.int>() => null;
+ List<Function> Function({int x}) m882<B extends core.int>() => null;
+ List<Function> Function(core.List<core.int> x) m982<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [int x]) m1082<B extends core.int>() => null;
+ core.List<core.int> Function([List<Function> x0]) m1182<B extends core.int>() => null;
+ core.List<core.int> Function({List<T> x}) m1282<B extends core.int>() => null;
+ List<T> Function(int y, {Function x}) m1382<B extends core.int>() => null;
+ List<T> Function(int x0, [List<T> x]) m1482<B extends core.int>() => null;
+ Function(Function x0) m1582<B extends core.int>() => null;
+ Function(int x, [core.List<core.int> x0]) m1682<B extends core.int>() => null;
+ Function Function<A>(Function x) m1782<B extends core.int>() => null;
+ List<T> Function<A>(List<Function> x) m1882<B extends core.int>() => null;
+ List<A> Function<A>(core.List<core.int> x) m1982<B extends core.int>() => null;
+
+
+ runTests() {
+ testF82();
+ testF182();
+ testF282();
+ testF382();
+ testF482();
+ testF582();
+ testF682();
+ testF782();
+ testF882();
+ testF982();
+ testF1082();
+ testF1182();
+ testF1282();
+ testF1382();
+ testF1482();
+ testF1582();
+ testF1682();
+ testF1782();
+ testF1882();
+ testF1982();
+ }
+
+ void testF82() {
+ // Function Function(List<Function> x0)
+ Expect.isTrue(f82 is F82);
+ Expect.isTrue(confuse(f82) is F82);
+ // In checked mode, verifies the type.
+ Function Function(List<Function> x0) l82;
+ // The static function f82 sets `T` to `int`.
+ if (!tIsBool) {
+ x82 = f82 as dynamic;
+ l82 = f82 as dynamic;
+ x82 = confuse(f82);
+ l82 = confuse(f82);
+ }
+
+ Expect.isTrue(m82 is F82);
+ Expect.isTrue(m82 is Function Function(List<Function> x0));
+ Expect.isTrue(confuse(m82) is F82);
+ // In checked mode, verifies the type.
+ x82 = m82;
+ l82 = m82;
+ x82 = confuse(m82);
+ l82 = confuse(m82);
+
+ }
+
+ void testF182() {
+ // core.List<core.int> Function(int y, [Function x])
+ Expect.isTrue(f182 is F182);
+ Expect.isTrue(confuse(f182) is F182);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [Function x]) l182;
+ // The static function f182 sets `T` to `int`.
+ if (!tIsBool) {
+ x182 = f182 as dynamic;
+ l182 = f182 as dynamic;
+ x182 = confuse(f182);
+ l182 = confuse(f182);
+ }
+
+ Expect.isTrue(m182 is F182);
+ Expect.isTrue(m182 is core.List<core.int> Function(int y, [Function x]));
+ Expect.isTrue(confuse(m182) is F182);
+ // In checked mode, verifies the type.
+ x182 = m182;
+ l182 = m182;
+ x182 = confuse(m182);
+ l182 = confuse(m182);
+
+ }
+
+ void testF282() {
+ // Function(int x0, [int x])
+ Expect.isTrue(f282 is F282);
+ Expect.isTrue(confuse(f282) is F282);
+ // In checked mode, verifies the type.
+ Function(int x0, [int x]) l282;
+ // The static function f282 sets `T` to `int`.
+ if (!tIsBool) {
+ x282 = f282 as dynamic;
+ l282 = f282 as dynamic;
+ x282 = confuse(f282);
+ l282 = confuse(f282);
+ }
+
+ Expect.isTrue(m282 is F282);
+ Expect.isTrue(m282 is Function(int x0, [int x]));
+ Expect.isTrue(confuse(m282) is F282);
+ // In checked mode, verifies the type.
+ x282 = m282;
+ l282 = m282;
+ x282 = confuse(m282);
+ l282 = confuse(m282);
+
+ }
+
+ void testF382() {
+ // Function<A>(A x)
+ Expect.isTrue(f382 is F382);
+ Expect.isTrue(confuse(f382) is F382);
+ // In checked mode, verifies the type.
+ Function<A>(A x) l382;
+ // The static function f382 sets `T` to `int`.
+ if (!tIsBool) {
+ x382 = f382 as dynamic;
+ l382 = f382 as dynamic;
+ x382 = confuse(f382);
+ l382 = confuse(f382);
+ }
+
+ Expect.isTrue(m382 is F382);
+ Expect.isTrue(m382 is Function<A>(A x));
+ Expect.isTrue(confuse(m382) is F382);
+ // In checked mode, verifies the type.
+ x382 = m382;
+ l382 = m382;
+ x382 = confuse(m382);
+ l382 = confuse(m382);
+
+ }
+
+ void testF482() {
+ // int Function(int x1, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f482 is F482);
+ Expect.isTrue(confuse(f482) is F482);
+ // In checked mode, verifies the type.
+ int Function(int x1, {Function x}) Function<B extends core.int>() l482;
+ // The static function f482 sets `T` to `int`.
+ if (!tIsBool) {
+ x482 = f482 as dynamic;
+ l482 = f482 as dynamic;
+ x482 = confuse(f482);
+ l482 = confuse(f482);
+ }
+
+ Expect.isTrue(m482 is F482);
+ Expect.isTrue(m482 is int Function(int x1, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m482) is F482);
+ // In checked mode, verifies the type.
+ x482 = m482;
+ l482 = m482;
+ x482 = confuse(m482);
+ l482 = confuse(m482);
+
+ }
+
+ void testF582() {
+ // int Function([List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f582 is F582);
+ Expect.isTrue(confuse(f582) is F582);
+ // In checked mode, verifies the type.
+ int Function([List<T> x]) Function<B extends core.int>() l582;
+ // The static function f582 sets `T` to `int`.
+ if (!tIsBool) {
+ x582 = f582 as dynamic;
+ l582 = f582 as dynamic;
+ x582 = confuse(f582);
+ l582 = confuse(f582);
+ }
+
+ Expect.isTrue(m582 is F582);
+ Expect.isTrue(m582 is int Function([List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m582) is F582);
+ // In checked mode, verifies the type.
+ x582 = m582;
+ l582 = m582;
+ x582 = confuse(m582);
+ l582 = confuse(m582);
+ if (!tIsBool) {
+ Expect.isTrue(f582 is F582<int>);
+ Expect.isFalse(f582 is F582<bool>);
+ Expect.isTrue(confuse(f582) is F582<int>);
+ Expect.isFalse(confuse(f582) is F582<bool>);
+ Expect.equals(tIsDynamic, m582 is F582<bool>);
+ Expect.equals(tIsDynamic, confuse(m582) is F582<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x582 = (f582 as dynamic); });
+ Expect.throws(() { x582 = confuse(f582); });
+ int Function([List<T> x]) Function<B extends core.int>() l582;
+ Expect.throws(() { l582 = (f582 as dynamic); });
+ Expect.throws(() { l582 = confuse(f582); });
+ }
+ int Function([List<T> x]) Function<B extends core.int>() l582 = m582;
+ // In checked mode, verifies the type.
+ x582 = m582;
+ x582 = confuse(m582);
+ }
+ }
+
+ void testF682() {
+ // Function Function(int y, [Function x]) Function<B extends core.int>()
+ Expect.isTrue(f682 is F682);
+ Expect.isTrue(confuse(f682) is F682);
+ // In checked mode, verifies the type.
+ Function Function(int y, [Function x]) Function<B extends core.int>() l682;
+ // The static function f682 sets `T` to `int`.
+ if (!tIsBool) {
+ x682 = f682 as dynamic;
+ l682 = f682 as dynamic;
+ x682 = confuse(f682);
+ l682 = confuse(f682);
+ }
+
+ Expect.isTrue(m682 is F682);
+ Expect.isTrue(m682 is Function Function(int y, [Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m682) is F682);
+ // In checked mode, verifies the type.
+ x682 = m682;
+ l682 = m682;
+ x682 = confuse(m682);
+ l682 = confuse(m682);
+
+ }
+
+ void testF782() {
+ // Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>()
+ Expect.isTrue(f782 is F782);
+ Expect.isTrue(confuse(f782) is F782);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>() l782;
+ // The static function f782 sets `T` to `int`.
+ if (!tIsBool) {
+ x782 = f782 as dynamic;
+ l782 = f782 as dynamic;
+ x782 = confuse(f782);
+ l782 = confuse(f782);
+ }
+
+ Expect.isTrue(m782 is F782);
+ Expect.isTrue(m782 is Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m782) is F782);
+ // In checked mode, verifies the type.
+ x782 = m782;
+ l782 = m782;
+ x782 = confuse(m782);
+ l782 = confuse(m782);
+
+ }
+
+ void testF882() {
+ // List<Function> Function({int x}) Function<B extends core.int>()
+ Expect.isTrue(f882 is F882);
+ Expect.isTrue(confuse(f882) is F882);
+ // In checked mode, verifies the type.
+ List<Function> Function({int x}) Function<B extends core.int>() l882;
+ // The static function f882 sets `T` to `int`.
+ if (!tIsBool) {
+ x882 = f882 as dynamic;
+ l882 = f882 as dynamic;
+ x882 = confuse(f882);
+ l882 = confuse(f882);
+ }
+
+ Expect.isTrue(m882 is F882);
+ Expect.isTrue(m882 is List<Function> Function({int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m882) is F882);
+ // In checked mode, verifies the type.
+ x882 = m882;
+ l882 = m882;
+ x882 = confuse(m882);
+ l882 = confuse(m882);
+
+ }
+
+ void testF982() {
+ // List<Function> Function(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f982 is F982);
+ Expect.isTrue(confuse(f982) is F982);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x) Function<B extends core.int>() l982;
+ // The static function f982 sets `T` to `int`.
+ if (!tIsBool) {
+ x982 = f982 as dynamic;
+ l982 = f982 as dynamic;
+ x982 = confuse(f982);
+ l982 = confuse(f982);
+ }
+
+ Expect.isTrue(m982 is F982);
+ Expect.isTrue(m982 is List<Function> Function(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m982) is F982);
+ // In checked mode, verifies the type.
+ x982 = m982;
+ l982 = m982;
+ x982 = confuse(m982);
+ l982 = confuse(m982);
+
+ }
+
+ void testF1082() {
+ // core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f1082 is F1082);
+ Expect.isTrue(confuse(f1082) is F1082);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>() l1082;
+ // The static function f1082 sets `T` to `int`.
+ if (!tIsBool) {
+ x1082 = f1082 as dynamic;
+ l1082 = f1082 as dynamic;
+ x1082 = confuse(f1082);
+ l1082 = confuse(f1082);
+ }
+
+ Expect.isTrue(m1082 is F1082);
+ Expect.isTrue(m1082 is core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1082) is F1082);
+ // In checked mode, verifies the type.
+ x1082 = m1082;
+ l1082 = m1082;
+ x1082 = confuse(m1082);
+ l1082 = confuse(m1082);
+
+ }
+
+ void testF1182() {
+ // core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1182 is F1182);
+ Expect.isTrue(confuse(f1182) is F1182);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>() l1182;
+ // The static function f1182 sets `T` to `int`.
+ if (!tIsBool) {
+ x1182 = f1182 as dynamic;
+ l1182 = f1182 as dynamic;
+ x1182 = confuse(f1182);
+ l1182 = confuse(f1182);
+ }
+
+ Expect.isTrue(m1182 is F1182);
+ Expect.isTrue(m1182 is core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1182) is F1182);
+ // In checked mode, verifies the type.
+ x1182 = m1182;
+ l1182 = m1182;
+ x1182 = confuse(m1182);
+ l1182 = confuse(m1182);
+
+ }
+
+ void testF1282() {
+ // core.List<core.int> Function({List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1282 is F1282);
+ Expect.isTrue(confuse(f1282) is F1282);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>() l1282;
+ // The static function f1282 sets `T` to `int`.
+ if (!tIsBool) {
+ x1282 = f1282 as dynamic;
+ l1282 = f1282 as dynamic;
+ x1282 = confuse(f1282);
+ l1282 = confuse(f1282);
+ }
+
+ Expect.isTrue(m1282 is F1282);
+ Expect.isTrue(m1282 is core.List<core.int> Function({List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1282) is F1282);
+ // In checked mode, verifies the type.
+ x1282 = m1282;
+ l1282 = m1282;
+ x1282 = confuse(m1282);
+ l1282 = confuse(m1282);
+ if (!tIsBool) {
+ Expect.isTrue(f1282 is F1282<int>);
+ Expect.isFalse(f1282 is F1282<bool>);
+ Expect.isTrue(confuse(f1282) is F1282<int>);
+ Expect.isFalse(confuse(f1282) is F1282<bool>);
+ Expect.equals(tIsDynamic, m1282 is F1282<bool>);
+ Expect.equals(tIsDynamic, confuse(m1282) is F1282<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1282 = (f1282 as dynamic); });
+ Expect.throws(() { x1282 = confuse(f1282); });
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>() l1282;
+ Expect.throws(() { l1282 = (f1282 as dynamic); });
+ Expect.throws(() { l1282 = confuse(f1282); });
+ }
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>() l1282 = m1282;
+ // In checked mode, verifies the type.
+ x1282 = m1282;
+ x1282 = confuse(m1282);
+ }
+ }
+
+ void testF1382() {
+ // List<T> Function(int y, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1382 is F1382);
+ Expect.isTrue(confuse(f1382) is F1382);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {Function x}) Function<B extends core.int>() l1382;
+ // The static function f1382 sets `T` to `int`.
+ if (!tIsBool) {
+ x1382 = f1382 as dynamic;
+ l1382 = f1382 as dynamic;
+ x1382 = confuse(f1382);
+ l1382 = confuse(f1382);
+ }
+
+ Expect.isTrue(m1382 is F1382);
+ Expect.isTrue(m1382 is List<T> Function(int y, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1382) is F1382);
+ // In checked mode, verifies the type.
+ x1382 = m1382;
+ l1382 = m1382;
+ x1382 = confuse(m1382);
+ l1382 = confuse(m1382);
+ if (!tIsBool) {
+ Expect.isTrue(f1382 is F1382<int>);
+ Expect.isFalse(f1382 is F1382<bool>);
+ Expect.isTrue(confuse(f1382) is F1382<int>);
+ Expect.isFalse(confuse(f1382) is F1382<bool>);
+ Expect.equals(tIsDynamic, m1382 is F1382<bool>);
+ Expect.equals(tIsDynamic, confuse(m1382) is F1382<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1382 = (f1382 as dynamic); });
+ Expect.throws(() { x1382 = confuse(f1382); });
+ List<T> Function(int y, {Function x}) Function<B extends core.int>() l1382;
+ Expect.throws(() { l1382 = (f1382 as dynamic); });
+ Expect.throws(() { l1382 = confuse(f1382); });
+ }
+ List<T> Function(int y, {Function x}) Function<B extends core.int>() l1382 = m1382;
+ // In checked mode, verifies the type.
+ x1382 = m1382;
+ x1382 = confuse(m1382);
+ }
+ }
+
+ void testF1482() {
+ // List<T> Function(int x1, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1482 is F1482);
+ Expect.isTrue(confuse(f1482) is F1482);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>() l1482;
+ // The static function f1482 sets `T` to `int`.
+ if (!tIsBool) {
+ x1482 = f1482 as dynamic;
+ l1482 = f1482 as dynamic;
+ x1482 = confuse(f1482);
+ l1482 = confuse(f1482);
+ }
+
+ Expect.isTrue(m1482 is F1482);
+ Expect.isTrue(m1482 is List<T> Function(int x1, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1482) is F1482);
+ // In checked mode, verifies the type.
+ x1482 = m1482;
+ l1482 = m1482;
+ x1482 = confuse(m1482);
+ l1482 = confuse(m1482);
+ if (!tIsBool) {
+ Expect.isTrue(f1482 is F1482<int>);
+ Expect.isFalse(f1482 is F1482<bool>);
+ Expect.isTrue(confuse(f1482) is F1482<int>);
+ Expect.isFalse(confuse(f1482) is F1482<bool>);
+ Expect.equals(tIsDynamic, m1482 is F1482<bool>);
+ Expect.equals(tIsDynamic, confuse(m1482) is F1482<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1482 = (f1482 as dynamic); });
+ Expect.throws(() { x1482 = confuse(f1482); });
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>() l1482;
+ Expect.throws(() { l1482 = (f1482 as dynamic); });
+ Expect.throws(() { l1482 = confuse(f1482); });
+ }
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>() l1482 = m1482;
+ // In checked mode, verifies the type.
+ x1482 = m1482;
+ x1482 = confuse(m1482);
+ }
+ }
+
+ void testF1582() {
+ // Function(Function x1) Function<B extends core.int>()
+ Expect.isTrue(f1582 is F1582);
+ Expect.isTrue(confuse(f1582) is F1582);
+ // In checked mode, verifies the type.
+ Function(Function x1) Function<B extends core.int>() l1582;
+ // The static function f1582 sets `T` to `int`.
+ if (!tIsBool) {
+ x1582 = f1582 as dynamic;
+ l1582 = f1582 as dynamic;
+ x1582 = confuse(f1582);
+ l1582 = confuse(f1582);
+ }
+
+ Expect.isTrue(m1582 is F1582);
+ Expect.isTrue(m1582 is Function(Function x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1582) is F1582);
+ // In checked mode, verifies the type.
+ x1582 = m1582;
+ l1582 = m1582;
+ x1582 = confuse(m1582);
+ l1582 = confuse(m1582);
+
+ }
+
+ void testF1682() {
+ // Function(int x, [core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1682 is F1682);
+ Expect.isTrue(confuse(f1682) is F1682);
+ // In checked mode, verifies the type.
+ Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l1682;
+ // The static function f1682 sets `T` to `int`.
+ if (!tIsBool) {
+ x1682 = f1682 as dynamic;
+ l1682 = f1682 as dynamic;
+ x1682 = confuse(f1682);
+ l1682 = confuse(f1682);
+ }
+
+ Expect.isTrue(m1682 is F1682);
+ Expect.isTrue(m1682 is Function(int x, [core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1682) is F1682);
+ // In checked mode, verifies the type.
+ x1682 = m1682;
+ l1682 = m1682;
+ x1682 = confuse(m1682);
+ l1682 = confuse(m1682);
+
+ }
+
+ void testF1782() {
+ // Function Function<A>(Function x) Function<B extends core.int>()
+ Expect.isTrue(f1782 is F1782);
+ Expect.isTrue(confuse(f1782) is F1782);
+ // In checked mode, verifies the type.
+ Function Function<A>(Function x) Function<B extends core.int>() l1782;
+ // The static function f1782 sets `T` to `int`.
+ if (!tIsBool) {
+ x1782 = f1782 as dynamic;
+ l1782 = f1782 as dynamic;
+ x1782 = confuse(f1782);
+ l1782 = confuse(f1782);
+ }
+
+ Expect.isTrue(m1782 is F1782);
+ Expect.isTrue(m1782 is Function Function<A>(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1782) is F1782);
+ // In checked mode, verifies the type.
+ x1782 = m1782;
+ l1782 = m1782;
+ x1782 = confuse(m1782);
+ l1782 = confuse(m1782);
+
+ }
+
+ void testF1882() {
+ // List<T> Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1882 is F1882);
+ Expect.isTrue(confuse(f1882) is F1882);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>() l1882;
+ // The static function f1882 sets `T` to `int`.
+ if (!tIsBool) {
+ x1882 = f1882 as dynamic;
+ l1882 = f1882 as dynamic;
+ x1882 = confuse(f1882);
+ l1882 = confuse(f1882);
+ }
+
+ Expect.isTrue(m1882 is F1882);
+ Expect.isTrue(m1882 is List<T> Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1882) is F1882);
+ // In checked mode, verifies the type.
+ x1882 = m1882;
+ l1882 = m1882;
+ x1882 = confuse(m1882);
+ l1882 = confuse(m1882);
+ if (!tIsBool) {
+ Expect.isTrue(f1882 is F1882<int>);
+ Expect.isFalse(f1882 is F1882<bool>);
+ Expect.isTrue(confuse(f1882) is F1882<int>);
+ Expect.isFalse(confuse(f1882) is F1882<bool>);
+ Expect.equals(tIsDynamic, m1882 is F1882<bool>);
+ Expect.equals(tIsDynamic, confuse(m1882) is F1882<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1882 = (f1882 as dynamic); });
+ Expect.throws(() { x1882 = confuse(f1882); });
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>() l1882;
+ Expect.throws(() { l1882 = (f1882 as dynamic); });
+ Expect.throws(() { l1882 = confuse(f1882); });
+ }
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>() l1882 = m1882;
+ // In checked mode, verifies the type.
+ x1882 = m1882;
+ x1882 = confuse(m1882);
+ }
+ }
+
+ void testF1982() {
+ // List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1982 is F1982);
+ Expect.isTrue(confuse(f1982) is F1982);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>() l1982;
+ // The static function f1982 sets `T` to `int`.
+ if (!tIsBool) {
+ x1982 = f1982 as dynamic;
+ l1982 = f1982 as dynamic;
+ x1982 = confuse(f1982);
+ l1982 = confuse(f1982);
+ }
+
+ Expect.isTrue(m1982 is F1982);
+ Expect.isTrue(m1982 is List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1982) is F1982);
+ // In checked mode, verifies the type.
+ x1982 = m1982;
+ l1982 = m1982;
+ x1982 = confuse(m1982);
+ l1982 = confuse(m1982);
+
+ }
+
+
+}
+
+class C83<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([List<Function> x1]) x83;
+ core.List<core.int> Function(Function x0) x183;
+ Function(int y, [int x]) x283;
+ Function<A>(List<A> x) x383;
+ int Function(int x1, {Function x}) Function<B extends core.int>(int x) x483;
+ int Function([List<T> x]) Function<B extends core.int>(int x) x583;
+ Function Function(int y, [Function x]) Function<B extends core.int>(int x) x683;
+ Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) x783;
+ List<Function> Function({int x}) Function<B extends core.int>(int x) x883;
+ List<Function> Function(core.List<core.int> x) Function<B extends core.int>(int x) x983;
+ core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>(int x) x1083;
+ core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>(int x) x1183;
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x) x1283;
+ List<T> Function(int y, {Function x}) Function<B extends core.int>(int x) x1383;
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x1483;
+ Function(Function x1) Function<B extends core.int>(int x) x1583;
+ Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) x1683;
+ Function Function<A>(Function x) Function<B extends core.int>(int x) x1783;
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x) x1883;
+ List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1983;
+
+
+ C83({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m83([List<Function> x0]) => null;
+ core.List<core.int> m183(Function x0) => null;
+ m283(int y, [int x]) => null;
+ m383<A>(List<A> x) => null;
+ int Function(int x0, {Function x}) m483<B extends core.int>(int x) => null;
+ int Function([List<T> x]) m583<B extends core.int>(int x) => null;
+ Function Function(int y, [Function x]) m683<B extends core.int>(int x) => null;
+ Function Function(int x0, [core.List<core.int> x1]) m783<B extends core.int>(int x) => null;
+ List<Function> Function({int x}) m883<B extends core.int>(int x) => null;
+ List<Function> Function(core.List<core.int> x) m983<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [int x]) m1083<B extends core.int>(int x) => null;
+ core.List<core.int> Function([List<Function> x0]) m1183<B extends core.int>(int x) => null;
+ core.List<core.int> Function({List<T> x}) m1283<B extends core.int>(int x) => null;
+ List<T> Function(int y, {Function x}) m1383<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [List<T> x]) m1483<B extends core.int>(int x) => null;
+ Function(Function x0) m1583<B extends core.int>(int x) => null;
+ Function(int x, [core.List<core.int> x0]) m1683<B extends core.int>(int x) => null;
+ Function Function<A>(Function x) m1783<B extends core.int>(int x) => null;
+ List<T> Function<A>(List<Function> x) m1883<B extends core.int>(int x) => null;
+ List<A> Function<A>(core.List<core.int> x) m1983<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF83();
+ testF183();
+ testF283();
+ testF383();
+ testF483();
+ testF583();
+ testF683();
+ testF783();
+ testF883();
+ testF983();
+ testF1083();
+ testF1183();
+ testF1283();
+ testF1383();
+ testF1483();
+ testF1583();
+ testF1683();
+ testF1783();
+ testF1883();
+ testF1983();
+ }
+
+ void testF83() {
+ // Function Function([List<Function> x1])
+ Expect.isTrue(f83 is F83);
+ Expect.isTrue(confuse(f83) is F83);
+ // In checked mode, verifies the type.
+ Function Function([List<Function> x1]) l83;
+ // The static function f83 sets `T` to `int`.
+ if (!tIsBool) {
+ x83 = f83 as dynamic;
+ l83 = f83 as dynamic;
+ x83 = confuse(f83);
+ l83 = confuse(f83);
+ }
+
+ Expect.isTrue(m83 is F83);
+ Expect.isTrue(m83 is Function Function([List<Function> x1]));
+ Expect.isTrue(confuse(m83) is F83);
+ // In checked mode, verifies the type.
+ x83 = m83;
+ l83 = m83;
+ x83 = confuse(m83);
+ l83 = confuse(m83);
+
+ }
+
+ void testF183() {
+ // core.List<core.int> Function(Function x0)
+ Expect.isTrue(f183 is F183);
+ Expect.isTrue(confuse(f183) is F183);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(Function x0) l183;
+ // The static function f183 sets `T` to `int`.
+ if (!tIsBool) {
+ x183 = f183 as dynamic;
+ l183 = f183 as dynamic;
+ x183 = confuse(f183);
+ l183 = confuse(f183);
+ }
+
+ Expect.isTrue(m183 is F183);
+ Expect.isTrue(m183 is core.List<core.int> Function(Function x0));
+ Expect.isTrue(confuse(m183) is F183);
+ // In checked mode, verifies the type.
+ x183 = m183;
+ l183 = m183;
+ x183 = confuse(m183);
+ l183 = confuse(m183);
+
+ }
+
+ void testF283() {
+ // Function(int y, [int x])
+ Expect.isTrue(f283 is F283);
+ Expect.isTrue(confuse(f283) is F283);
+ // In checked mode, verifies the type.
+ Function(int y, [int x]) l283;
+ // The static function f283 sets `T` to `int`.
+ if (!tIsBool) {
+ x283 = f283 as dynamic;
+ l283 = f283 as dynamic;
+ x283 = confuse(f283);
+ l283 = confuse(f283);
+ }
+
+ Expect.isTrue(m283 is F283);
+ Expect.isTrue(m283 is Function(int y, [int x]));
+ Expect.isTrue(confuse(m283) is F283);
+ // In checked mode, verifies the type.
+ x283 = m283;
+ l283 = m283;
+ x283 = confuse(m283);
+ l283 = confuse(m283);
+
+ }
+
+ void testF383() {
+ // Function<A>(List<A> x)
+ Expect.isTrue(f383 is F383);
+ Expect.isTrue(confuse(f383) is F383);
+ // In checked mode, verifies the type.
+ Function<A>(List<A> x) l383;
+ // The static function f383 sets `T` to `int`.
+ if (!tIsBool) {
+ x383 = f383 as dynamic;
+ l383 = f383 as dynamic;
+ x383 = confuse(f383);
+ l383 = confuse(f383);
+ }
+
+ Expect.isTrue(m383 is F383);
+ Expect.isTrue(m383 is Function<A>(List<A> x));
+ Expect.isTrue(confuse(m383) is F383);
+ // In checked mode, verifies the type.
+ x383 = m383;
+ l383 = m383;
+ x383 = confuse(m383);
+ l383 = confuse(m383);
+
+ }
+
+ void testF483() {
+ // int Function(int x1, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f483 is F483);
+ Expect.isTrue(confuse(f483) is F483);
+ // In checked mode, verifies the type.
+ int Function(int x1, {Function x}) Function<B extends core.int>(int x) l483;
+ // The static function f483 sets `T` to `int`.
+ if (!tIsBool) {
+ x483 = f483 as dynamic;
+ l483 = f483 as dynamic;
+ x483 = confuse(f483);
+ l483 = confuse(f483);
+ }
+
+ Expect.isTrue(m483 is F483);
+ Expect.isTrue(m483 is int Function(int x1, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m483) is F483);
+ // In checked mode, verifies the type.
+ x483 = m483;
+ l483 = m483;
+ x483 = confuse(m483);
+ l483 = confuse(m483);
+
+ }
+
+ void testF583() {
+ // int Function([List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f583 is F583);
+ Expect.isTrue(confuse(f583) is F583);
+ // In checked mode, verifies the type.
+ int Function([List<T> x]) Function<B extends core.int>(int x) l583;
+ // The static function f583 sets `T` to `int`.
+ if (!tIsBool) {
+ x583 = f583 as dynamic;
+ l583 = f583 as dynamic;
+ x583 = confuse(f583);
+ l583 = confuse(f583);
+ }
+
+ Expect.isTrue(m583 is F583);
+ Expect.isTrue(m583 is int Function([List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m583) is F583);
+ // In checked mode, verifies the type.
+ x583 = m583;
+ l583 = m583;
+ x583 = confuse(m583);
+ l583 = confuse(m583);
+ if (!tIsBool) {
+ Expect.isTrue(f583 is F583<int>);
+ Expect.isFalse(f583 is F583<bool>);
+ Expect.isTrue(confuse(f583) is F583<int>);
+ Expect.isFalse(confuse(f583) is F583<bool>);
+ Expect.equals(tIsDynamic, m583 is F583<bool>);
+ Expect.equals(tIsDynamic, confuse(m583) is F583<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x583 = (f583 as dynamic); });
+ Expect.throws(() { x583 = confuse(f583); });
+ int Function([List<T> x]) Function<B extends core.int>(int x) l583;
+ Expect.throws(() { l583 = (f583 as dynamic); });
+ Expect.throws(() { l583 = confuse(f583); });
+ }
+ int Function([List<T> x]) Function<B extends core.int>(int x) l583 = m583;
+ // In checked mode, verifies the type.
+ x583 = m583;
+ x583 = confuse(m583);
+ }
+ }
+
+ void testF683() {
+ // Function Function(int y, [Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f683 is F683);
+ Expect.isTrue(confuse(f683) is F683);
+ // In checked mode, verifies the type.
+ Function Function(int y, [Function x]) Function<B extends core.int>(int x) l683;
+ // The static function f683 sets `T` to `int`.
+ if (!tIsBool) {
+ x683 = f683 as dynamic;
+ l683 = f683 as dynamic;
+ x683 = confuse(f683);
+ l683 = confuse(f683);
+ }
+
+ Expect.isTrue(m683 is F683);
+ Expect.isTrue(m683 is Function Function(int y, [Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m683) is F683);
+ // In checked mode, verifies the type.
+ x683 = m683;
+ l683 = m683;
+ x683 = confuse(m683);
+ l683 = confuse(m683);
+
+ }
+
+ void testF783() {
+ // Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f783 is F783);
+ Expect.isTrue(confuse(f783) is F783);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x) l783;
+ // The static function f783 sets `T` to `int`.
+ if (!tIsBool) {
+ x783 = f783 as dynamic;
+ l783 = f783 as dynamic;
+ x783 = confuse(f783);
+ l783 = confuse(f783);
+ }
+
+ Expect.isTrue(m783 is F783);
+ Expect.isTrue(m783 is Function Function(int x2, [core.List<core.int> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m783) is F783);
+ // In checked mode, verifies the type.
+ x783 = m783;
+ l783 = m783;
+ x783 = confuse(m783);
+ l783 = confuse(m783);
+
+ }
+
+ void testF883() {
+ // List<Function> Function({int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f883 is F883);
+ Expect.isTrue(confuse(f883) is F883);
+ // In checked mode, verifies the type.
+ List<Function> Function({int x}) Function<B extends core.int>(int x) l883;
+ // The static function f883 sets `T` to `int`.
+ if (!tIsBool) {
+ x883 = f883 as dynamic;
+ l883 = f883 as dynamic;
+ x883 = confuse(f883);
+ l883 = confuse(f883);
+ }
+
+ Expect.isTrue(m883 is F883);
+ Expect.isTrue(m883 is List<Function> Function({int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m883) is F883);
+ // In checked mode, verifies the type.
+ x883 = m883;
+ l883 = m883;
+ x883 = confuse(m883);
+ l883 = confuse(m883);
+
+ }
+
+ void testF983() {
+ // List<Function> Function(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f983 is F983);
+ Expect.isTrue(confuse(f983) is F983);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x) Function<B extends core.int>(int x) l983;
+ // The static function f983 sets `T` to `int`.
+ if (!tIsBool) {
+ x983 = f983 as dynamic;
+ l983 = f983 as dynamic;
+ x983 = confuse(f983);
+ l983 = confuse(f983);
+ }
+
+ Expect.isTrue(m983 is F983);
+ Expect.isTrue(m983 is List<Function> Function(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m983) is F983);
+ // In checked mode, verifies the type.
+ x983 = m983;
+ l983 = m983;
+ x983 = confuse(m983);
+ l983 = confuse(m983);
+
+ }
+
+ void testF1083() {
+ // core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1083 is F1083);
+ Expect.isTrue(confuse(f1083) is F1083);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>(int x) l1083;
+ // The static function f1083 sets `T` to `int`.
+ if (!tIsBool) {
+ x1083 = f1083 as dynamic;
+ l1083 = f1083 as dynamic;
+ x1083 = confuse(f1083);
+ l1083 = confuse(f1083);
+ }
+
+ Expect.isTrue(m1083 is F1083);
+ Expect.isTrue(m1083 is core.List<core.int> Function(int x1, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1083) is F1083);
+ // In checked mode, verifies the type.
+ x1083 = m1083;
+ l1083 = m1083;
+ x1083 = confuse(m1083);
+ l1083 = confuse(m1083);
+
+ }
+
+ void testF1183() {
+ // core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1183 is F1183);
+ Expect.isTrue(confuse(f1183) is F1183);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>(int x) l1183;
+ // The static function f1183 sets `T` to `int`.
+ if (!tIsBool) {
+ x1183 = f1183 as dynamic;
+ l1183 = f1183 as dynamic;
+ x1183 = confuse(f1183);
+ l1183 = confuse(f1183);
+ }
+
+ Expect.isTrue(m1183 is F1183);
+ Expect.isTrue(m1183 is core.List<core.int> Function([List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1183) is F1183);
+ // In checked mode, verifies the type.
+ x1183 = m1183;
+ l1183 = m1183;
+ x1183 = confuse(m1183);
+ l1183 = confuse(m1183);
+
+ }
+
+ void testF1283() {
+ // core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1283 is F1283);
+ Expect.isTrue(confuse(f1283) is F1283);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x) l1283;
+ // The static function f1283 sets `T` to `int`.
+ if (!tIsBool) {
+ x1283 = f1283 as dynamic;
+ l1283 = f1283 as dynamic;
+ x1283 = confuse(f1283);
+ l1283 = confuse(f1283);
+ }
+
+ Expect.isTrue(m1283 is F1283);
+ Expect.isTrue(m1283 is core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1283) is F1283);
+ // In checked mode, verifies the type.
+ x1283 = m1283;
+ l1283 = m1283;
+ x1283 = confuse(m1283);
+ l1283 = confuse(m1283);
+ if (!tIsBool) {
+ Expect.isTrue(f1283 is F1283<int>);
+ Expect.isFalse(f1283 is F1283<bool>);
+ Expect.isTrue(confuse(f1283) is F1283<int>);
+ Expect.isFalse(confuse(f1283) is F1283<bool>);
+ Expect.equals(tIsDynamic, m1283 is F1283<bool>);
+ Expect.equals(tIsDynamic, confuse(m1283) is F1283<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1283 = (f1283 as dynamic); });
+ Expect.throws(() { x1283 = confuse(f1283); });
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x) l1283;
+ Expect.throws(() { l1283 = (f1283 as dynamic); });
+ Expect.throws(() { l1283 = confuse(f1283); });
+ }
+ core.List<core.int> Function({List<T> x}) Function<B extends core.int>(int x) l1283 = m1283;
+ // In checked mode, verifies the type.
+ x1283 = m1283;
+ x1283 = confuse(m1283);
+ }
+ }
+
+ void testF1383() {
+ // List<T> Function(int y, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1383 is F1383);
+ Expect.isTrue(confuse(f1383) is F1383);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, {Function x}) Function<B extends core.int>(int x) l1383;
+ // The static function f1383 sets `T` to `int`.
+ if (!tIsBool) {
+ x1383 = f1383 as dynamic;
+ l1383 = f1383 as dynamic;
+ x1383 = confuse(f1383);
+ l1383 = confuse(f1383);
+ }
+
+ Expect.isTrue(m1383 is F1383);
+ Expect.isTrue(m1383 is List<T> Function(int y, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1383) is F1383);
+ // In checked mode, verifies the type.
+ x1383 = m1383;
+ l1383 = m1383;
+ x1383 = confuse(m1383);
+ l1383 = confuse(m1383);
+ if (!tIsBool) {
+ Expect.isTrue(f1383 is F1383<int>);
+ Expect.isFalse(f1383 is F1383<bool>);
+ Expect.isTrue(confuse(f1383) is F1383<int>);
+ Expect.isFalse(confuse(f1383) is F1383<bool>);
+ Expect.equals(tIsDynamic, m1383 is F1383<bool>);
+ Expect.equals(tIsDynamic, confuse(m1383) is F1383<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1383 = (f1383 as dynamic); });
+ Expect.throws(() { x1383 = confuse(f1383); });
+ List<T> Function(int y, {Function x}) Function<B extends core.int>(int x) l1383;
+ Expect.throws(() { l1383 = (f1383 as dynamic); });
+ Expect.throws(() { l1383 = confuse(f1383); });
+ }
+ List<T> Function(int y, {Function x}) Function<B extends core.int>(int x) l1383 = m1383;
+ // In checked mode, verifies the type.
+ x1383 = m1383;
+ x1383 = confuse(m1383);
+ }
+ }
+
+ void testF1483() {
+ // List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1483 is F1483);
+ Expect.isTrue(confuse(f1483) is F1483);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1483;
+ // The static function f1483 sets `T` to `int`.
+ if (!tIsBool) {
+ x1483 = f1483 as dynamic;
+ l1483 = f1483 as dynamic;
+ x1483 = confuse(f1483);
+ l1483 = confuse(f1483);
+ }
+
+ Expect.isTrue(m1483 is F1483);
+ Expect.isTrue(m1483 is List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1483) is F1483);
+ // In checked mode, verifies the type.
+ x1483 = m1483;
+ l1483 = m1483;
+ x1483 = confuse(m1483);
+ l1483 = confuse(m1483);
+ if (!tIsBool) {
+ Expect.isTrue(f1483 is F1483<int>);
+ Expect.isFalse(f1483 is F1483<bool>);
+ Expect.isTrue(confuse(f1483) is F1483<int>);
+ Expect.isFalse(confuse(f1483) is F1483<bool>);
+ Expect.equals(tIsDynamic, m1483 is F1483<bool>);
+ Expect.equals(tIsDynamic, confuse(m1483) is F1483<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1483 = (f1483 as dynamic); });
+ Expect.throws(() { x1483 = confuse(f1483); });
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1483;
+ Expect.throws(() { l1483 = (f1483 as dynamic); });
+ Expect.throws(() { l1483 = confuse(f1483); });
+ }
+ List<T> Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l1483 = m1483;
+ // In checked mode, verifies the type.
+ x1483 = m1483;
+ x1483 = confuse(m1483);
+ }
+ }
+
+ void testF1583() {
+ // Function(Function x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1583 is F1583);
+ Expect.isTrue(confuse(f1583) is F1583);
+ // In checked mode, verifies the type.
+ Function(Function x1) Function<B extends core.int>(int x) l1583;
+ // The static function f1583 sets `T` to `int`.
+ if (!tIsBool) {
+ x1583 = f1583 as dynamic;
+ l1583 = f1583 as dynamic;
+ x1583 = confuse(f1583);
+ l1583 = confuse(f1583);
+ }
+
+ Expect.isTrue(m1583 is F1583);
+ Expect.isTrue(m1583 is Function(Function x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1583) is F1583);
+ // In checked mode, verifies the type.
+ x1583 = m1583;
+ l1583 = m1583;
+ x1583 = confuse(m1583);
+ l1583 = confuse(m1583);
+
+ }
+
+ void testF1683() {
+ // Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1683 is F1683);
+ Expect.isTrue(confuse(f1683) is F1683);
+ // In checked mode, verifies the type.
+ Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l1683;
+ // The static function f1683 sets `T` to `int`.
+ if (!tIsBool) {
+ x1683 = f1683 as dynamic;
+ l1683 = f1683 as dynamic;
+ x1683 = confuse(f1683);
+ l1683 = confuse(f1683);
+ }
+
+ Expect.isTrue(m1683 is F1683);
+ Expect.isTrue(m1683 is Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1683) is F1683);
+ // In checked mode, verifies the type.
+ x1683 = m1683;
+ l1683 = m1683;
+ x1683 = confuse(m1683);
+ l1683 = confuse(m1683);
+
+ }
+
+ void testF1783() {
+ // Function Function<A>(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1783 is F1783);
+ Expect.isTrue(confuse(f1783) is F1783);
+ // In checked mode, verifies the type.
+ Function Function<A>(Function x) Function<B extends core.int>(int x) l1783;
+ // The static function f1783 sets `T` to `int`.
+ if (!tIsBool) {
+ x1783 = f1783 as dynamic;
+ l1783 = f1783 as dynamic;
+ x1783 = confuse(f1783);
+ l1783 = confuse(f1783);
+ }
+
+ Expect.isTrue(m1783 is F1783);
+ Expect.isTrue(m1783 is Function Function<A>(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1783) is F1783);
+ // In checked mode, verifies the type.
+ x1783 = m1783;
+ l1783 = m1783;
+ x1783 = confuse(m1783);
+ l1783 = confuse(m1783);
+
+ }
+
+ void testF1883() {
+ // List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1883 is F1883);
+ Expect.isTrue(confuse(f1883) is F1883);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x) l1883;
+ // The static function f1883 sets `T` to `int`.
+ if (!tIsBool) {
+ x1883 = f1883 as dynamic;
+ l1883 = f1883 as dynamic;
+ x1883 = confuse(f1883);
+ l1883 = confuse(f1883);
+ }
+
+ Expect.isTrue(m1883 is F1883);
+ Expect.isTrue(m1883 is List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1883) is F1883);
+ // In checked mode, verifies the type.
+ x1883 = m1883;
+ l1883 = m1883;
+ x1883 = confuse(m1883);
+ l1883 = confuse(m1883);
+ if (!tIsBool) {
+ Expect.isTrue(f1883 is F1883<int>);
+ Expect.isFalse(f1883 is F1883<bool>);
+ Expect.isTrue(confuse(f1883) is F1883<int>);
+ Expect.isFalse(confuse(f1883) is F1883<bool>);
+ Expect.equals(tIsDynamic, m1883 is F1883<bool>);
+ Expect.equals(tIsDynamic, confuse(m1883) is F1883<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1883 = (f1883 as dynamic); });
+ Expect.throws(() { x1883 = confuse(f1883); });
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x) l1883;
+ Expect.throws(() { l1883 = (f1883 as dynamic); });
+ Expect.throws(() { l1883 = confuse(f1883); });
+ }
+ List<T> Function<A>(List<Function> x) Function<B extends core.int>(int x) l1883 = m1883;
+ // In checked mode, verifies the type.
+ x1883 = m1883;
+ x1883 = confuse(m1883);
+ }
+ }
+
+ void testF1983() {
+ // List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1983 is F1983);
+ Expect.isTrue(confuse(f1983) is F1983);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1983;
+ // The static function f1983 sets `T` to `int`.
+ if (!tIsBool) {
+ x1983 = f1983 as dynamic;
+ l1983 = f1983 as dynamic;
+ x1983 = confuse(f1983);
+ l1983 = confuse(f1983);
+ }
+
+ Expect.isTrue(m1983 is F1983);
+ Expect.isTrue(m1983 is List<A> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1983) is F1983);
+ // In checked mode, verifies the type.
+ x1983 = m1983;
+ l1983 = m1983;
+ x1983 = confuse(m1983);
+ l1983 = confuse(m1983);
+
+ }
+
+
+}
+
+class C84<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x1, [List<Function> x2]) x84;
+ core.List<core.int> Function([Function x1]) x184;
+ Function(int x0) x284;
+ A Function<A>(int x) x384;
+ int Function(int y, {Function x}) Function() x484;
+ int Function(int x0, [List<T> x]) Function() x584;
+ Function Function(Function x0) Function() x684;
+ Function Function(int x, [core.List<core.int> x2]) Function() x784;
+ List<Function> Function(int x0, {int x}) Function() x884;
+ List<Function> Function([core.List<core.int> x]) Function() x984;
+ core.List<core.int> Function(int y, [int x]) Function() x1084;
+ core.List<core.int> Function(int x1, [List<Function> x2]) Function() x1184;
+ core.List<core.int> Function(int x0, {List<T> x}) Function() x1284;
+ List<T> Function(List<Function> x) Function() x1384;
+ List<T> Function(int y, [List<T> x]) Function() x1484;
+ Function([Function x1]) Function() x1584;
+ Function({core.List<core.int> x}) Function() x1684;
+ Function Function<A>(List<Function> x) Function() x1784;
+ List<T> Function<A>(core.List<core.int> x) Function() x1884;
+ List<A> Function<A>(List<T> x) Function() x1984;
+
+
+ C84({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m84(int x0, [List<Function> x1]) => null;
+ core.List<core.int> m184([Function x0]) => null;
+ m284(int x0) => null;
+ A m384<A>(int x) => null;
+ int Function(int y, {Function x}) m484() => null;
+ int Function(int x0, [List<T> x]) m584() => null;
+ Function Function(Function x0) m684() => null;
+ Function Function(int x, [core.List<core.int> x0]) m784() => null;
+ List<Function> Function(int x0, {int x}) m884() => null;
+ List<Function> Function([core.List<core.int> x]) m984() => null;
+ core.List<core.int> Function(int y, [int x]) m1084() => null;
+ core.List<core.int> Function(int x0, [List<Function> x1]) m1184() => null;
+ core.List<core.int> Function(int x0, {List<T> x}) m1284() => null;
+ List<T> Function(List<Function> x) m1384() => null;
+ List<T> Function(int y, [List<T> x]) m1484() => null;
+ Function([Function x0]) m1584() => null;
+ Function({core.List<core.int> x}) m1684() => null;
+ Function Function<A>(List<Function> x) m1784() => null;
+ List<T> Function<A>(core.List<core.int> x) m1884() => null;
+ List<A> Function<A>(List<T> x) m1984() => null;
+
+
+ runTests() {
+ testF84();
+ testF184();
+ testF284();
+ testF384();
+ testF484();
+ testF584();
+ testF684();
+ testF784();
+ testF884();
+ testF984();
+ testF1084();
+ testF1184();
+ testF1284();
+ testF1384();
+ testF1484();
+ testF1584();
+ testF1684();
+ testF1784();
+ testF1884();
+ testF1984();
+ }
+
+ void testF84() {
+ // Function Function(int x1, [List<Function> x2])
+ Expect.isTrue(f84 is F84);
+ Expect.isTrue(confuse(f84) is F84);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [List<Function> x2]) l84;
+ // The static function f84 sets `T` to `int`.
+ if (!tIsBool) {
+ x84 = f84 as dynamic;
+ l84 = f84 as dynamic;
+ x84 = confuse(f84);
+ l84 = confuse(f84);
+ }
+
+ Expect.isTrue(m84 is F84);
+ Expect.isTrue(m84 is Function Function(int x1, [List<Function> x2]));
+ Expect.isTrue(confuse(m84) is F84);
+ // In checked mode, verifies the type.
+ x84 = m84;
+ l84 = m84;
+ x84 = confuse(m84);
+ l84 = confuse(m84);
+
+ }
+
+ void testF184() {
+ // core.List<core.int> Function([Function x1])
+ Expect.isTrue(f184 is F184);
+ Expect.isTrue(confuse(f184) is F184);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([Function x1]) l184;
+ // The static function f184 sets `T` to `int`.
+ if (!tIsBool) {
+ x184 = f184 as dynamic;
+ l184 = f184 as dynamic;
+ x184 = confuse(f184);
+ l184 = confuse(f184);
+ }
+
+ Expect.isTrue(m184 is F184);
+ Expect.isTrue(m184 is core.List<core.int> Function([Function x1]));
+ Expect.isTrue(confuse(m184) is F184);
+ // In checked mode, verifies the type.
+ x184 = m184;
+ l184 = m184;
+ x184 = confuse(m184);
+ l184 = confuse(m184);
+
+ }
+
+ void testF284() {
+ // Function(int x0)
+ Expect.isTrue(f284 is F284);
+ Expect.isTrue(confuse(f284) is F284);
+ // In checked mode, verifies the type.
+ Function(int x0) l284;
+ // The static function f284 sets `T` to `int`.
+ if (!tIsBool) {
+ x284 = f284 as dynamic;
+ l284 = f284 as dynamic;
+ x284 = confuse(f284);
+ l284 = confuse(f284);
+ }
+
+ Expect.isTrue(m284 is F284);
+ Expect.isTrue(m284 is Function(int x0));
+ Expect.isTrue(confuse(m284) is F284);
+ // In checked mode, verifies the type.
+ x284 = m284;
+ l284 = m284;
+ x284 = confuse(m284);
+ l284 = confuse(m284);
+
+ }
+
+ void testF384() {
+ // A Function<A>(int x)
+ Expect.isTrue(f384 is F384);
+ Expect.isTrue(confuse(f384) is F384);
+ // In checked mode, verifies the type.
+ A Function<A>(int x) l384;
+ // The static function f384 sets `T` to `int`.
+ if (!tIsBool) {
+ x384 = f384 as dynamic;
+ l384 = f384 as dynamic;
+ x384 = confuse(f384);
+ l384 = confuse(f384);
+ }
+
+ Expect.isTrue(m384 is F384);
+ Expect.isTrue(m384 is A Function<A>(int x));
+ Expect.isTrue(confuse(m384) is F384);
+ // In checked mode, verifies the type.
+ x384 = m384;
+ l384 = m384;
+ x384 = confuse(m384);
+ l384 = confuse(m384);
+
+ }
+
+ void testF484() {
+ // int Function(int y, {Function x}) Function()
+ Expect.isTrue(f484 is F484);
+ Expect.isTrue(confuse(f484) is F484);
+ // In checked mode, verifies the type.
+ int Function(int y, {Function x}) Function() l484;
+ // The static function f484 sets `T` to `int`.
+ if (!tIsBool) {
+ x484 = f484 as dynamic;
+ l484 = f484 as dynamic;
+ x484 = confuse(f484);
+ l484 = confuse(f484);
+ }
+
+ Expect.isTrue(m484 is F484);
+ Expect.isTrue(m484 is int Function(int y, {Function x}) Function());
+ Expect.isTrue(confuse(m484) is F484);
+ // In checked mode, verifies the type.
+ x484 = m484;
+ l484 = m484;
+ x484 = confuse(m484);
+ l484 = confuse(m484);
+
+ }
+
+ void testF584() {
+ // int Function(int x0, [List<T> x]) Function()
+ Expect.isTrue(f584 is F584);
+ Expect.isTrue(confuse(f584) is F584);
+ // In checked mode, verifies the type.
+ int Function(int x0, [List<T> x]) Function() l584;
+ // The static function f584 sets `T` to `int`.
+ if (!tIsBool) {
+ x584 = f584 as dynamic;
+ l584 = f584 as dynamic;
+ x584 = confuse(f584);
+ l584 = confuse(f584);
+ }
+
+ Expect.isTrue(m584 is F584);
+ Expect.isTrue(m584 is int Function(int x0, [List<T> x]) Function());
+ Expect.isTrue(confuse(m584) is F584);
+ // In checked mode, verifies the type.
+ x584 = m584;
+ l584 = m584;
+ x584 = confuse(m584);
+ l584 = confuse(m584);
+ if (!tIsBool) {
+ Expect.isTrue(f584 is F584<int>);
+ Expect.isFalse(f584 is F584<bool>);
+ Expect.isTrue(confuse(f584) is F584<int>);
+ Expect.isFalse(confuse(f584) is F584<bool>);
+ Expect.equals(tIsDynamic, m584 is F584<bool>);
+ Expect.equals(tIsDynamic, confuse(m584) is F584<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x584 = (f584 as dynamic); });
+ Expect.throws(() { x584 = confuse(f584); });
+ int Function(int x0, [List<T> x]) Function() l584;
+ Expect.throws(() { l584 = (f584 as dynamic); });
+ Expect.throws(() { l584 = confuse(f584); });
+ }
+ int Function(int x0, [List<T> x]) Function() l584 = m584;
+ // In checked mode, verifies the type.
+ x584 = m584;
+ x584 = confuse(m584);
+ }
+ }
+
+ void testF684() {
+ // Function Function(Function x0) Function()
+ Expect.isTrue(f684 is F684);
+ Expect.isTrue(confuse(f684) is F684);
+ // In checked mode, verifies the type.
+ Function Function(Function x0) Function() l684;
+ // The static function f684 sets `T` to `int`.
+ if (!tIsBool) {
+ x684 = f684 as dynamic;
+ l684 = f684 as dynamic;
+ x684 = confuse(f684);
+ l684 = confuse(f684);
+ }
+
+ Expect.isTrue(m684 is F684);
+ Expect.isTrue(m684 is Function Function(Function x0) Function());
+ Expect.isTrue(confuse(m684) is F684);
+ // In checked mode, verifies the type.
+ x684 = m684;
+ l684 = m684;
+ x684 = confuse(m684);
+ l684 = confuse(m684);
+
+ }
+
+ void testF784() {
+ // Function Function(int x, [core.List<core.int> x2]) Function()
+ Expect.isTrue(f784 is F784);
+ Expect.isTrue(confuse(f784) is F784);
+ // In checked mode, verifies the type.
+ Function Function(int x, [core.List<core.int> x2]) Function() l784;
+ // The static function f784 sets `T` to `int`.
+ if (!tIsBool) {
+ x784 = f784 as dynamic;
+ l784 = f784 as dynamic;
+ x784 = confuse(f784);
+ l784 = confuse(f784);
+ }
+
+ Expect.isTrue(m784 is F784);
+ Expect.isTrue(m784 is Function Function(int x, [core.List<core.int> x2]) Function());
+ Expect.isTrue(confuse(m784) is F784);
+ // In checked mode, verifies the type.
+ x784 = m784;
+ l784 = m784;
+ x784 = confuse(m784);
+ l784 = confuse(m784);
+
+ }
+
+ void testF884() {
+ // List<Function> Function(int x0, {int x}) Function()
+ Expect.isTrue(f884 is F884);
+ Expect.isTrue(confuse(f884) is F884);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, {int x}) Function() l884;
+ // The static function f884 sets `T` to `int`.
+ if (!tIsBool) {
+ x884 = f884 as dynamic;
+ l884 = f884 as dynamic;
+ x884 = confuse(f884);
+ l884 = confuse(f884);
+ }
+
+ Expect.isTrue(m884 is F884);
+ Expect.isTrue(m884 is List<Function> Function(int x0, {int x}) Function());
+ Expect.isTrue(confuse(m884) is F884);
+ // In checked mode, verifies the type.
+ x884 = m884;
+ l884 = m884;
+ x884 = confuse(m884);
+ l884 = confuse(m884);
+
+ }
+
+ void testF984() {
+ // List<Function> Function([core.List<core.int> x]) Function()
+ Expect.isTrue(f984 is F984);
+ Expect.isTrue(confuse(f984) is F984);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x]) Function() l984;
+ // The static function f984 sets `T` to `int`.
+ if (!tIsBool) {
+ x984 = f984 as dynamic;
+ l984 = f984 as dynamic;
+ x984 = confuse(f984);
+ l984 = confuse(f984);
+ }
+
+ Expect.isTrue(m984 is F984);
+ Expect.isTrue(m984 is List<Function> Function([core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m984) is F984);
+ // In checked mode, verifies the type.
+ x984 = m984;
+ l984 = m984;
+ x984 = confuse(m984);
+ l984 = confuse(m984);
+
+ }
+
+ void testF1084() {
+ // core.List<core.int> Function(int y, [int x]) Function()
+ Expect.isTrue(f1084 is F1084);
+ Expect.isTrue(confuse(f1084) is F1084);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [int x]) Function() l1084;
+ // The static function f1084 sets `T` to `int`.
+ if (!tIsBool) {
+ x1084 = f1084 as dynamic;
+ l1084 = f1084 as dynamic;
+ x1084 = confuse(f1084);
+ l1084 = confuse(f1084);
+ }
+
+ Expect.isTrue(m1084 is F1084);
+ Expect.isTrue(m1084 is core.List<core.int> Function(int y, [int x]) Function());
+ Expect.isTrue(confuse(m1084) is F1084);
+ // In checked mode, verifies the type.
+ x1084 = m1084;
+ l1084 = m1084;
+ x1084 = confuse(m1084);
+ l1084 = confuse(m1084);
+
+ }
+
+ void testF1184() {
+ // core.List<core.int> Function(int x1, [List<Function> x2]) Function()
+ Expect.isTrue(f1184 is F1184);
+ Expect.isTrue(confuse(f1184) is F1184);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<Function> x2]) Function() l1184;
+ // The static function f1184 sets `T` to `int`.
+ if (!tIsBool) {
+ x1184 = f1184 as dynamic;
+ l1184 = f1184 as dynamic;
+ x1184 = confuse(f1184);
+ l1184 = confuse(f1184);
+ }
+
+ Expect.isTrue(m1184 is F1184);
+ Expect.isTrue(m1184 is core.List<core.int> Function(int x1, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m1184) is F1184);
+ // In checked mode, verifies the type.
+ x1184 = m1184;
+ l1184 = m1184;
+ x1184 = confuse(m1184);
+ l1184 = confuse(m1184);
+
+ }
+
+ void testF1284() {
+ // core.List<core.int> Function(int x0, {List<T> x}) Function()
+ Expect.isTrue(f1284 is F1284);
+ Expect.isTrue(confuse(f1284) is F1284);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {List<T> x}) Function() l1284;
+ // The static function f1284 sets `T` to `int`.
+ if (!tIsBool) {
+ x1284 = f1284 as dynamic;
+ l1284 = f1284 as dynamic;
+ x1284 = confuse(f1284);
+ l1284 = confuse(f1284);
+ }
+
+ Expect.isTrue(m1284 is F1284);
+ Expect.isTrue(m1284 is core.List<core.int> Function(int x0, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1284) is F1284);
+ // In checked mode, verifies the type.
+ x1284 = m1284;
+ l1284 = m1284;
+ x1284 = confuse(m1284);
+ l1284 = confuse(m1284);
+ if (!tIsBool) {
+ Expect.isTrue(f1284 is F1284<int>);
+ Expect.isFalse(f1284 is F1284<bool>);
+ Expect.isTrue(confuse(f1284) is F1284<int>);
+ Expect.isFalse(confuse(f1284) is F1284<bool>);
+ Expect.equals(tIsDynamic, m1284 is F1284<bool>);
+ Expect.equals(tIsDynamic, confuse(m1284) is F1284<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1284 = (f1284 as dynamic); });
+ Expect.throws(() { x1284 = confuse(f1284); });
+ core.List<core.int> Function(int x0, {List<T> x}) Function() l1284;
+ Expect.throws(() { l1284 = (f1284 as dynamic); });
+ Expect.throws(() { l1284 = confuse(f1284); });
+ }
+ core.List<core.int> Function(int x0, {List<T> x}) Function() l1284 = m1284;
+ // In checked mode, verifies the type.
+ x1284 = m1284;
+ x1284 = confuse(m1284);
+ }
+ }
+
+ void testF1384() {
+ // List<T> Function(List<Function> x) Function()
+ Expect.isTrue(f1384 is F1384);
+ Expect.isTrue(confuse(f1384) is F1384);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x) Function() l1384;
+ // The static function f1384 sets `T` to `int`.
+ if (!tIsBool) {
+ x1384 = f1384 as dynamic;
+ l1384 = f1384 as dynamic;
+ x1384 = confuse(f1384);
+ l1384 = confuse(f1384);
+ }
+
+ Expect.isTrue(m1384 is F1384);
+ Expect.isTrue(m1384 is List<T> Function(List<Function> x) Function());
+ Expect.isTrue(confuse(m1384) is F1384);
+ // In checked mode, verifies the type.
+ x1384 = m1384;
+ l1384 = m1384;
+ x1384 = confuse(m1384);
+ l1384 = confuse(m1384);
+ if (!tIsBool) {
+ Expect.isTrue(f1384 is F1384<int>);
+ Expect.isFalse(f1384 is F1384<bool>);
+ Expect.isTrue(confuse(f1384) is F1384<int>);
+ Expect.isFalse(confuse(f1384) is F1384<bool>);
+ Expect.equals(tIsDynamic, m1384 is F1384<bool>);
+ Expect.equals(tIsDynamic, confuse(m1384) is F1384<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1384 = (f1384 as dynamic); });
+ Expect.throws(() { x1384 = confuse(f1384); });
+ List<T> Function(List<Function> x) Function() l1384;
+ Expect.throws(() { l1384 = (f1384 as dynamic); });
+ Expect.throws(() { l1384 = confuse(f1384); });
+ }
+ List<T> Function(List<Function> x) Function() l1384 = m1384;
+ // In checked mode, verifies the type.
+ x1384 = m1384;
+ x1384 = confuse(m1384);
+ }
+ }
+
+ void testF1484() {
+ // List<T> Function(int y, [List<T> x]) Function()
+ Expect.isTrue(f1484 is F1484);
+ Expect.isTrue(confuse(f1484) is F1484);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<T> x]) Function() l1484;
+ // The static function f1484 sets `T` to `int`.
+ if (!tIsBool) {
+ x1484 = f1484 as dynamic;
+ l1484 = f1484 as dynamic;
+ x1484 = confuse(f1484);
+ l1484 = confuse(f1484);
+ }
+
+ Expect.isTrue(m1484 is F1484);
+ Expect.isTrue(m1484 is List<T> Function(int y, [List<T> x]) Function());
+ Expect.isTrue(confuse(m1484) is F1484);
+ // In checked mode, verifies the type.
+ x1484 = m1484;
+ l1484 = m1484;
+ x1484 = confuse(m1484);
+ l1484 = confuse(m1484);
+ if (!tIsBool) {
+ Expect.isTrue(f1484 is F1484<int>);
+ Expect.isFalse(f1484 is F1484<bool>);
+ Expect.isTrue(confuse(f1484) is F1484<int>);
+ Expect.isFalse(confuse(f1484) is F1484<bool>);
+ Expect.equals(tIsDynamic, m1484 is F1484<bool>);
+ Expect.equals(tIsDynamic, confuse(m1484) is F1484<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1484 = (f1484 as dynamic); });
+ Expect.throws(() { x1484 = confuse(f1484); });
+ List<T> Function(int y, [List<T> x]) Function() l1484;
+ Expect.throws(() { l1484 = (f1484 as dynamic); });
+ Expect.throws(() { l1484 = confuse(f1484); });
+ }
+ List<T> Function(int y, [List<T> x]) Function() l1484 = m1484;
+ // In checked mode, verifies the type.
+ x1484 = m1484;
+ x1484 = confuse(m1484);
+ }
+ }
+
+ void testF1584() {
+ // Function([Function x1]) Function()
+ Expect.isTrue(f1584 is F1584);
+ Expect.isTrue(confuse(f1584) is F1584);
+ // In checked mode, verifies the type.
+ Function([Function x1]) Function() l1584;
+ // The static function f1584 sets `T` to `int`.
+ if (!tIsBool) {
+ x1584 = f1584 as dynamic;
+ l1584 = f1584 as dynamic;
+ x1584 = confuse(f1584);
+ l1584 = confuse(f1584);
+ }
+
+ Expect.isTrue(m1584 is F1584);
+ Expect.isTrue(m1584 is Function([Function x1]) Function());
+ Expect.isTrue(confuse(m1584) is F1584);
+ // In checked mode, verifies the type.
+ x1584 = m1584;
+ l1584 = m1584;
+ x1584 = confuse(m1584);
+ l1584 = confuse(m1584);
+
+ }
+
+ void testF1684() {
+ // Function({core.List<core.int> x}) Function()
+ Expect.isTrue(f1684 is F1684);
+ Expect.isTrue(confuse(f1684) is F1684);
+ // In checked mode, verifies the type.
+ Function({core.List<core.int> x}) Function() l1684;
+ // The static function f1684 sets `T` to `int`.
+ if (!tIsBool) {
+ x1684 = f1684 as dynamic;
+ l1684 = f1684 as dynamic;
+ x1684 = confuse(f1684);
+ l1684 = confuse(f1684);
+ }
+
+ Expect.isTrue(m1684 is F1684);
+ Expect.isTrue(m1684 is Function({core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1684) is F1684);
+ // In checked mode, verifies the type.
+ x1684 = m1684;
+ l1684 = m1684;
+ x1684 = confuse(m1684);
+ l1684 = confuse(m1684);
+
+ }
+
+ void testF1784() {
+ // Function Function<A>(List<Function> x) Function()
+ Expect.isTrue(f1784 is F1784);
+ Expect.isTrue(confuse(f1784) is F1784);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<Function> x) Function() l1784;
+ // The static function f1784 sets `T` to `int`.
+ if (!tIsBool) {
+ x1784 = f1784 as dynamic;
+ l1784 = f1784 as dynamic;
+ x1784 = confuse(f1784);
+ l1784 = confuse(f1784);
+ }
+
+ Expect.isTrue(m1784 is F1784);
+ Expect.isTrue(m1784 is Function Function<A>(List<Function> x) Function());
+ Expect.isTrue(confuse(m1784) is F1784);
+ // In checked mode, verifies the type.
+ x1784 = m1784;
+ l1784 = m1784;
+ x1784 = confuse(m1784);
+ l1784 = confuse(m1784);
+
+ }
+
+ void testF1884() {
+ // List<T> Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1884 is F1884);
+ Expect.isTrue(confuse(f1884) is F1884);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(core.List<core.int> x) Function() l1884;
+ // The static function f1884 sets `T` to `int`.
+ if (!tIsBool) {
+ x1884 = f1884 as dynamic;
+ l1884 = f1884 as dynamic;
+ x1884 = confuse(f1884);
+ l1884 = confuse(f1884);
+ }
+
+ Expect.isTrue(m1884 is F1884);
+ Expect.isTrue(m1884 is List<T> Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1884) is F1884);
+ // In checked mode, verifies the type.
+ x1884 = m1884;
+ l1884 = m1884;
+ x1884 = confuse(m1884);
+ l1884 = confuse(m1884);
+ if (!tIsBool) {
+ Expect.isTrue(f1884 is F1884<int>);
+ Expect.isFalse(f1884 is F1884<bool>);
+ Expect.isTrue(confuse(f1884) is F1884<int>);
+ Expect.isFalse(confuse(f1884) is F1884<bool>);
+ Expect.equals(tIsDynamic, m1884 is F1884<bool>);
+ Expect.equals(tIsDynamic, confuse(m1884) is F1884<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1884 = (f1884 as dynamic); });
+ Expect.throws(() { x1884 = confuse(f1884); });
+ List<T> Function<A>(core.List<core.int> x) Function() l1884;
+ Expect.throws(() { l1884 = (f1884 as dynamic); });
+ Expect.throws(() { l1884 = confuse(f1884); });
+ }
+ List<T> Function<A>(core.List<core.int> x) Function() l1884 = m1884;
+ // In checked mode, verifies the type.
+ x1884 = m1884;
+ x1884 = confuse(m1884);
+ }
+ }
+
+ void testF1984() {
+ // List<A> Function<A>(List<T> x) Function()
+ Expect.isTrue(f1984 is F1984);
+ Expect.isTrue(confuse(f1984) is F1984);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<T> x) Function() l1984;
+ // The static function f1984 sets `T` to `int`.
+ if (!tIsBool) {
+ x1984 = f1984 as dynamic;
+ l1984 = f1984 as dynamic;
+ x1984 = confuse(f1984);
+ l1984 = confuse(f1984);
+ }
+
+ Expect.isTrue(m1984 is F1984);
+ Expect.isTrue(m1984 is List<A> Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1984) is F1984);
+ // In checked mode, verifies the type.
+ x1984 = m1984;
+ l1984 = m1984;
+ x1984 = confuse(m1984);
+ l1984 = confuse(m1984);
+ if (!tIsBool) {
+ Expect.isTrue(f1984 is F1984<int>);
+ Expect.isFalse(f1984 is F1984<bool>);
+ Expect.isTrue(confuse(f1984) is F1984<int>);
+ Expect.isFalse(confuse(f1984) is F1984<bool>);
+ Expect.equals(tIsDynamic, m1984 is F1984<bool>);
+ Expect.equals(tIsDynamic, confuse(m1984) is F1984<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1984 = (f1984 as dynamic); });
+ Expect.throws(() { x1984 = confuse(f1984); });
+ List<A> Function<A>(List<T> x) Function() l1984;
+ Expect.throws(() { l1984 = (f1984 as dynamic); });
+ Expect.throws(() { l1984 = confuse(f1984); });
+ }
+ List<A> Function<A>(List<T> x) Function() l1984 = m1984;
+ // In checked mode, verifies the type.
+ x1984 = m1984;
+ x1984 = confuse(m1984);
+ }
+ }
+
+
+}
+
+class C85<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x, [List<Function> x2]) x85;
+ core.List<core.int> Function(int x1, [Function x2]) x185;
+ Function([int x1]) x285;
+ A Function<A>(Function x) x385;
+ int Function(int y, {Function x}) Function(int x) x485;
+ int Function(int x1, [List<T> x]) Function(int x) x585;
+ Function Function(Function x1) Function(int x) x685;
+ Function Function(int x, [core.List<core.int> x1]) Function(int x) x785;
+ List<Function> Function(int x1, {int x}) Function(int x) x885;
+ List<Function> Function([core.List<core.int> x]) Function(int x) x985;
+ core.List<core.int> Function(int y, [int x]) Function(int x) x1085;
+ core.List<core.int> Function(int x2, [List<Function> x3]) Function(int x) x1185;
+ core.List<core.int> Function(int x1, {List<T> x}) Function(int x) x1285;
+ List<T> Function(List<Function> x) Function(int x) x1385;
+ List<T> Function(int y, [List<T> x]) Function(int x) x1485;
+ Function([Function x1]) Function(int x) x1585;
+ Function({core.List<core.int> x}) Function(int x) x1685;
+ Function Function<A>(List<Function> x) Function(int x) x1785;
+ List<T> Function<A>(core.List<core.int> x) Function(int x) x1885;
+ List<A> Function<A>(List<T> x) Function(int x) x1985;
+
+
+ C85({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m85(int x, [List<Function> x0]) => null;
+ core.List<core.int> m185(int x0, [Function x1]) => null;
+ m285([int x0]) => null;
+ A m385<A>(Function x) => null;
+ int Function(int y, {Function x}) m485(int x) => null;
+ int Function(int x0, [List<T> x]) m585(int x) => null;
+ Function Function(Function x0) m685(int x) => null;
+ Function Function(int x, [core.List<core.int> x0]) m785(int x) => null;
+ List<Function> Function(int x0, {int x}) m885(int x) => null;
+ List<Function> Function([core.List<core.int> x]) m985(int x) => null;
+ core.List<core.int> Function(int y, [int x]) m1085(int x) => null;
+ core.List<core.int> Function(int x0, [List<Function> x1]) m1185(int x) => null;
+ core.List<core.int> Function(int x0, {List<T> x}) m1285(int x) => null;
+ List<T> Function(List<Function> x) m1385(int x) => null;
+ List<T> Function(int y, [List<T> x]) m1485(int x) => null;
+ Function([Function x0]) m1585(int x) => null;
+ Function({core.List<core.int> x}) m1685(int x) => null;
+ Function Function<A>(List<Function> x) m1785(int x) => null;
+ List<T> Function<A>(core.List<core.int> x) m1885(int x) => null;
+ List<A> Function<A>(List<T> x) m1985(int x) => null;
+
+
+ runTests() {
+ testF85();
+ testF185();
+ testF285();
+ testF385();
+ testF485();
+ testF585();
+ testF685();
+ testF785();
+ testF885();
+ testF985();
+ testF1085();
+ testF1185();
+ testF1285();
+ testF1385();
+ testF1485();
+ testF1585();
+ testF1685();
+ testF1785();
+ testF1885();
+ testF1985();
+ }
+
+ void testF85() {
+ // Function Function(int x, [List<Function> x2])
+ Expect.isTrue(f85 is F85);
+ Expect.isTrue(confuse(f85) is F85);
+ // In checked mode, verifies the type.
+ Function Function(int x, [List<Function> x2]) l85;
+ // The static function f85 sets `T` to `int`.
+ if (!tIsBool) {
+ x85 = f85 as dynamic;
+ l85 = f85 as dynamic;
+ x85 = confuse(f85);
+ l85 = confuse(f85);
+ }
+
+ Expect.isTrue(m85 is F85);
+ Expect.isTrue(m85 is Function Function(int x, [List<Function> x2]));
+ Expect.isTrue(confuse(m85) is F85);
+ // In checked mode, verifies the type.
+ x85 = m85;
+ l85 = m85;
+ x85 = confuse(m85);
+ l85 = confuse(m85);
+
+ }
+
+ void testF185() {
+ // core.List<core.int> Function(int x1, [Function x2])
+ Expect.isTrue(f185 is F185);
+ Expect.isTrue(confuse(f185) is F185);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [Function x2]) l185;
+ // The static function f185 sets `T` to `int`.
+ if (!tIsBool) {
+ x185 = f185 as dynamic;
+ l185 = f185 as dynamic;
+ x185 = confuse(f185);
+ l185 = confuse(f185);
+ }
+
+ Expect.isTrue(m185 is F185);
+ Expect.isTrue(m185 is core.List<core.int> Function(int x1, [Function x2]));
+ Expect.isTrue(confuse(m185) is F185);
+ // In checked mode, verifies the type.
+ x185 = m185;
+ l185 = m185;
+ x185 = confuse(m185);
+ l185 = confuse(m185);
+
+ }
+
+ void testF285() {
+ // Function([int x1])
+ Expect.isTrue(f285 is F285);
+ Expect.isTrue(confuse(f285) is F285);
+ // In checked mode, verifies the type.
+ Function([int x1]) l285;
+ // The static function f285 sets `T` to `int`.
+ if (!tIsBool) {
+ x285 = f285 as dynamic;
+ l285 = f285 as dynamic;
+ x285 = confuse(f285);
+ l285 = confuse(f285);
+ }
+
+ Expect.isTrue(m285 is F285);
+ Expect.isTrue(m285 is Function([int x1]));
+ Expect.isTrue(confuse(m285) is F285);
+ // In checked mode, verifies the type.
+ x285 = m285;
+ l285 = m285;
+ x285 = confuse(m285);
+ l285 = confuse(m285);
+
+ }
+
+ void testF385() {
+ // A Function<A>(Function x)
+ Expect.isTrue(f385 is F385);
+ Expect.isTrue(confuse(f385) is F385);
+ // In checked mode, verifies the type.
+ A Function<A>(Function x) l385;
+ // The static function f385 sets `T` to `int`.
+ if (!tIsBool) {
+ x385 = f385 as dynamic;
+ l385 = f385 as dynamic;
+ x385 = confuse(f385);
+ l385 = confuse(f385);
+ }
+
+ Expect.isTrue(m385 is F385);
+ Expect.isTrue(m385 is A Function<A>(Function x));
+ Expect.isTrue(confuse(m385) is F385);
+ // In checked mode, verifies the type.
+ x385 = m385;
+ l385 = m385;
+ x385 = confuse(m385);
+ l385 = confuse(m385);
+
+ }
+
+ void testF485() {
+ // int Function(int y, {Function x}) Function(int x)
+ Expect.isTrue(f485 is F485);
+ Expect.isTrue(confuse(f485) is F485);
+ // In checked mode, verifies the type.
+ int Function(int y, {Function x}) Function(int x) l485;
+ // The static function f485 sets `T` to `int`.
+ if (!tIsBool) {
+ x485 = f485 as dynamic;
+ l485 = f485 as dynamic;
+ x485 = confuse(f485);
+ l485 = confuse(f485);
+ }
+
+ Expect.isTrue(m485 is F485);
+ Expect.isTrue(m485 is int Function(int y, {Function x}) Function(int x));
+ Expect.isTrue(confuse(m485) is F485);
+ // In checked mode, verifies the type.
+ x485 = m485;
+ l485 = m485;
+ x485 = confuse(m485);
+ l485 = confuse(m485);
+
+ }
+
+ void testF585() {
+ // int Function(int x1, [List<T> x]) Function(int x)
+ Expect.isTrue(f585 is F585);
+ Expect.isTrue(confuse(f585) is F585);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<T> x]) Function(int x) l585;
+ // The static function f585 sets `T` to `int`.
+ if (!tIsBool) {
+ x585 = f585 as dynamic;
+ l585 = f585 as dynamic;
+ x585 = confuse(f585);
+ l585 = confuse(f585);
+ }
+
+ Expect.isTrue(m585 is F585);
+ Expect.isTrue(m585 is int Function(int x1, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m585) is F585);
+ // In checked mode, verifies the type.
+ x585 = m585;
+ l585 = m585;
+ x585 = confuse(m585);
+ l585 = confuse(m585);
+ if (!tIsBool) {
+ Expect.isTrue(f585 is F585<int>);
+ Expect.isFalse(f585 is F585<bool>);
+ Expect.isTrue(confuse(f585) is F585<int>);
+ Expect.isFalse(confuse(f585) is F585<bool>);
+ Expect.equals(tIsDynamic, m585 is F585<bool>);
+ Expect.equals(tIsDynamic, confuse(m585) is F585<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x585 = (f585 as dynamic); });
+ Expect.throws(() { x585 = confuse(f585); });
+ int Function(int x1, [List<T> x]) Function(int x) l585;
+ Expect.throws(() { l585 = (f585 as dynamic); });
+ Expect.throws(() { l585 = confuse(f585); });
+ }
+ int Function(int x1, [List<T> x]) Function(int x) l585 = m585;
+ // In checked mode, verifies the type.
+ x585 = m585;
+ x585 = confuse(m585);
+ }
+ }
+
+ void testF685() {
+ // Function Function(Function x1) Function(int x)
+ Expect.isTrue(f685 is F685);
+ Expect.isTrue(confuse(f685) is F685);
+ // In checked mode, verifies the type.
+ Function Function(Function x1) Function(int x) l685;
+ // The static function f685 sets `T` to `int`.
+ if (!tIsBool) {
+ x685 = f685 as dynamic;
+ l685 = f685 as dynamic;
+ x685 = confuse(f685);
+ l685 = confuse(f685);
+ }
+
+ Expect.isTrue(m685 is F685);
+ Expect.isTrue(m685 is Function Function(Function x1) Function(int x));
+ Expect.isTrue(confuse(m685) is F685);
+ // In checked mode, verifies the type.
+ x685 = m685;
+ l685 = m685;
+ x685 = confuse(m685);
+ l685 = confuse(m685);
+
+ }
+
+ void testF785() {
+ // Function Function(int x, [core.List<core.int> x1]) Function(int x)
+ Expect.isTrue(f785 is F785);
+ Expect.isTrue(confuse(f785) is F785);
+ // In checked mode, verifies the type.
+ Function Function(int x, [core.List<core.int> x1]) Function(int x) l785;
+ // The static function f785 sets `T` to `int`.
+ if (!tIsBool) {
+ x785 = f785 as dynamic;
+ l785 = f785 as dynamic;
+ x785 = confuse(f785);
+ l785 = confuse(f785);
+ }
+
+ Expect.isTrue(m785 is F785);
+ Expect.isTrue(m785 is Function Function(int x, [core.List<core.int> x1]) Function(int x));
+ Expect.isTrue(confuse(m785) is F785);
+ // In checked mode, verifies the type.
+ x785 = m785;
+ l785 = m785;
+ x785 = confuse(m785);
+ l785 = confuse(m785);
+
+ }
+
+ void testF885() {
+ // List<Function> Function(int x1, {int x}) Function(int x)
+ Expect.isTrue(f885 is F885);
+ Expect.isTrue(confuse(f885) is F885);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {int x}) Function(int x) l885;
+ // The static function f885 sets `T` to `int`.
+ if (!tIsBool) {
+ x885 = f885 as dynamic;
+ l885 = f885 as dynamic;
+ x885 = confuse(f885);
+ l885 = confuse(f885);
+ }
+
+ Expect.isTrue(m885 is F885);
+ Expect.isTrue(m885 is List<Function> Function(int x1, {int x}) Function(int x));
+ Expect.isTrue(confuse(m885) is F885);
+ // In checked mode, verifies the type.
+ x885 = m885;
+ l885 = m885;
+ x885 = confuse(m885);
+ l885 = confuse(m885);
+
+ }
+
+ void testF985() {
+ // List<Function> Function([core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f985 is F985);
+ Expect.isTrue(confuse(f985) is F985);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x]) Function(int x) l985;
+ // The static function f985 sets `T` to `int`.
+ if (!tIsBool) {
+ x985 = f985 as dynamic;
+ l985 = f985 as dynamic;
+ x985 = confuse(f985);
+ l985 = confuse(f985);
+ }
+
+ Expect.isTrue(m985 is F985);
+ Expect.isTrue(m985 is List<Function> Function([core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m985) is F985);
+ // In checked mode, verifies the type.
+ x985 = m985;
+ l985 = m985;
+ x985 = confuse(m985);
+ l985 = confuse(m985);
+
+ }
+
+ void testF1085() {
+ // core.List<core.int> Function(int y, [int x]) Function(int x)
+ Expect.isTrue(f1085 is F1085);
+ Expect.isTrue(confuse(f1085) is F1085);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [int x]) Function(int x) l1085;
+ // The static function f1085 sets `T` to `int`.
+ if (!tIsBool) {
+ x1085 = f1085 as dynamic;
+ l1085 = f1085 as dynamic;
+ x1085 = confuse(f1085);
+ l1085 = confuse(f1085);
+ }
+
+ Expect.isTrue(m1085 is F1085);
+ Expect.isTrue(m1085 is core.List<core.int> Function(int y, [int x]) Function(int x));
+ Expect.isTrue(confuse(m1085) is F1085);
+ // In checked mode, verifies the type.
+ x1085 = m1085;
+ l1085 = m1085;
+ x1085 = confuse(m1085);
+ l1085 = confuse(m1085);
+
+ }
+
+ void testF1185() {
+ // core.List<core.int> Function(int x2, [List<Function> x3]) Function(int x)
+ Expect.isTrue(f1185 is F1185);
+ Expect.isTrue(confuse(f1185) is F1185);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [List<Function> x3]) Function(int x) l1185;
+ // The static function f1185 sets `T` to `int`.
+ if (!tIsBool) {
+ x1185 = f1185 as dynamic;
+ l1185 = f1185 as dynamic;
+ x1185 = confuse(f1185);
+ l1185 = confuse(f1185);
+ }
+
+ Expect.isTrue(m1185 is F1185);
+ Expect.isTrue(m1185 is core.List<core.int> Function(int x2, [List<Function> x3]) Function(int x));
+ Expect.isTrue(confuse(m1185) is F1185);
+ // In checked mode, verifies the type.
+ x1185 = m1185;
+ l1185 = m1185;
+ x1185 = confuse(m1185);
+ l1185 = confuse(m1185);
+
+ }
+
+ void testF1285() {
+ // core.List<core.int> Function(int x1, {List<T> x}) Function(int x)
+ Expect.isTrue(f1285 is F1285);
+ Expect.isTrue(confuse(f1285) is F1285);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {List<T> x}) Function(int x) l1285;
+ // The static function f1285 sets `T` to `int`.
+ if (!tIsBool) {
+ x1285 = f1285 as dynamic;
+ l1285 = f1285 as dynamic;
+ x1285 = confuse(f1285);
+ l1285 = confuse(f1285);
+ }
+
+ Expect.isTrue(m1285 is F1285);
+ Expect.isTrue(m1285 is core.List<core.int> Function(int x1, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1285) is F1285);
+ // In checked mode, verifies the type.
+ x1285 = m1285;
+ l1285 = m1285;
+ x1285 = confuse(m1285);
+ l1285 = confuse(m1285);
+ if (!tIsBool) {
+ Expect.isTrue(f1285 is F1285<int>);
+ Expect.isFalse(f1285 is F1285<bool>);
+ Expect.isTrue(confuse(f1285) is F1285<int>);
+ Expect.isFalse(confuse(f1285) is F1285<bool>);
+ Expect.equals(tIsDynamic, m1285 is F1285<bool>);
+ Expect.equals(tIsDynamic, confuse(m1285) is F1285<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1285 = (f1285 as dynamic); });
+ Expect.throws(() { x1285 = confuse(f1285); });
+ core.List<core.int> Function(int x1, {List<T> x}) Function(int x) l1285;
+ Expect.throws(() { l1285 = (f1285 as dynamic); });
+ Expect.throws(() { l1285 = confuse(f1285); });
+ }
+ core.List<core.int> Function(int x1, {List<T> x}) Function(int x) l1285 = m1285;
+ // In checked mode, verifies the type.
+ x1285 = m1285;
+ x1285 = confuse(m1285);
+ }
+ }
+
+ void testF1385() {
+ // List<T> Function(List<Function> x) Function(int x)
+ Expect.isTrue(f1385 is F1385);
+ Expect.isTrue(confuse(f1385) is F1385);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x) Function(int x) l1385;
+ // The static function f1385 sets `T` to `int`.
+ if (!tIsBool) {
+ x1385 = f1385 as dynamic;
+ l1385 = f1385 as dynamic;
+ x1385 = confuse(f1385);
+ l1385 = confuse(f1385);
+ }
+
+ Expect.isTrue(m1385 is F1385);
+ Expect.isTrue(m1385 is List<T> Function(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1385) is F1385);
+ // In checked mode, verifies the type.
+ x1385 = m1385;
+ l1385 = m1385;
+ x1385 = confuse(m1385);
+ l1385 = confuse(m1385);
+ if (!tIsBool) {
+ Expect.isTrue(f1385 is F1385<int>);
+ Expect.isFalse(f1385 is F1385<bool>);
+ Expect.isTrue(confuse(f1385) is F1385<int>);
+ Expect.isFalse(confuse(f1385) is F1385<bool>);
+ Expect.equals(tIsDynamic, m1385 is F1385<bool>);
+ Expect.equals(tIsDynamic, confuse(m1385) is F1385<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1385 = (f1385 as dynamic); });
+ Expect.throws(() { x1385 = confuse(f1385); });
+ List<T> Function(List<Function> x) Function(int x) l1385;
+ Expect.throws(() { l1385 = (f1385 as dynamic); });
+ Expect.throws(() { l1385 = confuse(f1385); });
+ }
+ List<T> Function(List<Function> x) Function(int x) l1385 = m1385;
+ // In checked mode, verifies the type.
+ x1385 = m1385;
+ x1385 = confuse(m1385);
+ }
+ }
+
+ void testF1485() {
+ // List<T> Function(int y, [List<T> x]) Function(int x)
+ Expect.isTrue(f1485 is F1485);
+ Expect.isTrue(confuse(f1485) is F1485);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<T> x]) Function(int x) l1485;
+ // The static function f1485 sets `T` to `int`.
+ if (!tIsBool) {
+ x1485 = f1485 as dynamic;
+ l1485 = f1485 as dynamic;
+ x1485 = confuse(f1485);
+ l1485 = confuse(f1485);
+ }
+
+ Expect.isTrue(m1485 is F1485);
+ Expect.isTrue(m1485 is List<T> Function(int y, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m1485) is F1485);
+ // In checked mode, verifies the type.
+ x1485 = m1485;
+ l1485 = m1485;
+ x1485 = confuse(m1485);
+ l1485 = confuse(m1485);
+ if (!tIsBool) {
+ Expect.isTrue(f1485 is F1485<int>);
+ Expect.isFalse(f1485 is F1485<bool>);
+ Expect.isTrue(confuse(f1485) is F1485<int>);
+ Expect.isFalse(confuse(f1485) is F1485<bool>);
+ Expect.equals(tIsDynamic, m1485 is F1485<bool>);
+ Expect.equals(tIsDynamic, confuse(m1485) is F1485<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1485 = (f1485 as dynamic); });
+ Expect.throws(() { x1485 = confuse(f1485); });
+ List<T> Function(int y, [List<T> x]) Function(int x) l1485;
+ Expect.throws(() { l1485 = (f1485 as dynamic); });
+ Expect.throws(() { l1485 = confuse(f1485); });
+ }
+ List<T> Function(int y, [List<T> x]) Function(int x) l1485 = m1485;
+ // In checked mode, verifies the type.
+ x1485 = m1485;
+ x1485 = confuse(m1485);
+ }
+ }
+
+ void testF1585() {
+ // Function([Function x1]) Function(int x)
+ Expect.isTrue(f1585 is F1585);
+ Expect.isTrue(confuse(f1585) is F1585);
+ // In checked mode, verifies the type.
+ Function([Function x1]) Function(int x) l1585;
+ // The static function f1585 sets `T` to `int`.
+ if (!tIsBool) {
+ x1585 = f1585 as dynamic;
+ l1585 = f1585 as dynamic;
+ x1585 = confuse(f1585);
+ l1585 = confuse(f1585);
+ }
+
+ Expect.isTrue(m1585 is F1585);
+ Expect.isTrue(m1585 is Function([Function x1]) Function(int x));
+ Expect.isTrue(confuse(m1585) is F1585);
+ // In checked mode, verifies the type.
+ x1585 = m1585;
+ l1585 = m1585;
+ x1585 = confuse(m1585);
+ l1585 = confuse(m1585);
+
+ }
+
+ void testF1685() {
+ // Function({core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1685 is F1685);
+ Expect.isTrue(confuse(f1685) is F1685);
+ // In checked mode, verifies the type.
+ Function({core.List<core.int> x}) Function(int x) l1685;
+ // The static function f1685 sets `T` to `int`.
+ if (!tIsBool) {
+ x1685 = f1685 as dynamic;
+ l1685 = f1685 as dynamic;
+ x1685 = confuse(f1685);
+ l1685 = confuse(f1685);
+ }
+
+ Expect.isTrue(m1685 is F1685);
+ Expect.isTrue(m1685 is Function({core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1685) is F1685);
+ // In checked mode, verifies the type.
+ x1685 = m1685;
+ l1685 = m1685;
+ x1685 = confuse(m1685);
+ l1685 = confuse(m1685);
+
+ }
+
+ void testF1785() {
+ // Function Function<A>(List<Function> x) Function(int x)
+ Expect.isTrue(f1785 is F1785);
+ Expect.isTrue(confuse(f1785) is F1785);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<Function> x) Function(int x) l1785;
+ // The static function f1785 sets `T` to `int`.
+ if (!tIsBool) {
+ x1785 = f1785 as dynamic;
+ l1785 = f1785 as dynamic;
+ x1785 = confuse(f1785);
+ l1785 = confuse(f1785);
+ }
+
+ Expect.isTrue(m1785 is F1785);
+ Expect.isTrue(m1785 is Function Function<A>(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m1785) is F1785);
+ // In checked mode, verifies the type.
+ x1785 = m1785;
+ l1785 = m1785;
+ x1785 = confuse(m1785);
+ l1785 = confuse(m1785);
+
+ }
+
+ void testF1885() {
+ // List<T> Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1885 is F1885);
+ Expect.isTrue(confuse(f1885) is F1885);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(core.List<core.int> x) Function(int x) l1885;
+ // The static function f1885 sets `T` to `int`.
+ if (!tIsBool) {
+ x1885 = f1885 as dynamic;
+ l1885 = f1885 as dynamic;
+ x1885 = confuse(f1885);
+ l1885 = confuse(f1885);
+ }
+
+ Expect.isTrue(m1885 is F1885);
+ Expect.isTrue(m1885 is List<T> Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1885) is F1885);
+ // In checked mode, verifies the type.
+ x1885 = m1885;
+ l1885 = m1885;
+ x1885 = confuse(m1885);
+ l1885 = confuse(m1885);
+ if (!tIsBool) {
+ Expect.isTrue(f1885 is F1885<int>);
+ Expect.isFalse(f1885 is F1885<bool>);
+ Expect.isTrue(confuse(f1885) is F1885<int>);
+ Expect.isFalse(confuse(f1885) is F1885<bool>);
+ Expect.equals(tIsDynamic, m1885 is F1885<bool>);
+ Expect.equals(tIsDynamic, confuse(m1885) is F1885<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1885 = (f1885 as dynamic); });
+ Expect.throws(() { x1885 = confuse(f1885); });
+ List<T> Function<A>(core.List<core.int> x) Function(int x) l1885;
+ Expect.throws(() { l1885 = (f1885 as dynamic); });
+ Expect.throws(() { l1885 = confuse(f1885); });
+ }
+ List<T> Function<A>(core.List<core.int> x) Function(int x) l1885 = m1885;
+ // In checked mode, verifies the type.
+ x1885 = m1885;
+ x1885 = confuse(m1885);
+ }
+ }
+
+ void testF1985() {
+ // List<A> Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1985 is F1985);
+ Expect.isTrue(confuse(f1985) is F1985);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<T> x) Function(int x) l1985;
+ // The static function f1985 sets `T` to `int`.
+ if (!tIsBool) {
+ x1985 = f1985 as dynamic;
+ l1985 = f1985 as dynamic;
+ x1985 = confuse(f1985);
+ l1985 = confuse(f1985);
+ }
+
+ Expect.isTrue(m1985 is F1985);
+ Expect.isTrue(m1985 is List<A> Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1985) is F1985);
+ // In checked mode, verifies the type.
+ x1985 = m1985;
+ l1985 = m1985;
+ x1985 = confuse(m1985);
+ l1985 = confuse(m1985);
+ if (!tIsBool) {
+ Expect.isTrue(f1985 is F1985<int>);
+ Expect.isFalse(f1985 is F1985<bool>);
+ Expect.isTrue(confuse(f1985) is F1985<int>);
+ Expect.isFalse(confuse(f1985) is F1985<bool>);
+ Expect.equals(tIsDynamic, m1985 is F1985<bool>);
+ Expect.equals(tIsDynamic, confuse(m1985) is F1985<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1985 = (f1985 as dynamic); });
+ Expect.throws(() { x1985 = confuse(f1985); });
+ List<A> Function<A>(List<T> x) Function(int x) l1985;
+ Expect.throws(() { l1985 = (f1985 as dynamic); });
+ Expect.throws(() { l1985 = confuse(f1985); });
+ }
+ List<A> Function<A>(List<T> x) Function(int x) l1985 = m1985;
+ // In checked mode, verifies the type.
+ x1985 = m1985;
+ x1985 = confuse(m1985);
+ }
+ }
+
+
+}
+
+class C86<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function({List<Function> x}) x86;
+ core.List<core.int> Function(int x, [Function x2]) x186;
+ Function(int x1, [int x2]) x286;
+ A Function<A>(List<Function> x) x386;
+ int Function(int y, {Function x}) Function<B extends core.int>() x486;
+ int Function(int x1, [List<T> x]) Function<B extends core.int>() x586;
+ Function Function(Function x1) Function<B extends core.int>() x686;
+ Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() x786;
+ List<Function> Function(int x1, {int x}) Function<B extends core.int>() x886;
+ List<Function> Function([core.List<core.int> x]) Function<B extends core.int>() x986;
+ core.List<core.int> Function(int y, [int x]) Function<B extends core.int>() x1086;
+ core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>() x1186;
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>() x1286;
+ List<T> Function(List<Function> x) Function<B extends core.int>() x1386;
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>() x1486;
+ Function([Function x1]) Function<B extends core.int>() x1586;
+ Function({core.List<core.int> x}) Function<B extends core.int>() x1686;
+ Function Function<A>(List<Function> x) Function<B extends core.int>() x1786;
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>() x1886;
+ List<A> Function<A>(List<T> x) Function<B extends core.int>() x1986;
+
+
+ C86({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m86({List<Function> x}) => null;
+ core.List<core.int> m186(int x, [Function x0]) => null;
+ m286(int x0, [int x1]) => null;
+ A m386<A>(List<Function> x) => null;
+ int Function(int y, {Function x}) m486<B extends core.int>() => null;
+ int Function(int x0, [List<T> x]) m586<B extends core.int>() => null;
+ Function Function(Function x0) m686<B extends core.int>() => null;
+ Function Function(int x, [core.List<core.int> x0]) m786<B extends core.int>() => null;
+ List<Function> Function(int x0, {int x}) m886<B extends core.int>() => null;
+ List<Function> Function([core.List<core.int> x]) m986<B extends core.int>() => null;
+ core.List<core.int> Function(int y, [int x]) m1086<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [List<Function> x1]) m1186<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, {List<T> x}) m1286<B extends core.int>() => null;
+ List<T> Function(List<Function> x) m1386<B extends core.int>() => null;
+ List<T> Function(int y, [List<T> x]) m1486<B extends core.int>() => null;
+ Function([Function x0]) m1586<B extends core.int>() => null;
+ Function({core.List<core.int> x}) m1686<B extends core.int>() => null;
+ Function Function<A>(List<Function> x) m1786<B extends core.int>() => null;
+ List<T> Function<A>(core.List<core.int> x) m1886<B extends core.int>() => null;
+ List<A> Function<A>(List<T> x) m1986<B extends core.int>() => null;
+
+
+ runTests() {
+ testF86();
+ testF186();
+ testF286();
+ testF386();
+ testF486();
+ testF586();
+ testF686();
+ testF786();
+ testF886();
+ testF986();
+ testF1086();
+ testF1186();
+ testF1286();
+ testF1386();
+ testF1486();
+ testF1586();
+ testF1686();
+ testF1786();
+ testF1886();
+ testF1986();
+ }
+
+ void testF86() {
+ // Function Function({List<Function> x})
+ Expect.isTrue(f86 is F86);
+ Expect.isTrue(confuse(f86) is F86);
+ // In checked mode, verifies the type.
+ Function Function({List<Function> x}) l86;
+ // The static function f86 sets `T` to `int`.
+ if (!tIsBool) {
+ x86 = f86 as dynamic;
+ l86 = f86 as dynamic;
+ x86 = confuse(f86);
+ l86 = confuse(f86);
+ }
+
+ Expect.isTrue(m86 is F86);
+ Expect.isTrue(m86 is Function Function({List<Function> x}));
+ Expect.isTrue(confuse(m86) is F86);
+ // In checked mode, verifies the type.
+ x86 = m86;
+ l86 = m86;
+ x86 = confuse(m86);
+ l86 = confuse(m86);
+
+ }
+
+ void testF186() {
+ // core.List<core.int> Function(int x, [Function x2])
+ Expect.isTrue(f186 is F186);
+ Expect.isTrue(confuse(f186) is F186);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [Function x2]) l186;
+ // The static function f186 sets `T` to `int`.
+ if (!tIsBool) {
+ x186 = f186 as dynamic;
+ l186 = f186 as dynamic;
+ x186 = confuse(f186);
+ l186 = confuse(f186);
+ }
+
+ Expect.isTrue(m186 is F186);
+ Expect.isTrue(m186 is core.List<core.int> Function(int x, [Function x2]));
+ Expect.isTrue(confuse(m186) is F186);
+ // In checked mode, verifies the type.
+ x186 = m186;
+ l186 = m186;
+ x186 = confuse(m186);
+ l186 = confuse(m186);
+
+ }
+
+ void testF286() {
+ // Function(int x1, [int x2])
+ Expect.isTrue(f286 is F286);
+ Expect.isTrue(confuse(f286) is F286);
+ // In checked mode, verifies the type.
+ Function(int x1, [int x2]) l286;
+ // The static function f286 sets `T` to `int`.
+ if (!tIsBool) {
+ x286 = f286 as dynamic;
+ l286 = f286 as dynamic;
+ x286 = confuse(f286);
+ l286 = confuse(f286);
+ }
+
+ Expect.isTrue(m286 is F286);
+ Expect.isTrue(m286 is Function(int x1, [int x2]));
+ Expect.isTrue(confuse(m286) is F286);
+ // In checked mode, verifies the type.
+ x286 = m286;
+ l286 = m286;
+ x286 = confuse(m286);
+ l286 = confuse(m286);
+
+ }
+
+ void testF386() {
+ // A Function<A>(List<Function> x)
+ Expect.isTrue(f386 is F386);
+ Expect.isTrue(confuse(f386) is F386);
+ // In checked mode, verifies the type.
+ A Function<A>(List<Function> x) l386;
+ // The static function f386 sets `T` to `int`.
+ if (!tIsBool) {
+ x386 = f386 as dynamic;
+ l386 = f386 as dynamic;
+ x386 = confuse(f386);
+ l386 = confuse(f386);
+ }
+
+ Expect.isTrue(m386 is F386);
+ Expect.isTrue(m386 is A Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m386) is F386);
+ // In checked mode, verifies the type.
+ x386 = m386;
+ l386 = m386;
+ x386 = confuse(m386);
+ l386 = confuse(m386);
+
+ }
+
+ void testF486() {
+ // int Function(int y, {Function x}) Function<B extends core.int>()
+ Expect.isTrue(f486 is F486);
+ Expect.isTrue(confuse(f486) is F486);
+ // In checked mode, verifies the type.
+ int Function(int y, {Function x}) Function<B extends core.int>() l486;
+ // The static function f486 sets `T` to `int`.
+ if (!tIsBool) {
+ x486 = f486 as dynamic;
+ l486 = f486 as dynamic;
+ x486 = confuse(f486);
+ l486 = confuse(f486);
+ }
+
+ Expect.isTrue(m486 is F486);
+ Expect.isTrue(m486 is int Function(int y, {Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m486) is F486);
+ // In checked mode, verifies the type.
+ x486 = m486;
+ l486 = m486;
+ x486 = confuse(m486);
+ l486 = confuse(m486);
+
+ }
+
+ void testF586() {
+ // int Function(int x1, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f586 is F586);
+ Expect.isTrue(confuse(f586) is F586);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<T> x]) Function<B extends core.int>() l586;
+ // The static function f586 sets `T` to `int`.
+ if (!tIsBool) {
+ x586 = f586 as dynamic;
+ l586 = f586 as dynamic;
+ x586 = confuse(f586);
+ l586 = confuse(f586);
+ }
+
+ Expect.isTrue(m586 is F586);
+ Expect.isTrue(m586 is int Function(int x1, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m586) is F586);
+ // In checked mode, verifies the type.
+ x586 = m586;
+ l586 = m586;
+ x586 = confuse(m586);
+ l586 = confuse(m586);
+ if (!tIsBool) {
+ Expect.isTrue(f586 is F586<int>);
+ Expect.isFalse(f586 is F586<bool>);
+ Expect.isTrue(confuse(f586) is F586<int>);
+ Expect.isFalse(confuse(f586) is F586<bool>);
+ Expect.equals(tIsDynamic, m586 is F586<bool>);
+ Expect.equals(tIsDynamic, confuse(m586) is F586<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x586 = (f586 as dynamic); });
+ Expect.throws(() { x586 = confuse(f586); });
+ int Function(int x1, [List<T> x]) Function<B extends core.int>() l586;
+ Expect.throws(() { l586 = (f586 as dynamic); });
+ Expect.throws(() { l586 = confuse(f586); });
+ }
+ int Function(int x1, [List<T> x]) Function<B extends core.int>() l586 = m586;
+ // In checked mode, verifies the type.
+ x586 = m586;
+ x586 = confuse(m586);
+ }
+ }
+
+ void testF686() {
+ // Function Function(Function x1) Function<B extends core.int>()
+ Expect.isTrue(f686 is F686);
+ Expect.isTrue(confuse(f686) is F686);
+ // In checked mode, verifies the type.
+ Function Function(Function x1) Function<B extends core.int>() l686;
+ // The static function f686 sets `T` to `int`.
+ if (!tIsBool) {
+ x686 = f686 as dynamic;
+ l686 = f686 as dynamic;
+ x686 = confuse(f686);
+ l686 = confuse(f686);
+ }
+
+ Expect.isTrue(m686 is F686);
+ Expect.isTrue(m686 is Function Function(Function x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m686) is F686);
+ // In checked mode, verifies the type.
+ x686 = m686;
+ l686 = m686;
+ x686 = confuse(m686);
+ l686 = confuse(m686);
+
+ }
+
+ void testF786() {
+ // Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>()
+ Expect.isTrue(f786 is F786);
+ Expect.isTrue(confuse(f786) is F786);
+ // In checked mode, verifies the type.
+ Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>() l786;
+ // The static function f786 sets `T` to `int`.
+ if (!tIsBool) {
+ x786 = f786 as dynamic;
+ l786 = f786 as dynamic;
+ x786 = confuse(f786);
+ l786 = confuse(f786);
+ }
+
+ Expect.isTrue(m786 is F786);
+ Expect.isTrue(m786 is Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m786) is F786);
+ // In checked mode, verifies the type.
+ x786 = m786;
+ l786 = m786;
+ x786 = confuse(m786);
+ l786 = confuse(m786);
+
+ }
+
+ void testF886() {
+ // List<Function> Function(int x1, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f886 is F886);
+ Expect.isTrue(confuse(f886) is F886);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {int x}) Function<B extends core.int>() l886;
+ // The static function f886 sets `T` to `int`.
+ if (!tIsBool) {
+ x886 = f886 as dynamic;
+ l886 = f886 as dynamic;
+ x886 = confuse(f886);
+ l886 = confuse(f886);
+ }
+
+ Expect.isTrue(m886 is F886);
+ Expect.isTrue(m886 is List<Function> Function(int x1, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m886) is F886);
+ // In checked mode, verifies the type.
+ x886 = m886;
+ l886 = m886;
+ x886 = confuse(m886);
+ l886 = confuse(m886);
+
+ }
+
+ void testF986() {
+ // List<Function> Function([core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f986 is F986);
+ Expect.isTrue(confuse(f986) is F986);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x]) Function<B extends core.int>() l986;
+ // The static function f986 sets `T` to `int`.
+ if (!tIsBool) {
+ x986 = f986 as dynamic;
+ l986 = f986 as dynamic;
+ x986 = confuse(f986);
+ l986 = confuse(f986);
+ }
+
+ Expect.isTrue(m986 is F986);
+ Expect.isTrue(m986 is List<Function> Function([core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m986) is F986);
+ // In checked mode, verifies the type.
+ x986 = m986;
+ l986 = m986;
+ x986 = confuse(m986);
+ l986 = confuse(m986);
+
+ }
+
+ void testF1086() {
+ // core.List<core.int> Function(int y, [int x]) Function<B extends core.int>()
+ Expect.isTrue(f1086 is F1086);
+ Expect.isTrue(confuse(f1086) is F1086);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [int x]) Function<B extends core.int>() l1086;
+ // The static function f1086 sets `T` to `int`.
+ if (!tIsBool) {
+ x1086 = f1086 as dynamic;
+ l1086 = f1086 as dynamic;
+ x1086 = confuse(f1086);
+ l1086 = confuse(f1086);
+ }
+
+ Expect.isTrue(m1086 is F1086);
+ Expect.isTrue(m1086 is core.List<core.int> Function(int y, [int x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1086) is F1086);
+ // In checked mode, verifies the type.
+ x1086 = m1086;
+ l1086 = m1086;
+ x1086 = confuse(m1086);
+ l1086 = confuse(m1086);
+
+ }
+
+ void testF1186() {
+ // core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1186 is F1186);
+ Expect.isTrue(confuse(f1186) is F1186);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>() l1186;
+ // The static function f1186 sets `T` to `int`.
+ if (!tIsBool) {
+ x1186 = f1186 as dynamic;
+ l1186 = f1186 as dynamic;
+ x1186 = confuse(f1186);
+ l1186 = confuse(f1186);
+ }
+
+ Expect.isTrue(m1186 is F1186);
+ Expect.isTrue(m1186 is core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1186) is F1186);
+ // In checked mode, verifies the type.
+ x1186 = m1186;
+ l1186 = m1186;
+ x1186 = confuse(m1186);
+ l1186 = confuse(m1186);
+
+ }
+
+ void testF1286() {
+ // core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1286 is F1286);
+ Expect.isTrue(confuse(f1286) is F1286);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>() l1286;
+ // The static function f1286 sets `T` to `int`.
+ if (!tIsBool) {
+ x1286 = f1286 as dynamic;
+ l1286 = f1286 as dynamic;
+ x1286 = confuse(f1286);
+ l1286 = confuse(f1286);
+ }
+
+ Expect.isTrue(m1286 is F1286);
+ Expect.isTrue(m1286 is core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1286) is F1286);
+ // In checked mode, verifies the type.
+ x1286 = m1286;
+ l1286 = m1286;
+ x1286 = confuse(m1286);
+ l1286 = confuse(m1286);
+ if (!tIsBool) {
+ Expect.isTrue(f1286 is F1286<int>);
+ Expect.isFalse(f1286 is F1286<bool>);
+ Expect.isTrue(confuse(f1286) is F1286<int>);
+ Expect.isFalse(confuse(f1286) is F1286<bool>);
+ Expect.equals(tIsDynamic, m1286 is F1286<bool>);
+ Expect.equals(tIsDynamic, confuse(m1286) is F1286<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1286 = (f1286 as dynamic); });
+ Expect.throws(() { x1286 = confuse(f1286); });
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>() l1286;
+ Expect.throws(() { l1286 = (f1286 as dynamic); });
+ Expect.throws(() { l1286 = confuse(f1286); });
+ }
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>() l1286 = m1286;
+ // In checked mode, verifies the type.
+ x1286 = m1286;
+ x1286 = confuse(m1286);
+ }
+ }
+
+ void testF1386() {
+ // List<T> Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1386 is F1386);
+ Expect.isTrue(confuse(f1386) is F1386);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x) Function<B extends core.int>() l1386;
+ // The static function f1386 sets `T` to `int`.
+ if (!tIsBool) {
+ x1386 = f1386 as dynamic;
+ l1386 = f1386 as dynamic;
+ x1386 = confuse(f1386);
+ l1386 = confuse(f1386);
+ }
+
+ Expect.isTrue(m1386 is F1386);
+ Expect.isTrue(m1386 is List<T> Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1386) is F1386);
+ // In checked mode, verifies the type.
+ x1386 = m1386;
+ l1386 = m1386;
+ x1386 = confuse(m1386);
+ l1386 = confuse(m1386);
+ if (!tIsBool) {
+ Expect.isTrue(f1386 is F1386<int>);
+ Expect.isFalse(f1386 is F1386<bool>);
+ Expect.isTrue(confuse(f1386) is F1386<int>);
+ Expect.isFalse(confuse(f1386) is F1386<bool>);
+ Expect.equals(tIsDynamic, m1386 is F1386<bool>);
+ Expect.equals(tIsDynamic, confuse(m1386) is F1386<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1386 = (f1386 as dynamic); });
+ Expect.throws(() { x1386 = confuse(f1386); });
+ List<T> Function(List<Function> x) Function<B extends core.int>() l1386;
+ Expect.throws(() { l1386 = (f1386 as dynamic); });
+ Expect.throws(() { l1386 = confuse(f1386); });
+ }
+ List<T> Function(List<Function> x) Function<B extends core.int>() l1386 = m1386;
+ // In checked mode, verifies the type.
+ x1386 = m1386;
+ x1386 = confuse(m1386);
+ }
+ }
+
+ void testF1486() {
+ // List<T> Function(int y, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f1486 is F1486);
+ Expect.isTrue(confuse(f1486) is F1486);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>() l1486;
+ // The static function f1486 sets `T` to `int`.
+ if (!tIsBool) {
+ x1486 = f1486 as dynamic;
+ l1486 = f1486 as dynamic;
+ x1486 = confuse(f1486);
+ l1486 = confuse(f1486);
+ }
+
+ Expect.isTrue(m1486 is F1486);
+ Expect.isTrue(m1486 is List<T> Function(int y, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1486) is F1486);
+ // In checked mode, verifies the type.
+ x1486 = m1486;
+ l1486 = m1486;
+ x1486 = confuse(m1486);
+ l1486 = confuse(m1486);
+ if (!tIsBool) {
+ Expect.isTrue(f1486 is F1486<int>);
+ Expect.isFalse(f1486 is F1486<bool>);
+ Expect.isTrue(confuse(f1486) is F1486<int>);
+ Expect.isFalse(confuse(f1486) is F1486<bool>);
+ Expect.equals(tIsDynamic, m1486 is F1486<bool>);
+ Expect.equals(tIsDynamic, confuse(m1486) is F1486<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1486 = (f1486 as dynamic); });
+ Expect.throws(() { x1486 = confuse(f1486); });
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>() l1486;
+ Expect.throws(() { l1486 = (f1486 as dynamic); });
+ Expect.throws(() { l1486 = confuse(f1486); });
+ }
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>() l1486 = m1486;
+ // In checked mode, verifies the type.
+ x1486 = m1486;
+ x1486 = confuse(m1486);
+ }
+ }
+
+ void testF1586() {
+ // Function([Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f1586 is F1586);
+ Expect.isTrue(confuse(f1586) is F1586);
+ // In checked mode, verifies the type.
+ Function([Function x1]) Function<B extends core.int>() l1586;
+ // The static function f1586 sets `T` to `int`.
+ if (!tIsBool) {
+ x1586 = f1586 as dynamic;
+ l1586 = f1586 as dynamic;
+ x1586 = confuse(f1586);
+ l1586 = confuse(f1586);
+ }
+
+ Expect.isTrue(m1586 is F1586);
+ Expect.isTrue(m1586 is Function([Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1586) is F1586);
+ // In checked mode, verifies the type.
+ x1586 = m1586;
+ l1586 = m1586;
+ x1586 = confuse(m1586);
+ l1586 = confuse(m1586);
+
+ }
+
+ void testF1686() {
+ // Function({core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1686 is F1686);
+ Expect.isTrue(confuse(f1686) is F1686);
+ // In checked mode, verifies the type.
+ Function({core.List<core.int> x}) Function<B extends core.int>() l1686;
+ // The static function f1686 sets `T` to `int`.
+ if (!tIsBool) {
+ x1686 = f1686 as dynamic;
+ l1686 = f1686 as dynamic;
+ x1686 = confuse(f1686);
+ l1686 = confuse(f1686);
+ }
+
+ Expect.isTrue(m1686 is F1686);
+ Expect.isTrue(m1686 is Function({core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1686) is F1686);
+ // In checked mode, verifies the type.
+ x1686 = m1686;
+ l1686 = m1686;
+ x1686 = confuse(m1686);
+ l1686 = confuse(m1686);
+
+ }
+
+ void testF1786() {
+ // Function Function<A>(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f1786 is F1786);
+ Expect.isTrue(confuse(f1786) is F1786);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<Function> x) Function<B extends core.int>() l1786;
+ // The static function f1786 sets `T` to `int`.
+ if (!tIsBool) {
+ x1786 = f1786 as dynamic;
+ l1786 = f1786 as dynamic;
+ x1786 = confuse(f1786);
+ l1786 = confuse(f1786);
+ }
+
+ Expect.isTrue(m1786 is F1786);
+ Expect.isTrue(m1786 is Function Function<A>(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1786) is F1786);
+ // In checked mode, verifies the type.
+ x1786 = m1786;
+ l1786 = m1786;
+ x1786 = confuse(m1786);
+ l1786 = confuse(m1786);
+
+ }
+
+ void testF1886() {
+ // List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1886 is F1886);
+ Expect.isTrue(confuse(f1886) is F1886);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>() l1886;
+ // The static function f1886 sets `T` to `int`.
+ if (!tIsBool) {
+ x1886 = f1886 as dynamic;
+ l1886 = f1886 as dynamic;
+ x1886 = confuse(f1886);
+ l1886 = confuse(f1886);
+ }
+
+ Expect.isTrue(m1886 is F1886);
+ Expect.isTrue(m1886 is List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1886) is F1886);
+ // In checked mode, verifies the type.
+ x1886 = m1886;
+ l1886 = m1886;
+ x1886 = confuse(m1886);
+ l1886 = confuse(m1886);
+ if (!tIsBool) {
+ Expect.isTrue(f1886 is F1886<int>);
+ Expect.isFalse(f1886 is F1886<bool>);
+ Expect.isTrue(confuse(f1886) is F1886<int>);
+ Expect.isFalse(confuse(f1886) is F1886<bool>);
+ Expect.equals(tIsDynamic, m1886 is F1886<bool>);
+ Expect.equals(tIsDynamic, confuse(m1886) is F1886<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1886 = (f1886 as dynamic); });
+ Expect.throws(() { x1886 = confuse(f1886); });
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>() l1886;
+ Expect.throws(() { l1886 = (f1886 as dynamic); });
+ Expect.throws(() { l1886 = confuse(f1886); });
+ }
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>() l1886 = m1886;
+ // In checked mode, verifies the type.
+ x1886 = m1886;
+ x1886 = confuse(m1886);
+ }
+ }
+
+ void testF1986() {
+ // List<A> Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1986 is F1986);
+ Expect.isTrue(confuse(f1986) is F1986);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<T> x) Function<B extends core.int>() l1986;
+ // The static function f1986 sets `T` to `int`.
+ if (!tIsBool) {
+ x1986 = f1986 as dynamic;
+ l1986 = f1986 as dynamic;
+ x1986 = confuse(f1986);
+ l1986 = confuse(f1986);
+ }
+
+ Expect.isTrue(m1986 is F1986);
+ Expect.isTrue(m1986 is List<A> Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1986) is F1986);
+ // In checked mode, verifies the type.
+ x1986 = m1986;
+ l1986 = m1986;
+ x1986 = confuse(m1986);
+ l1986 = confuse(m1986);
+ if (!tIsBool) {
+ Expect.isTrue(f1986 is F1986<int>);
+ Expect.isFalse(f1986 is F1986<bool>);
+ Expect.isTrue(confuse(f1986) is F1986<int>);
+ Expect.isFalse(confuse(f1986) is F1986<bool>);
+ Expect.equals(tIsDynamic, m1986 is F1986<bool>);
+ Expect.equals(tIsDynamic, confuse(m1986) is F1986<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1986 = (f1986 as dynamic); });
+ Expect.throws(() { x1986 = confuse(f1986); });
+ List<A> Function<A>(List<T> x) Function<B extends core.int>() l1986;
+ Expect.throws(() { l1986 = (f1986 as dynamic); });
+ Expect.throws(() { l1986 = confuse(f1986); });
+ }
+ List<A> Function<A>(List<T> x) Function<B extends core.int>() l1986 = m1986;
+ // In checked mode, verifies the type.
+ x1986 = m1986;
+ x1986 = confuse(m1986);
+ }
+ }
+
+
+}
+
+class C87<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, {List<Function> x}) x87;
+ core.List<core.int> Function({Function x}) x187;
+ Function(int x, [int x2]) x287;
+ A Function<A>(core.List<core.int> x) x387;
+ int Function(int y, {Function x}) Function<B extends core.int>(int x) x487;
+ int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x587;
+ Function Function(Function x1) Function<B extends core.int>(int x) x687;
+ Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) x787;
+ List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x) x887;
+ List<Function> Function([core.List<core.int> x]) Function<B extends core.int>(int x) x987;
+ core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(int x) x1087;
+ core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) x1187;
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) x1287;
+ List<T> Function(List<Function> x) Function<B extends core.int>(int x) x1387;
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) x1487;
+ Function([Function x1]) Function<B extends core.int>(int x) x1587;
+ Function({core.List<core.int> x}) Function<B extends core.int>(int x) x1687;
+ Function Function<A>(List<Function> x) Function<B extends core.int>(int x) x1787;
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1887;
+ List<A> Function<A>(List<T> x) Function<B extends core.int>(int x) x1987;
+
+
+ C87({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m87(int x0, {List<Function> x}) => null;
+ core.List<core.int> m187({Function x}) => null;
+ m287(int x, [int x0]) => null;
+ A m387<A>(core.List<core.int> x) => null;
+ int Function(int y, {Function x}) m487<B extends core.int>(int x) => null;
+ int Function(int x0, [List<T> x]) m587<B extends core.int>(int x) => null;
+ Function Function(Function x0) m687<B extends core.int>(int x) => null;
+ Function Function(int x, [core.List<core.int> x0]) m787<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, {int x}) m887<B extends core.int>(int x) => null;
+ List<Function> Function([core.List<core.int> x]) m987<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, [int x]) m1087<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [List<Function> x1]) m1187<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, {List<T> x}) m1287<B extends core.int>(int x) => null;
+ List<T> Function(List<Function> x) m1387<B extends core.int>(int x) => null;
+ List<T> Function(int y, [List<T> x]) m1487<B extends core.int>(int x) => null;
+ Function([Function x0]) m1587<B extends core.int>(int x) => null;
+ Function({core.List<core.int> x}) m1687<B extends core.int>(int x) => null;
+ Function Function<A>(List<Function> x) m1787<B extends core.int>(int x) => null;
+ List<T> Function<A>(core.List<core.int> x) m1887<B extends core.int>(int x) => null;
+ List<A> Function<A>(List<T> x) m1987<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF87();
+ testF187();
+ testF287();
+ testF387();
+ testF487();
+ testF587();
+ testF687();
+ testF787();
+ testF887();
+ testF987();
+ testF1087();
+ testF1187();
+ testF1287();
+ testF1387();
+ testF1487();
+ testF1587();
+ testF1687();
+ testF1787();
+ testF1887();
+ testF1987();
+ }
+
+ void testF87() {
+ // Function Function(int x0, {List<Function> x})
+ Expect.isTrue(f87 is F87);
+ Expect.isTrue(confuse(f87) is F87);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {List<Function> x}) l87;
+ // The static function f87 sets `T` to `int`.
+ if (!tIsBool) {
+ x87 = f87 as dynamic;
+ l87 = f87 as dynamic;
+ x87 = confuse(f87);
+ l87 = confuse(f87);
+ }
+
+ Expect.isTrue(m87 is F87);
+ Expect.isTrue(m87 is Function Function(int x0, {List<Function> x}));
+ Expect.isTrue(confuse(m87) is F87);
+ // In checked mode, verifies the type.
+ x87 = m87;
+ l87 = m87;
+ x87 = confuse(m87);
+ l87 = confuse(m87);
+
+ }
+
+ void testF187() {
+ // core.List<core.int> Function({Function x})
+ Expect.isTrue(f187 is F187);
+ Expect.isTrue(confuse(f187) is F187);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({Function x}) l187;
+ // The static function f187 sets `T` to `int`.
+ if (!tIsBool) {
+ x187 = f187 as dynamic;
+ l187 = f187 as dynamic;
+ x187 = confuse(f187);
+ l187 = confuse(f187);
+ }
+
+ Expect.isTrue(m187 is F187);
+ Expect.isTrue(m187 is core.List<core.int> Function({Function x}));
+ Expect.isTrue(confuse(m187) is F187);
+ // In checked mode, verifies the type.
+ x187 = m187;
+ l187 = m187;
+ x187 = confuse(m187);
+ l187 = confuse(m187);
+
+ }
+
+ void testF287() {
+ // Function(int x, [int x2])
+ Expect.isTrue(f287 is F287);
+ Expect.isTrue(confuse(f287) is F287);
+ // In checked mode, verifies the type.
+ Function(int x, [int x2]) l287;
+ // The static function f287 sets `T` to `int`.
+ if (!tIsBool) {
+ x287 = f287 as dynamic;
+ l287 = f287 as dynamic;
+ x287 = confuse(f287);
+ l287 = confuse(f287);
+ }
+
+ Expect.isTrue(m287 is F287);
+ Expect.isTrue(m287 is Function(int x, [int x2]));
+ Expect.isTrue(confuse(m287) is F287);
+ // In checked mode, verifies the type.
+ x287 = m287;
+ l287 = m287;
+ x287 = confuse(m287);
+ l287 = confuse(m287);
+
+ }
+
+ void testF387() {
+ // A Function<A>(core.List<core.int> x)
+ Expect.isTrue(f387 is F387);
+ Expect.isTrue(confuse(f387) is F387);
+ // In checked mode, verifies the type.
+ A Function<A>(core.List<core.int> x) l387;
+ // The static function f387 sets `T` to `int`.
+ if (!tIsBool) {
+ x387 = f387 as dynamic;
+ l387 = f387 as dynamic;
+ x387 = confuse(f387);
+ l387 = confuse(f387);
+ }
+
+ Expect.isTrue(m387 is F387);
+ Expect.isTrue(m387 is A Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m387) is F387);
+ // In checked mode, verifies the type.
+ x387 = m387;
+ l387 = m387;
+ x387 = confuse(m387);
+ l387 = confuse(m387);
+
+ }
+
+ void testF487() {
+ // int Function(int y, {Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f487 is F487);
+ Expect.isTrue(confuse(f487) is F487);
+ // In checked mode, verifies the type.
+ int Function(int y, {Function x}) Function<B extends core.int>(int x) l487;
+ // The static function f487 sets `T` to `int`.
+ if (!tIsBool) {
+ x487 = f487 as dynamic;
+ l487 = f487 as dynamic;
+ x487 = confuse(f487);
+ l487 = confuse(f487);
+ }
+
+ Expect.isTrue(m487 is F487);
+ Expect.isTrue(m487 is int Function(int y, {Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m487) is F487);
+ // In checked mode, verifies the type.
+ x487 = m487;
+ l487 = m487;
+ x487 = confuse(m487);
+ l487 = confuse(m487);
+
+ }
+
+ void testF587() {
+ // int Function(int x1, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f587 is F587);
+ Expect.isTrue(confuse(f587) is F587);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l587;
+ // The static function f587 sets `T` to `int`.
+ if (!tIsBool) {
+ x587 = f587 as dynamic;
+ l587 = f587 as dynamic;
+ x587 = confuse(f587);
+ l587 = confuse(f587);
+ }
+
+ Expect.isTrue(m587 is F587);
+ Expect.isTrue(m587 is int Function(int x1, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m587) is F587);
+ // In checked mode, verifies the type.
+ x587 = m587;
+ l587 = m587;
+ x587 = confuse(m587);
+ l587 = confuse(m587);
+ if (!tIsBool) {
+ Expect.isTrue(f587 is F587<int>);
+ Expect.isFalse(f587 is F587<bool>);
+ Expect.isTrue(confuse(f587) is F587<int>);
+ Expect.isFalse(confuse(f587) is F587<bool>);
+ Expect.equals(tIsDynamic, m587 is F587<bool>);
+ Expect.equals(tIsDynamic, confuse(m587) is F587<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x587 = (f587 as dynamic); });
+ Expect.throws(() { x587 = confuse(f587); });
+ int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l587;
+ Expect.throws(() { l587 = (f587 as dynamic); });
+ Expect.throws(() { l587 = confuse(f587); });
+ }
+ int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l587 = m587;
+ // In checked mode, verifies the type.
+ x587 = m587;
+ x587 = confuse(m587);
+ }
+ }
+
+ void testF687() {
+ // Function Function(Function x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f687 is F687);
+ Expect.isTrue(confuse(f687) is F687);
+ // In checked mode, verifies the type.
+ Function Function(Function x1) Function<B extends core.int>(int x) l687;
+ // The static function f687 sets `T` to `int`.
+ if (!tIsBool) {
+ x687 = f687 as dynamic;
+ l687 = f687 as dynamic;
+ x687 = confuse(f687);
+ l687 = confuse(f687);
+ }
+
+ Expect.isTrue(m687 is F687);
+ Expect.isTrue(m687 is Function Function(Function x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m687) is F687);
+ // In checked mode, verifies the type.
+ x687 = m687;
+ l687 = m687;
+ x687 = confuse(m687);
+ l687 = confuse(m687);
+
+ }
+
+ void testF787() {
+ // Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f787 is F787);
+ Expect.isTrue(confuse(f787) is F787);
+ // In checked mode, verifies the type.
+ Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x) l787;
+ // The static function f787 sets `T` to `int`.
+ if (!tIsBool) {
+ x787 = f787 as dynamic;
+ l787 = f787 as dynamic;
+ x787 = confuse(f787);
+ l787 = confuse(f787);
+ }
+
+ Expect.isTrue(m787 is F787);
+ Expect.isTrue(m787 is Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m787) is F787);
+ // In checked mode, verifies the type.
+ x787 = m787;
+ l787 = m787;
+ x787 = confuse(m787);
+ l787 = confuse(m787);
+
+ }
+
+ void testF887() {
+ // List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f887 is F887);
+ Expect.isTrue(confuse(f887) is F887);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x) l887;
+ // The static function f887 sets `T` to `int`.
+ if (!tIsBool) {
+ x887 = f887 as dynamic;
+ l887 = f887 as dynamic;
+ x887 = confuse(f887);
+ l887 = confuse(f887);
+ }
+
+ Expect.isTrue(m887 is F887);
+ Expect.isTrue(m887 is List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m887) is F887);
+ // In checked mode, verifies the type.
+ x887 = m887;
+ l887 = m887;
+ x887 = confuse(m887);
+ l887 = confuse(m887);
+
+ }
+
+ void testF987() {
+ // List<Function> Function([core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f987 is F987);
+ Expect.isTrue(confuse(f987) is F987);
+ // In checked mode, verifies the type.
+ List<Function> Function([core.List<core.int> x]) Function<B extends core.int>(int x) l987;
+ // The static function f987 sets `T` to `int`.
+ if (!tIsBool) {
+ x987 = f987 as dynamic;
+ l987 = f987 as dynamic;
+ x987 = confuse(f987);
+ l987 = confuse(f987);
+ }
+
+ Expect.isTrue(m987 is F987);
+ Expect.isTrue(m987 is List<Function> Function([core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m987) is F987);
+ // In checked mode, verifies the type.
+ x987 = m987;
+ l987 = m987;
+ x987 = confuse(m987);
+ l987 = confuse(m987);
+
+ }
+
+ void testF1087() {
+ // core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1087 is F1087);
+ Expect.isTrue(confuse(f1087) is F1087);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(int x) l1087;
+ // The static function f1087 sets `T` to `int`.
+ if (!tIsBool) {
+ x1087 = f1087 as dynamic;
+ l1087 = f1087 as dynamic;
+ x1087 = confuse(f1087);
+ l1087 = confuse(f1087);
+ }
+
+ Expect.isTrue(m1087 is F1087);
+ Expect.isTrue(m1087 is core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1087) is F1087);
+ // In checked mode, verifies the type.
+ x1087 = m1087;
+ l1087 = m1087;
+ x1087 = confuse(m1087);
+ l1087 = confuse(m1087);
+
+ }
+
+ void testF1187() {
+ // core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1187 is F1187);
+ Expect.isTrue(confuse(f1187) is F1187);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x) l1187;
+ // The static function f1187 sets `T` to `int`.
+ if (!tIsBool) {
+ x1187 = f1187 as dynamic;
+ l1187 = f1187 as dynamic;
+ x1187 = confuse(f1187);
+ l1187 = confuse(f1187);
+ }
+
+ Expect.isTrue(m1187 is F1187);
+ Expect.isTrue(m1187 is core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1187) is F1187);
+ // In checked mode, verifies the type.
+ x1187 = m1187;
+ l1187 = m1187;
+ x1187 = confuse(m1187);
+ l1187 = confuse(m1187);
+
+ }
+
+ void testF1287() {
+ // core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1287 is F1287);
+ Expect.isTrue(confuse(f1287) is F1287);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1287;
+ // The static function f1287 sets `T` to `int`.
+ if (!tIsBool) {
+ x1287 = f1287 as dynamic;
+ l1287 = f1287 as dynamic;
+ x1287 = confuse(f1287);
+ l1287 = confuse(f1287);
+ }
+
+ Expect.isTrue(m1287 is F1287);
+ Expect.isTrue(m1287 is core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1287) is F1287);
+ // In checked mode, verifies the type.
+ x1287 = m1287;
+ l1287 = m1287;
+ x1287 = confuse(m1287);
+ l1287 = confuse(m1287);
+ if (!tIsBool) {
+ Expect.isTrue(f1287 is F1287<int>);
+ Expect.isFalse(f1287 is F1287<bool>);
+ Expect.isTrue(confuse(f1287) is F1287<int>);
+ Expect.isFalse(confuse(f1287) is F1287<bool>);
+ Expect.equals(tIsDynamic, m1287 is F1287<bool>);
+ Expect.equals(tIsDynamic, confuse(m1287) is F1287<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1287 = (f1287 as dynamic); });
+ Expect.throws(() { x1287 = confuse(f1287); });
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1287;
+ Expect.throws(() { l1287 = (f1287 as dynamic); });
+ Expect.throws(() { l1287 = confuse(f1287); });
+ }
+ core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>(int x) l1287 = m1287;
+ // In checked mode, verifies the type.
+ x1287 = m1287;
+ x1287 = confuse(m1287);
+ }
+ }
+
+ void testF1387() {
+ // List<T> Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1387 is F1387);
+ Expect.isTrue(confuse(f1387) is F1387);
+ // In checked mode, verifies the type.
+ List<T> Function(List<Function> x) Function<B extends core.int>(int x) l1387;
+ // The static function f1387 sets `T` to `int`.
+ if (!tIsBool) {
+ x1387 = f1387 as dynamic;
+ l1387 = f1387 as dynamic;
+ x1387 = confuse(f1387);
+ l1387 = confuse(f1387);
+ }
+
+ Expect.isTrue(m1387 is F1387);
+ Expect.isTrue(m1387 is List<T> Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1387) is F1387);
+ // In checked mode, verifies the type.
+ x1387 = m1387;
+ l1387 = m1387;
+ x1387 = confuse(m1387);
+ l1387 = confuse(m1387);
+ if (!tIsBool) {
+ Expect.isTrue(f1387 is F1387<int>);
+ Expect.isFalse(f1387 is F1387<bool>);
+ Expect.isTrue(confuse(f1387) is F1387<int>);
+ Expect.isFalse(confuse(f1387) is F1387<bool>);
+ Expect.equals(tIsDynamic, m1387 is F1387<bool>);
+ Expect.equals(tIsDynamic, confuse(m1387) is F1387<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1387 = (f1387 as dynamic); });
+ Expect.throws(() { x1387 = confuse(f1387); });
+ List<T> Function(List<Function> x) Function<B extends core.int>(int x) l1387;
+ Expect.throws(() { l1387 = (f1387 as dynamic); });
+ Expect.throws(() { l1387 = confuse(f1387); });
+ }
+ List<T> Function(List<Function> x) Function<B extends core.int>(int x) l1387 = m1387;
+ // In checked mode, verifies the type.
+ x1387 = m1387;
+ x1387 = confuse(m1387);
+ }
+ }
+
+ void testF1487() {
+ // List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1487 is F1487);
+ Expect.isTrue(confuse(f1487) is F1487);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1487;
+ // The static function f1487 sets `T` to `int`.
+ if (!tIsBool) {
+ x1487 = f1487 as dynamic;
+ l1487 = f1487 as dynamic;
+ x1487 = confuse(f1487);
+ l1487 = confuse(f1487);
+ }
+
+ Expect.isTrue(m1487 is F1487);
+ Expect.isTrue(m1487 is List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1487) is F1487);
+ // In checked mode, verifies the type.
+ x1487 = m1487;
+ l1487 = m1487;
+ x1487 = confuse(m1487);
+ l1487 = confuse(m1487);
+ if (!tIsBool) {
+ Expect.isTrue(f1487 is F1487<int>);
+ Expect.isFalse(f1487 is F1487<bool>);
+ Expect.isTrue(confuse(f1487) is F1487<int>);
+ Expect.isFalse(confuse(f1487) is F1487<bool>);
+ Expect.equals(tIsDynamic, m1487 is F1487<bool>);
+ Expect.equals(tIsDynamic, confuse(m1487) is F1487<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1487 = (f1487 as dynamic); });
+ Expect.throws(() { x1487 = confuse(f1487); });
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1487;
+ Expect.throws(() { l1487 = (f1487 as dynamic); });
+ Expect.throws(() { l1487 = confuse(f1487); });
+ }
+ List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l1487 = m1487;
+ // In checked mode, verifies the type.
+ x1487 = m1487;
+ x1487 = confuse(m1487);
+ }
+ }
+
+ void testF1587() {
+ // Function([Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1587 is F1587);
+ Expect.isTrue(confuse(f1587) is F1587);
+ // In checked mode, verifies the type.
+ Function([Function x1]) Function<B extends core.int>(int x) l1587;
+ // The static function f1587 sets `T` to `int`.
+ if (!tIsBool) {
+ x1587 = f1587 as dynamic;
+ l1587 = f1587 as dynamic;
+ x1587 = confuse(f1587);
+ l1587 = confuse(f1587);
+ }
+
+ Expect.isTrue(m1587 is F1587);
+ Expect.isTrue(m1587 is Function([Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1587) is F1587);
+ // In checked mode, verifies the type.
+ x1587 = m1587;
+ l1587 = m1587;
+ x1587 = confuse(m1587);
+ l1587 = confuse(m1587);
+
+ }
+
+ void testF1687() {
+ // Function({core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1687 is F1687);
+ Expect.isTrue(confuse(f1687) is F1687);
+ // In checked mode, verifies the type.
+ Function({core.List<core.int> x}) Function<B extends core.int>(int x) l1687;
+ // The static function f1687 sets `T` to `int`.
+ if (!tIsBool) {
+ x1687 = f1687 as dynamic;
+ l1687 = f1687 as dynamic;
+ x1687 = confuse(f1687);
+ l1687 = confuse(f1687);
+ }
+
+ Expect.isTrue(m1687 is F1687);
+ Expect.isTrue(m1687 is Function({core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1687) is F1687);
+ // In checked mode, verifies the type.
+ x1687 = m1687;
+ l1687 = m1687;
+ x1687 = confuse(m1687);
+ l1687 = confuse(m1687);
+
+ }
+
+ void testF1787() {
+ // Function Function<A>(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1787 is F1787);
+ Expect.isTrue(confuse(f1787) is F1787);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<Function> x) Function<B extends core.int>(int x) l1787;
+ // The static function f1787 sets `T` to `int`.
+ if (!tIsBool) {
+ x1787 = f1787 as dynamic;
+ l1787 = f1787 as dynamic;
+ x1787 = confuse(f1787);
+ l1787 = confuse(f1787);
+ }
+
+ Expect.isTrue(m1787 is F1787);
+ Expect.isTrue(m1787 is Function Function<A>(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1787) is F1787);
+ // In checked mode, verifies the type.
+ x1787 = m1787;
+ l1787 = m1787;
+ x1787 = confuse(m1787);
+ l1787 = confuse(m1787);
+
+ }
+
+ void testF1887() {
+ // List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1887 is F1887);
+ Expect.isTrue(confuse(f1887) is F1887);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1887;
+ // The static function f1887 sets `T` to `int`.
+ if (!tIsBool) {
+ x1887 = f1887 as dynamic;
+ l1887 = f1887 as dynamic;
+ x1887 = confuse(f1887);
+ l1887 = confuse(f1887);
+ }
+
+ Expect.isTrue(m1887 is F1887);
+ Expect.isTrue(m1887 is List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1887) is F1887);
+ // In checked mode, verifies the type.
+ x1887 = m1887;
+ l1887 = m1887;
+ x1887 = confuse(m1887);
+ l1887 = confuse(m1887);
+ if (!tIsBool) {
+ Expect.isTrue(f1887 is F1887<int>);
+ Expect.isFalse(f1887 is F1887<bool>);
+ Expect.isTrue(confuse(f1887) is F1887<int>);
+ Expect.isFalse(confuse(f1887) is F1887<bool>);
+ Expect.equals(tIsDynamic, m1887 is F1887<bool>);
+ Expect.equals(tIsDynamic, confuse(m1887) is F1887<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1887 = (f1887 as dynamic); });
+ Expect.throws(() { x1887 = confuse(f1887); });
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1887;
+ Expect.throws(() { l1887 = (f1887 as dynamic); });
+ Expect.throws(() { l1887 = confuse(f1887); });
+ }
+ List<T> Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1887 = m1887;
+ // In checked mode, verifies the type.
+ x1887 = m1887;
+ x1887 = confuse(m1887);
+ }
+ }
+
+ void testF1987() {
+ // List<A> Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1987 is F1987);
+ Expect.isTrue(confuse(f1987) is F1987);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<T> x) Function<B extends core.int>(int x) l1987;
+ // The static function f1987 sets `T` to `int`.
+ if (!tIsBool) {
+ x1987 = f1987 as dynamic;
+ l1987 = f1987 as dynamic;
+ x1987 = confuse(f1987);
+ l1987 = confuse(f1987);
+ }
+
+ Expect.isTrue(m1987 is F1987);
+ Expect.isTrue(m1987 is List<A> Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1987) is F1987);
+ // In checked mode, verifies the type.
+ x1987 = m1987;
+ l1987 = m1987;
+ x1987 = confuse(m1987);
+ l1987 = confuse(m1987);
+ if (!tIsBool) {
+ Expect.isTrue(f1987 is F1987<int>);
+ Expect.isFalse(f1987 is F1987<bool>);
+ Expect.isTrue(confuse(f1987) is F1987<int>);
+ Expect.isFalse(confuse(f1987) is F1987<bool>);
+ Expect.equals(tIsDynamic, m1987 is F1987<bool>);
+ Expect.equals(tIsDynamic, confuse(m1987) is F1987<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1987 = (f1987 as dynamic); });
+ Expect.throws(() { x1987 = confuse(f1987); });
+ List<A> Function<A>(List<T> x) Function<B extends core.int>(int x) l1987;
+ Expect.throws(() { l1987 = (f1987 as dynamic); });
+ Expect.throws(() { l1987 = confuse(f1987); });
+ }
+ List<A> Function<A>(List<T> x) Function<B extends core.int>(int x) l1987 = m1987;
+ // In checked mode, verifies the type.
+ x1987 = m1987;
+ x1987 = confuse(m1987);
+ }
+ }
+
+
+}
+
+class C88<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, {List<Function> x}) x88;
+ core.List<core.int> Function(int x0, {Function x}) x188;
+ Function({int x}) x288;
+ A Function<A>(List<T> x) x388;
+ int Function(List<Function> x) Function() x488;
+ int Function(int y, [List<T> x]) Function() x588;
+ Function Function([Function x1]) Function() x688;
+ Function Function({core.List<core.int> x}) Function() x788;
+ List<Function> Function(int y, {int x}) Function() x888;
+ List<Function> Function(int x0, [core.List<core.int> x]) Function() x988;
+ core.List<core.int> Function(int x0) Function() x1088;
+ core.List<core.int> Function(int x, [List<Function> x2]) Function() x1188;
+ core.List<core.int> Function(int y, {List<T> x}) Function() x1288;
+ List<T> Function([List<Function> x]) Function() x1388;
+ List<T> Function(List<T> x0) Function() x1488;
+ Function(int x1, [Function x2]) Function() x1588;
+ Function(int x0, {core.List<core.int> x}) Function() x1688;
+ Function Function<A>(core.List<core.int> x) Function() x1788;
+ List<T> Function<A>(List<T> x) Function() x1888;
+ List<A> Function<A>() Function() x1988;
+
+
+ C88({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m88(int y, {List<Function> x}) => null;
+ core.List<core.int> m188(int x0, {Function x}) => null;
+ m288({int x}) => null;
+ A m388<A>(List<T> x) => null;
+ int Function(List<Function> x) m488() => null;
+ int Function(int y, [List<T> x]) m588() => null;
+ Function Function([Function x0]) m688() => null;
+ Function Function({core.List<core.int> x}) m788() => null;
+ List<Function> Function(int y, {int x}) m888() => null;
+ List<Function> Function(int x0, [core.List<core.int> x]) m988() => null;
+ core.List<core.int> Function(int x0) m1088() => null;
+ core.List<core.int> Function(int x, [List<Function> x0]) m1188() => null;
+ core.List<core.int> Function(int y, {List<T> x}) m1288() => null;
+ List<T> Function([List<Function> x]) m1388() => null;
+ List<T> Function(List<T> x0) m1488() => null;
+ Function(int x0, [Function x1]) m1588() => null;
+ Function(int x0, {core.List<core.int> x}) m1688() => null;
+ Function Function<A>(core.List<core.int> x) m1788() => null;
+ List<T> Function<A>(List<T> x) m1888() => null;
+ List<A> Function<A>() m1988() => null;
+
+
+ runTests() {
+ testF88();
+ testF188();
+ testF288();
+ testF388();
+ testF488();
+ testF588();
+ testF688();
+ testF788();
+ testF888();
+ testF988();
+ testF1088();
+ testF1188();
+ testF1288();
+ testF1388();
+ testF1488();
+ testF1588();
+ testF1688();
+ testF1788();
+ testF1888();
+ testF1988();
+ }
+
+ void testF88() {
+ // Function Function(int y, {List<Function> x})
+ Expect.isTrue(f88 is F88);
+ Expect.isTrue(confuse(f88) is F88);
+ // In checked mode, verifies the type.
+ Function Function(int y, {List<Function> x}) l88;
+ // The static function f88 sets `T` to `int`.
+ if (!tIsBool) {
+ x88 = f88 as dynamic;
+ l88 = f88 as dynamic;
+ x88 = confuse(f88);
+ l88 = confuse(f88);
+ }
+
+ Expect.isTrue(m88 is F88);
+ Expect.isTrue(m88 is Function Function(int y, {List<Function> x}));
+ Expect.isTrue(confuse(m88) is F88);
+ // In checked mode, verifies the type.
+ x88 = m88;
+ l88 = m88;
+ x88 = confuse(m88);
+ l88 = confuse(m88);
+
+ }
+
+ void testF188() {
+ // core.List<core.int> Function(int x0, {Function x})
+ Expect.isTrue(f188 is F188);
+ Expect.isTrue(confuse(f188) is F188);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {Function x}) l188;
+ // The static function f188 sets `T` to `int`.
+ if (!tIsBool) {
+ x188 = f188 as dynamic;
+ l188 = f188 as dynamic;
+ x188 = confuse(f188);
+ l188 = confuse(f188);
+ }
+
+ Expect.isTrue(m188 is F188);
+ Expect.isTrue(m188 is core.List<core.int> Function(int x0, {Function x}));
+ Expect.isTrue(confuse(m188) is F188);
+ // In checked mode, verifies the type.
+ x188 = m188;
+ l188 = m188;
+ x188 = confuse(m188);
+ l188 = confuse(m188);
+
+ }
+
+ void testF288() {
+ // Function({int x})
+ Expect.isTrue(f288 is F288);
+ Expect.isTrue(confuse(f288) is F288);
+ // In checked mode, verifies the type.
+ Function({int x}) l288;
+ // The static function f288 sets `T` to `int`.
+ if (!tIsBool) {
+ x288 = f288 as dynamic;
+ l288 = f288 as dynamic;
+ x288 = confuse(f288);
+ l288 = confuse(f288);
+ }
+
+ Expect.isTrue(m288 is F288);
+ Expect.isTrue(m288 is Function({int x}));
+ Expect.isTrue(confuse(m288) is F288);
+ // In checked mode, verifies the type.
+ x288 = m288;
+ l288 = m288;
+ x288 = confuse(m288);
+ l288 = confuse(m288);
+
+ }
+
+ void testF388() {
+ // A Function<A>(List<T> x)
+ Expect.isTrue(f388 is F388);
+ Expect.isTrue(confuse(f388) is F388);
+ // In checked mode, verifies the type.
+ A Function<A>(List<T> x) l388;
+ // The static function f388 sets `T` to `int`.
+ if (!tIsBool) {
+ x388 = f388 as dynamic;
+ l388 = f388 as dynamic;
+ x388 = confuse(f388);
+ l388 = confuse(f388);
+ }
+
+ Expect.isTrue(m388 is F388);
+ Expect.isTrue(m388 is A Function<A>(List<T> x));
+ Expect.isTrue(confuse(m388) is F388);
+ // In checked mode, verifies the type.
+ x388 = m388;
+ l388 = m388;
+ x388 = confuse(m388);
+ l388 = confuse(m388);
+ if (!tIsBool) {
+ Expect.isTrue(f388 is F388<int>);
+ Expect.isFalse(f388 is F388<bool>);
+ Expect.isTrue(confuse(f388) is F388<int>);
+ Expect.isFalse(confuse(f388) is F388<bool>);
+ Expect.equals(tIsDynamic, m388 is F388<bool>);
+ Expect.equals(tIsDynamic, confuse(m388) is F388<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x388 = (f388 as dynamic); });
+ Expect.throws(() { x388 = confuse(f388); });
+ A Function<A>(List<T> x) l388;
+ Expect.throws(() { l388 = (f388 as dynamic); });
+ Expect.throws(() { l388 = confuse(f388); });
+ }
+ A Function<A>(List<T> x) l388 = m388;
+ // In checked mode, verifies the type.
+ x388 = m388;
+ x388 = confuse(m388);
+ }
+ }
+
+ void testF488() {
+ // int Function(List<Function> x) Function()
+ Expect.isTrue(f488 is F488);
+ Expect.isTrue(confuse(f488) is F488);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x) Function() l488;
+ // The static function f488 sets `T` to `int`.
+ if (!tIsBool) {
+ x488 = f488 as dynamic;
+ l488 = f488 as dynamic;
+ x488 = confuse(f488);
+ l488 = confuse(f488);
+ }
+
+ Expect.isTrue(m488 is F488);
+ Expect.isTrue(m488 is int Function(List<Function> x) Function());
+ Expect.isTrue(confuse(m488) is F488);
+ // In checked mode, verifies the type.
+ x488 = m488;
+ l488 = m488;
+ x488 = confuse(m488);
+ l488 = confuse(m488);
+
+ }
+
+ void testF588() {
+ // int Function(int y, [List<T> x]) Function()
+ Expect.isTrue(f588 is F588);
+ Expect.isTrue(confuse(f588) is F588);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<T> x]) Function() l588;
+ // The static function f588 sets `T` to `int`.
+ if (!tIsBool) {
+ x588 = f588 as dynamic;
+ l588 = f588 as dynamic;
+ x588 = confuse(f588);
+ l588 = confuse(f588);
+ }
+
+ Expect.isTrue(m588 is F588);
+ Expect.isTrue(m588 is int Function(int y, [List<T> x]) Function());
+ Expect.isTrue(confuse(m588) is F588);
+ // In checked mode, verifies the type.
+ x588 = m588;
+ l588 = m588;
+ x588 = confuse(m588);
+ l588 = confuse(m588);
+ if (!tIsBool) {
+ Expect.isTrue(f588 is F588<int>);
+ Expect.isFalse(f588 is F588<bool>);
+ Expect.isTrue(confuse(f588) is F588<int>);
+ Expect.isFalse(confuse(f588) is F588<bool>);
+ Expect.equals(tIsDynamic, m588 is F588<bool>);
+ Expect.equals(tIsDynamic, confuse(m588) is F588<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x588 = (f588 as dynamic); });
+ Expect.throws(() { x588 = confuse(f588); });
+ int Function(int y, [List<T> x]) Function() l588;
+ Expect.throws(() { l588 = (f588 as dynamic); });
+ Expect.throws(() { l588 = confuse(f588); });
+ }
+ int Function(int y, [List<T> x]) Function() l588 = m588;
+ // In checked mode, verifies the type.
+ x588 = m588;
+ x588 = confuse(m588);
+ }
+ }
+
+ void testF688() {
+ // Function Function([Function x1]) Function()
+ Expect.isTrue(f688 is F688);
+ Expect.isTrue(confuse(f688) is F688);
+ // In checked mode, verifies the type.
+ Function Function([Function x1]) Function() l688;
+ // The static function f688 sets `T` to `int`.
+ if (!tIsBool) {
+ x688 = f688 as dynamic;
+ l688 = f688 as dynamic;
+ x688 = confuse(f688);
+ l688 = confuse(f688);
+ }
+
+ Expect.isTrue(m688 is F688);
+ Expect.isTrue(m688 is Function Function([Function x1]) Function());
+ Expect.isTrue(confuse(m688) is F688);
+ // In checked mode, verifies the type.
+ x688 = m688;
+ l688 = m688;
+ x688 = confuse(m688);
+ l688 = confuse(m688);
+
+ }
+
+ void testF788() {
+ // Function Function({core.List<core.int> x}) Function()
+ Expect.isTrue(f788 is F788);
+ Expect.isTrue(confuse(f788) is F788);
+ // In checked mode, verifies the type.
+ Function Function({core.List<core.int> x}) Function() l788;
+ // The static function f788 sets `T` to `int`.
+ if (!tIsBool) {
+ x788 = f788 as dynamic;
+ l788 = f788 as dynamic;
+ x788 = confuse(f788);
+ l788 = confuse(f788);
+ }
+
+ Expect.isTrue(m788 is F788);
+ Expect.isTrue(m788 is Function Function({core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m788) is F788);
+ // In checked mode, verifies the type.
+ x788 = m788;
+ l788 = m788;
+ x788 = confuse(m788);
+ l788 = confuse(m788);
+
+ }
+
+ void testF888() {
+ // List<Function> Function(int y, {int x}) Function()
+ Expect.isTrue(f888 is F888);
+ Expect.isTrue(confuse(f888) is F888);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {int x}) Function() l888;
+ // The static function f888 sets `T` to `int`.
+ if (!tIsBool) {
+ x888 = f888 as dynamic;
+ l888 = f888 as dynamic;
+ x888 = confuse(f888);
+ l888 = confuse(f888);
+ }
+
+ Expect.isTrue(m888 is F888);
+ Expect.isTrue(m888 is List<Function> Function(int y, {int x}) Function());
+ Expect.isTrue(confuse(m888) is F888);
+ // In checked mode, verifies the type.
+ x888 = m888;
+ l888 = m888;
+ x888 = confuse(m888);
+ l888 = confuse(m888);
+
+ }
+
+ void testF988() {
+ // List<Function> Function(int x0, [core.List<core.int> x]) Function()
+ Expect.isTrue(f988 is F988);
+ Expect.isTrue(confuse(f988) is F988);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x0, [core.List<core.int> x]) Function() l988;
+ // The static function f988 sets `T` to `int`.
+ if (!tIsBool) {
+ x988 = f988 as dynamic;
+ l988 = f988 as dynamic;
+ x988 = confuse(f988);
+ l988 = confuse(f988);
+ }
+
+ Expect.isTrue(m988 is F988);
+ Expect.isTrue(m988 is List<Function> Function(int x0, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m988) is F988);
+ // In checked mode, verifies the type.
+ x988 = m988;
+ l988 = m988;
+ x988 = confuse(m988);
+ l988 = confuse(m988);
+
+ }
+
+ void testF1088() {
+ // core.List<core.int> Function(int x0) Function()
+ Expect.isTrue(f1088 is F1088);
+ Expect.isTrue(confuse(f1088) is F1088);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0) Function() l1088;
+ // The static function f1088 sets `T` to `int`.
+ if (!tIsBool) {
+ x1088 = f1088 as dynamic;
+ l1088 = f1088 as dynamic;
+ x1088 = confuse(f1088);
+ l1088 = confuse(f1088);
+ }
+
+ Expect.isTrue(m1088 is F1088);
+ Expect.isTrue(m1088 is core.List<core.int> Function(int x0) Function());
+ Expect.isTrue(confuse(m1088) is F1088);
+ // In checked mode, verifies the type.
+ x1088 = m1088;
+ l1088 = m1088;
+ x1088 = confuse(m1088);
+ l1088 = confuse(m1088);
+
+ }
+
+ void testF1188() {
+ // core.List<core.int> Function(int x, [List<Function> x2]) Function()
+ Expect.isTrue(f1188 is F1188);
+ Expect.isTrue(confuse(f1188) is F1188);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<Function> x2]) Function() l1188;
+ // The static function f1188 sets `T` to `int`.
+ if (!tIsBool) {
+ x1188 = f1188 as dynamic;
+ l1188 = f1188 as dynamic;
+ x1188 = confuse(f1188);
+ l1188 = confuse(f1188);
+ }
+
+ Expect.isTrue(m1188 is F1188);
+ Expect.isTrue(m1188 is core.List<core.int> Function(int x, [List<Function> x2]) Function());
+ Expect.isTrue(confuse(m1188) is F1188);
+ // In checked mode, verifies the type.
+ x1188 = m1188;
+ l1188 = m1188;
+ x1188 = confuse(m1188);
+ l1188 = confuse(m1188);
+
+ }
+
+ void testF1288() {
+ // core.List<core.int> Function(int y, {List<T> x}) Function()
+ Expect.isTrue(f1288 is F1288);
+ Expect.isTrue(confuse(f1288) is F1288);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<T> x}) Function() l1288;
+ // The static function f1288 sets `T` to `int`.
+ if (!tIsBool) {
+ x1288 = f1288 as dynamic;
+ l1288 = f1288 as dynamic;
+ x1288 = confuse(f1288);
+ l1288 = confuse(f1288);
+ }
+
+ Expect.isTrue(m1288 is F1288);
+ Expect.isTrue(m1288 is core.List<core.int> Function(int y, {List<T> x}) Function());
+ Expect.isTrue(confuse(m1288) is F1288);
+ // In checked mode, verifies the type.
+ x1288 = m1288;
+ l1288 = m1288;
+ x1288 = confuse(m1288);
+ l1288 = confuse(m1288);
+ if (!tIsBool) {
+ Expect.isTrue(f1288 is F1288<int>);
+ Expect.isFalse(f1288 is F1288<bool>);
+ Expect.isTrue(confuse(f1288) is F1288<int>);
+ Expect.isFalse(confuse(f1288) is F1288<bool>);
+ Expect.equals(tIsDynamic, m1288 is F1288<bool>);
+ Expect.equals(tIsDynamic, confuse(m1288) is F1288<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1288 = (f1288 as dynamic); });
+ Expect.throws(() { x1288 = confuse(f1288); });
+ core.List<core.int> Function(int y, {List<T> x}) Function() l1288;
+ Expect.throws(() { l1288 = (f1288 as dynamic); });
+ Expect.throws(() { l1288 = confuse(f1288); });
+ }
+ core.List<core.int> Function(int y, {List<T> x}) Function() l1288 = m1288;
+ // In checked mode, verifies the type.
+ x1288 = m1288;
+ x1288 = confuse(m1288);
+ }
+ }
+
+ void testF1388() {
+ // List<T> Function([List<Function> x]) Function()
+ Expect.isTrue(f1388 is F1388);
+ Expect.isTrue(confuse(f1388) is F1388);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x]) Function() l1388;
+ // The static function f1388 sets `T` to `int`.
+ if (!tIsBool) {
+ x1388 = f1388 as dynamic;
+ l1388 = f1388 as dynamic;
+ x1388 = confuse(f1388);
+ l1388 = confuse(f1388);
+ }
+
+ Expect.isTrue(m1388 is F1388);
+ Expect.isTrue(m1388 is List<T> Function([List<Function> x]) Function());
+ Expect.isTrue(confuse(m1388) is F1388);
+ // In checked mode, verifies the type.
+ x1388 = m1388;
+ l1388 = m1388;
+ x1388 = confuse(m1388);
+ l1388 = confuse(m1388);
+ if (!tIsBool) {
+ Expect.isTrue(f1388 is F1388<int>);
+ Expect.isFalse(f1388 is F1388<bool>);
+ Expect.isTrue(confuse(f1388) is F1388<int>);
+ Expect.isFalse(confuse(f1388) is F1388<bool>);
+ Expect.equals(tIsDynamic, m1388 is F1388<bool>);
+ Expect.equals(tIsDynamic, confuse(m1388) is F1388<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1388 = (f1388 as dynamic); });
+ Expect.throws(() { x1388 = confuse(f1388); });
+ List<T> Function([List<Function> x]) Function() l1388;
+ Expect.throws(() { l1388 = (f1388 as dynamic); });
+ Expect.throws(() { l1388 = confuse(f1388); });
+ }
+ List<T> Function([List<Function> x]) Function() l1388 = m1388;
+ // In checked mode, verifies the type.
+ x1388 = m1388;
+ x1388 = confuse(m1388);
+ }
+ }
+
+ void testF1488() {
+ // List<T> Function(List<T> x0) Function()
+ Expect.isTrue(f1488 is F1488);
+ Expect.isTrue(confuse(f1488) is F1488);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x0) Function() l1488;
+ // The static function f1488 sets `T` to `int`.
+ if (!tIsBool) {
+ x1488 = f1488 as dynamic;
+ l1488 = f1488 as dynamic;
+ x1488 = confuse(f1488);
+ l1488 = confuse(f1488);
+ }
+
+ Expect.isTrue(m1488 is F1488);
+ Expect.isTrue(m1488 is List<T> Function(List<T> x0) Function());
+ Expect.isTrue(confuse(m1488) is F1488);
+ // In checked mode, verifies the type.
+ x1488 = m1488;
+ l1488 = m1488;
+ x1488 = confuse(m1488);
+ l1488 = confuse(m1488);
+ if (!tIsBool) {
+ Expect.isTrue(f1488 is F1488<int>);
+ Expect.isFalse(f1488 is F1488<bool>);
+ Expect.isTrue(confuse(f1488) is F1488<int>);
+ Expect.isFalse(confuse(f1488) is F1488<bool>);
+ Expect.equals(tIsDynamic, m1488 is F1488<bool>);
+ Expect.equals(tIsDynamic, confuse(m1488) is F1488<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1488 = (f1488 as dynamic); });
+ Expect.throws(() { x1488 = confuse(f1488); });
+ List<T> Function(List<T> x0) Function() l1488;
+ Expect.throws(() { l1488 = (f1488 as dynamic); });
+ Expect.throws(() { l1488 = confuse(f1488); });
+ }
+ List<T> Function(List<T> x0) Function() l1488 = m1488;
+ // In checked mode, verifies the type.
+ x1488 = m1488;
+ x1488 = confuse(m1488);
+ }
+ }
+
+ void testF1588() {
+ // Function(int x1, [Function x2]) Function()
+ Expect.isTrue(f1588 is F1588);
+ Expect.isTrue(confuse(f1588) is F1588);
+ // In checked mode, verifies the type.
+ Function(int x1, [Function x2]) Function() l1588;
+ // The static function f1588 sets `T` to `int`.
+ if (!tIsBool) {
+ x1588 = f1588 as dynamic;
+ l1588 = f1588 as dynamic;
+ x1588 = confuse(f1588);
+ l1588 = confuse(f1588);
+ }
+
+ Expect.isTrue(m1588 is F1588);
+ Expect.isTrue(m1588 is Function(int x1, [Function x2]) Function());
+ Expect.isTrue(confuse(m1588) is F1588);
+ // In checked mode, verifies the type.
+ x1588 = m1588;
+ l1588 = m1588;
+ x1588 = confuse(m1588);
+ l1588 = confuse(m1588);
+
+ }
+
+ void testF1688() {
+ // Function(int x0, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1688 is F1688);
+ Expect.isTrue(confuse(f1688) is F1688);
+ // In checked mode, verifies the type.
+ Function(int x0, {core.List<core.int> x}) Function() l1688;
+ // The static function f1688 sets `T` to `int`.
+ if (!tIsBool) {
+ x1688 = f1688 as dynamic;
+ l1688 = f1688 as dynamic;
+ x1688 = confuse(f1688);
+ l1688 = confuse(f1688);
+ }
+
+ Expect.isTrue(m1688 is F1688);
+ Expect.isTrue(m1688 is Function(int x0, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1688) is F1688);
+ // In checked mode, verifies the type.
+ x1688 = m1688;
+ l1688 = m1688;
+ x1688 = confuse(m1688);
+ l1688 = confuse(m1688);
+
+ }
+
+ void testF1788() {
+ // Function Function<A>(core.List<core.int> x) Function()
+ Expect.isTrue(f1788 is F1788);
+ Expect.isTrue(confuse(f1788) is F1788);
+ // In checked mode, verifies the type.
+ Function Function<A>(core.List<core.int> x) Function() l1788;
+ // The static function f1788 sets `T` to `int`.
+ if (!tIsBool) {
+ x1788 = f1788 as dynamic;
+ l1788 = f1788 as dynamic;
+ x1788 = confuse(f1788);
+ l1788 = confuse(f1788);
+ }
+
+ Expect.isTrue(m1788 is F1788);
+ Expect.isTrue(m1788 is Function Function<A>(core.List<core.int> x) Function());
+ Expect.isTrue(confuse(m1788) is F1788);
+ // In checked mode, verifies the type.
+ x1788 = m1788;
+ l1788 = m1788;
+ x1788 = confuse(m1788);
+ l1788 = confuse(m1788);
+
+ }
+
+ void testF1888() {
+ // List<T> Function<A>(List<T> x) Function()
+ Expect.isTrue(f1888 is F1888);
+ Expect.isTrue(confuse(f1888) is F1888);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<T> x) Function() l1888;
+ // The static function f1888 sets `T` to `int`.
+ if (!tIsBool) {
+ x1888 = f1888 as dynamic;
+ l1888 = f1888 as dynamic;
+ x1888 = confuse(f1888);
+ l1888 = confuse(f1888);
+ }
+
+ Expect.isTrue(m1888 is F1888);
+ Expect.isTrue(m1888 is List<T> Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1888) is F1888);
+ // In checked mode, verifies the type.
+ x1888 = m1888;
+ l1888 = m1888;
+ x1888 = confuse(m1888);
+ l1888 = confuse(m1888);
+ if (!tIsBool) {
+ Expect.isTrue(f1888 is F1888<int>);
+ Expect.isFalse(f1888 is F1888<bool>);
+ Expect.isTrue(confuse(f1888) is F1888<int>);
+ Expect.isFalse(confuse(f1888) is F1888<bool>);
+ Expect.equals(tIsDynamic, m1888 is F1888<bool>);
+ Expect.equals(tIsDynamic, confuse(m1888) is F1888<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1888 = (f1888 as dynamic); });
+ Expect.throws(() { x1888 = confuse(f1888); });
+ List<T> Function<A>(List<T> x) Function() l1888;
+ Expect.throws(() { l1888 = (f1888 as dynamic); });
+ Expect.throws(() { l1888 = confuse(f1888); });
+ }
+ List<T> Function<A>(List<T> x) Function() l1888 = m1888;
+ // In checked mode, verifies the type.
+ x1888 = m1888;
+ x1888 = confuse(m1888);
+ }
+ }
+
+ void testF1988() {
+ // List<A> Function<A>() Function()
+ Expect.isTrue(f1988 is F1988);
+ Expect.isTrue(confuse(f1988) is F1988);
+ // In checked mode, verifies the type.
+ List<A> Function<A>() Function() l1988;
+ // The static function f1988 sets `T` to `int`.
+ if (!tIsBool) {
+ x1988 = f1988 as dynamic;
+ l1988 = f1988 as dynamic;
+ x1988 = confuse(f1988);
+ l1988 = confuse(f1988);
+ }
+
+ Expect.isTrue(m1988 is F1988);
+ Expect.isTrue(m1988 is List<A> Function<A>() Function());
+ Expect.isTrue(confuse(m1988) is F1988);
+ // In checked mode, verifies the type.
+ x1988 = m1988;
+ l1988 = m1988;
+ x1988 = confuse(m1988);
+ l1988 = confuse(m1988);
+
+ }
+
+
+}
+
+class C89<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(core.List<core.int> x) x89;
+ core.List<core.int> Function(int y, {Function x}) x189;
+ Function(int x0, {int x}) x289;
+ A Function<A>() x389;
+ int Function(List<Function> x) Function(int x) x489;
+ int Function(int y, [List<T> x]) Function(int x) x589;
+ Function Function([Function x1]) Function(int x) x689;
+ Function Function({core.List<core.int> x}) Function(int x) x789;
+ List<Function> Function(int y, {int x}) Function(int x) x889;
+ List<Function> Function(int x1, [core.List<core.int> x]) Function(int x) x989;
+ core.List<core.int> Function(int x1) Function(int x) x1089;
+ core.List<core.int> Function(int x, [List<Function> x1]) Function(int x) x1189;
+ core.List<core.int> Function(int y, {List<T> x}) Function(int x) x1289;
+ List<T> Function([List<Function> x]) Function(int x) x1389;
+ List<T> Function(List<T> x1) Function(int x) x1489;
+ Function(int x2, [Function x3]) Function(int x) x1589;
+ Function(int x1, {core.List<core.int> x}) Function(int x) x1689;
+ Function Function<A>(core.List<core.int> x) Function(int x) x1789;
+ List<T> Function<A>(List<T> x) Function(int x) x1889;
+ List<A> Function<A>() Function(int x) x1989;
+
+
+ C89({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m89(core.List<core.int> x) => null;
+ core.List<core.int> m189(int y, {Function x}) => null;
+ m289(int x0, {int x}) => null;
+ A m389<A>() => null;
+ int Function(List<Function> x) m489(int x) => null;
+ int Function(int y, [List<T> x]) m589(int x) => null;
+ Function Function([Function x0]) m689(int x) => null;
+ Function Function({core.List<core.int> x}) m789(int x) => null;
+ List<Function> Function(int y, {int x}) m889(int x) => null;
+ List<Function> Function(int x0, [core.List<core.int> x]) m989(int x) => null;
+ core.List<core.int> Function(int x0) m1089(int x) => null;
+ core.List<core.int> Function(int x, [List<Function> x0]) m1189(int x) => null;
+ core.List<core.int> Function(int y, {List<T> x}) m1289(int x) => null;
+ List<T> Function([List<Function> x]) m1389(int x) => null;
+ List<T> Function(List<T> x0) m1489(int x) => null;
+ Function(int x0, [Function x1]) m1589(int x) => null;
+ Function(int x0, {core.List<core.int> x}) m1689(int x) => null;
+ Function Function<A>(core.List<core.int> x) m1789(int x) => null;
+ List<T> Function<A>(List<T> x) m1889(int x) => null;
+ List<A> Function<A>() m1989(int x) => null;
+
+
+ runTests() {
+ testF89();
+ testF189();
+ testF289();
+ testF389();
+ testF489();
+ testF589();
+ testF689();
+ testF789();
+ testF889();
+ testF989();
+ testF1089();
+ testF1189();
+ testF1289();
+ testF1389();
+ testF1489();
+ testF1589();
+ testF1689();
+ testF1789();
+ testF1889();
+ testF1989();
+ }
+
+ void testF89() {
+ // Function Function(core.List<core.int> x)
+ Expect.isTrue(f89 is F89);
+ Expect.isTrue(confuse(f89) is F89);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x) l89;
+ // The static function f89 sets `T` to `int`.
+ if (!tIsBool) {
+ x89 = f89 as dynamic;
+ l89 = f89 as dynamic;
+ x89 = confuse(f89);
+ l89 = confuse(f89);
+ }
+
+ Expect.isTrue(m89 is F89);
+ Expect.isTrue(m89 is Function Function(core.List<core.int> x));
+ Expect.isTrue(confuse(m89) is F89);
+ // In checked mode, verifies the type.
+ x89 = m89;
+ l89 = m89;
+ x89 = confuse(m89);
+ l89 = confuse(m89);
+
+ }
+
+ void testF189() {
+ // core.List<core.int> Function(int y, {Function x})
+ Expect.isTrue(f189 is F189);
+ Expect.isTrue(confuse(f189) is F189);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {Function x}) l189;
+ // The static function f189 sets `T` to `int`.
+ if (!tIsBool) {
+ x189 = f189 as dynamic;
+ l189 = f189 as dynamic;
+ x189 = confuse(f189);
+ l189 = confuse(f189);
+ }
+
+ Expect.isTrue(m189 is F189);
+ Expect.isTrue(m189 is core.List<core.int> Function(int y, {Function x}));
+ Expect.isTrue(confuse(m189) is F189);
+ // In checked mode, verifies the type.
+ x189 = m189;
+ l189 = m189;
+ x189 = confuse(m189);
+ l189 = confuse(m189);
+
+ }
+
+ void testF289() {
+ // Function(int x0, {int x})
+ Expect.isTrue(f289 is F289);
+ Expect.isTrue(confuse(f289) is F289);
+ // In checked mode, verifies the type.
+ Function(int x0, {int x}) l289;
+ // The static function f289 sets `T` to `int`.
+ if (!tIsBool) {
+ x289 = f289 as dynamic;
+ l289 = f289 as dynamic;
+ x289 = confuse(f289);
+ l289 = confuse(f289);
+ }
+
+ Expect.isTrue(m289 is F289);
+ Expect.isTrue(m289 is Function(int x0, {int x}));
+ Expect.isTrue(confuse(m289) is F289);
+ // In checked mode, verifies the type.
+ x289 = m289;
+ l289 = m289;
+ x289 = confuse(m289);
+ l289 = confuse(m289);
+
+ }
+
+ void testF389() {
+ // A Function<A>()
+ Expect.isTrue(f389 is F389);
+ Expect.isTrue(confuse(f389) is F389);
+ // In checked mode, verifies the type.
+ A Function<A>() l389;
+ // The static function f389 sets `T` to `int`.
+ if (!tIsBool) {
+ x389 = f389 as dynamic;
+ l389 = f389 as dynamic;
+ x389 = confuse(f389);
+ l389 = confuse(f389);
+ }
+
+ Expect.isTrue(m389 is F389);
+ Expect.isTrue(m389 is A Function<A>());
+ Expect.isTrue(confuse(m389) is F389);
+ // In checked mode, verifies the type.
+ x389 = m389;
+ l389 = m389;
+ x389 = confuse(m389);
+ l389 = confuse(m389);
+
+ }
+
+ void testF489() {
+ // int Function(List<Function> x) Function(int x)
+ Expect.isTrue(f489 is F489);
+ Expect.isTrue(confuse(f489) is F489);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x) Function(int x) l489;
+ // The static function f489 sets `T` to `int`.
+ if (!tIsBool) {
+ x489 = f489 as dynamic;
+ l489 = f489 as dynamic;
+ x489 = confuse(f489);
+ l489 = confuse(f489);
+ }
+
+ Expect.isTrue(m489 is F489);
+ Expect.isTrue(m489 is int Function(List<Function> x) Function(int x));
+ Expect.isTrue(confuse(m489) is F489);
+ // In checked mode, verifies the type.
+ x489 = m489;
+ l489 = m489;
+ x489 = confuse(m489);
+ l489 = confuse(m489);
+
+ }
+
+ void testF589() {
+ // int Function(int y, [List<T> x]) Function(int x)
+ Expect.isTrue(f589 is F589);
+ Expect.isTrue(confuse(f589) is F589);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<T> x]) Function(int x) l589;
+ // The static function f589 sets `T` to `int`.
+ if (!tIsBool) {
+ x589 = f589 as dynamic;
+ l589 = f589 as dynamic;
+ x589 = confuse(f589);
+ l589 = confuse(f589);
+ }
+
+ Expect.isTrue(m589 is F589);
+ Expect.isTrue(m589 is int Function(int y, [List<T> x]) Function(int x));
+ Expect.isTrue(confuse(m589) is F589);
+ // In checked mode, verifies the type.
+ x589 = m589;
+ l589 = m589;
+ x589 = confuse(m589);
+ l589 = confuse(m589);
+ if (!tIsBool) {
+ Expect.isTrue(f589 is F589<int>);
+ Expect.isFalse(f589 is F589<bool>);
+ Expect.isTrue(confuse(f589) is F589<int>);
+ Expect.isFalse(confuse(f589) is F589<bool>);
+ Expect.equals(tIsDynamic, m589 is F589<bool>);
+ Expect.equals(tIsDynamic, confuse(m589) is F589<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x589 = (f589 as dynamic); });
+ Expect.throws(() { x589 = confuse(f589); });
+ int Function(int y, [List<T> x]) Function(int x) l589;
+ Expect.throws(() { l589 = (f589 as dynamic); });
+ Expect.throws(() { l589 = confuse(f589); });
+ }
+ int Function(int y, [List<T> x]) Function(int x) l589 = m589;
+ // In checked mode, verifies the type.
+ x589 = m589;
+ x589 = confuse(m589);
+ }
+ }
+
+ void testF689() {
+ // Function Function([Function x1]) Function(int x)
+ Expect.isTrue(f689 is F689);
+ Expect.isTrue(confuse(f689) is F689);
+ // In checked mode, verifies the type.
+ Function Function([Function x1]) Function(int x) l689;
+ // The static function f689 sets `T` to `int`.
+ if (!tIsBool) {
+ x689 = f689 as dynamic;
+ l689 = f689 as dynamic;
+ x689 = confuse(f689);
+ l689 = confuse(f689);
+ }
+
+ Expect.isTrue(m689 is F689);
+ Expect.isTrue(m689 is Function Function([Function x1]) Function(int x));
+ Expect.isTrue(confuse(m689) is F689);
+ // In checked mode, verifies the type.
+ x689 = m689;
+ l689 = m689;
+ x689 = confuse(m689);
+ l689 = confuse(m689);
+
+ }
+
+ void testF789() {
+ // Function Function({core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f789 is F789);
+ Expect.isTrue(confuse(f789) is F789);
+ // In checked mode, verifies the type.
+ Function Function({core.List<core.int> x}) Function(int x) l789;
+ // The static function f789 sets `T` to `int`.
+ if (!tIsBool) {
+ x789 = f789 as dynamic;
+ l789 = f789 as dynamic;
+ x789 = confuse(f789);
+ l789 = confuse(f789);
+ }
+
+ Expect.isTrue(m789 is F789);
+ Expect.isTrue(m789 is Function Function({core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m789) is F789);
+ // In checked mode, verifies the type.
+ x789 = m789;
+ l789 = m789;
+ x789 = confuse(m789);
+ l789 = confuse(m789);
+
+ }
+
+ void testF889() {
+ // List<Function> Function(int y, {int x}) Function(int x)
+ Expect.isTrue(f889 is F889);
+ Expect.isTrue(confuse(f889) is F889);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {int x}) Function(int x) l889;
+ // The static function f889 sets `T` to `int`.
+ if (!tIsBool) {
+ x889 = f889 as dynamic;
+ l889 = f889 as dynamic;
+ x889 = confuse(f889);
+ l889 = confuse(f889);
+ }
+
+ Expect.isTrue(m889 is F889);
+ Expect.isTrue(m889 is List<Function> Function(int y, {int x}) Function(int x));
+ Expect.isTrue(confuse(m889) is F889);
+ // In checked mode, verifies the type.
+ x889 = m889;
+ l889 = m889;
+ x889 = confuse(m889);
+ l889 = confuse(m889);
+
+ }
+
+ void testF989() {
+ // List<Function> Function(int x1, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f989 is F989);
+ Expect.isTrue(confuse(f989) is F989);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [core.List<core.int> x]) Function(int x) l989;
+ // The static function f989 sets `T` to `int`.
+ if (!tIsBool) {
+ x989 = f989 as dynamic;
+ l989 = f989 as dynamic;
+ x989 = confuse(f989);
+ l989 = confuse(f989);
+ }
+
+ Expect.isTrue(m989 is F989);
+ Expect.isTrue(m989 is List<Function> Function(int x1, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m989) is F989);
+ // In checked mode, verifies the type.
+ x989 = m989;
+ l989 = m989;
+ x989 = confuse(m989);
+ l989 = confuse(m989);
+
+ }
+
+ void testF1089() {
+ // core.List<core.int> Function(int x1) Function(int x)
+ Expect.isTrue(f1089 is F1089);
+ Expect.isTrue(confuse(f1089) is F1089);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1) Function(int x) l1089;
+ // The static function f1089 sets `T` to `int`.
+ if (!tIsBool) {
+ x1089 = f1089 as dynamic;
+ l1089 = f1089 as dynamic;
+ x1089 = confuse(f1089);
+ l1089 = confuse(f1089);
+ }
+
+ Expect.isTrue(m1089 is F1089);
+ Expect.isTrue(m1089 is core.List<core.int> Function(int x1) Function(int x));
+ Expect.isTrue(confuse(m1089) is F1089);
+ // In checked mode, verifies the type.
+ x1089 = m1089;
+ l1089 = m1089;
+ x1089 = confuse(m1089);
+ l1089 = confuse(m1089);
+
+ }
+
+ void testF1189() {
+ // core.List<core.int> Function(int x, [List<Function> x1]) Function(int x)
+ Expect.isTrue(f1189 is F1189);
+ Expect.isTrue(confuse(f1189) is F1189);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<Function> x1]) Function(int x) l1189;
+ // The static function f1189 sets `T` to `int`.
+ if (!tIsBool) {
+ x1189 = f1189 as dynamic;
+ l1189 = f1189 as dynamic;
+ x1189 = confuse(f1189);
+ l1189 = confuse(f1189);
+ }
+
+ Expect.isTrue(m1189 is F1189);
+ Expect.isTrue(m1189 is core.List<core.int> Function(int x, [List<Function> x1]) Function(int x));
+ Expect.isTrue(confuse(m1189) is F1189);
+ // In checked mode, verifies the type.
+ x1189 = m1189;
+ l1189 = m1189;
+ x1189 = confuse(m1189);
+ l1189 = confuse(m1189);
+
+ }
+
+ void testF1289() {
+ // core.List<core.int> Function(int y, {List<T> x}) Function(int x)
+ Expect.isTrue(f1289 is F1289);
+ Expect.isTrue(confuse(f1289) is F1289);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<T> x}) Function(int x) l1289;
+ // The static function f1289 sets `T` to `int`.
+ if (!tIsBool) {
+ x1289 = f1289 as dynamic;
+ l1289 = f1289 as dynamic;
+ x1289 = confuse(f1289);
+ l1289 = confuse(f1289);
+ }
+
+ Expect.isTrue(m1289 is F1289);
+ Expect.isTrue(m1289 is core.List<core.int> Function(int y, {List<T> x}) Function(int x));
+ Expect.isTrue(confuse(m1289) is F1289);
+ // In checked mode, verifies the type.
+ x1289 = m1289;
+ l1289 = m1289;
+ x1289 = confuse(m1289);
+ l1289 = confuse(m1289);
+ if (!tIsBool) {
+ Expect.isTrue(f1289 is F1289<int>);
+ Expect.isFalse(f1289 is F1289<bool>);
+ Expect.isTrue(confuse(f1289) is F1289<int>);
+ Expect.isFalse(confuse(f1289) is F1289<bool>);
+ Expect.equals(tIsDynamic, m1289 is F1289<bool>);
+ Expect.equals(tIsDynamic, confuse(m1289) is F1289<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1289 = (f1289 as dynamic); });
+ Expect.throws(() { x1289 = confuse(f1289); });
+ core.List<core.int> Function(int y, {List<T> x}) Function(int x) l1289;
+ Expect.throws(() { l1289 = (f1289 as dynamic); });
+ Expect.throws(() { l1289 = confuse(f1289); });
+ }
+ core.List<core.int> Function(int y, {List<T> x}) Function(int x) l1289 = m1289;
+ // In checked mode, verifies the type.
+ x1289 = m1289;
+ x1289 = confuse(m1289);
+ }
+ }
+
+ void testF1389() {
+ // List<T> Function([List<Function> x]) Function(int x)
+ Expect.isTrue(f1389 is F1389);
+ Expect.isTrue(confuse(f1389) is F1389);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x]) Function(int x) l1389;
+ // The static function f1389 sets `T` to `int`.
+ if (!tIsBool) {
+ x1389 = f1389 as dynamic;
+ l1389 = f1389 as dynamic;
+ x1389 = confuse(f1389);
+ l1389 = confuse(f1389);
+ }
+
+ Expect.isTrue(m1389 is F1389);
+ Expect.isTrue(m1389 is List<T> Function([List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1389) is F1389);
+ // In checked mode, verifies the type.
+ x1389 = m1389;
+ l1389 = m1389;
+ x1389 = confuse(m1389);
+ l1389 = confuse(m1389);
+ if (!tIsBool) {
+ Expect.isTrue(f1389 is F1389<int>);
+ Expect.isFalse(f1389 is F1389<bool>);
+ Expect.isTrue(confuse(f1389) is F1389<int>);
+ Expect.isFalse(confuse(f1389) is F1389<bool>);
+ Expect.equals(tIsDynamic, m1389 is F1389<bool>);
+ Expect.equals(tIsDynamic, confuse(m1389) is F1389<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1389 = (f1389 as dynamic); });
+ Expect.throws(() { x1389 = confuse(f1389); });
+ List<T> Function([List<Function> x]) Function(int x) l1389;
+ Expect.throws(() { l1389 = (f1389 as dynamic); });
+ Expect.throws(() { l1389 = confuse(f1389); });
+ }
+ List<T> Function([List<Function> x]) Function(int x) l1389 = m1389;
+ // In checked mode, verifies the type.
+ x1389 = m1389;
+ x1389 = confuse(m1389);
+ }
+ }
+
+ void testF1489() {
+ // List<T> Function(List<T> x1) Function(int x)
+ Expect.isTrue(f1489 is F1489);
+ Expect.isTrue(confuse(f1489) is F1489);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x1) Function(int x) l1489;
+ // The static function f1489 sets `T` to `int`.
+ if (!tIsBool) {
+ x1489 = f1489 as dynamic;
+ l1489 = f1489 as dynamic;
+ x1489 = confuse(f1489);
+ l1489 = confuse(f1489);
+ }
+
+ Expect.isTrue(m1489 is F1489);
+ Expect.isTrue(m1489 is List<T> Function(List<T> x1) Function(int x));
+ Expect.isTrue(confuse(m1489) is F1489);
+ // In checked mode, verifies the type.
+ x1489 = m1489;
+ l1489 = m1489;
+ x1489 = confuse(m1489);
+ l1489 = confuse(m1489);
+ if (!tIsBool) {
+ Expect.isTrue(f1489 is F1489<int>);
+ Expect.isFalse(f1489 is F1489<bool>);
+ Expect.isTrue(confuse(f1489) is F1489<int>);
+ Expect.isFalse(confuse(f1489) is F1489<bool>);
+ Expect.equals(tIsDynamic, m1489 is F1489<bool>);
+ Expect.equals(tIsDynamic, confuse(m1489) is F1489<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1489 = (f1489 as dynamic); });
+ Expect.throws(() { x1489 = confuse(f1489); });
+ List<T> Function(List<T> x1) Function(int x) l1489;
+ Expect.throws(() { l1489 = (f1489 as dynamic); });
+ Expect.throws(() { l1489 = confuse(f1489); });
+ }
+ List<T> Function(List<T> x1) Function(int x) l1489 = m1489;
+ // In checked mode, verifies the type.
+ x1489 = m1489;
+ x1489 = confuse(m1489);
+ }
+ }
+
+ void testF1589() {
+ // Function(int x2, [Function x3]) Function(int x)
+ Expect.isTrue(f1589 is F1589);
+ Expect.isTrue(confuse(f1589) is F1589);
+ // In checked mode, verifies the type.
+ Function(int x2, [Function x3]) Function(int x) l1589;
+ // The static function f1589 sets `T` to `int`.
+ if (!tIsBool) {
+ x1589 = f1589 as dynamic;
+ l1589 = f1589 as dynamic;
+ x1589 = confuse(f1589);
+ l1589 = confuse(f1589);
+ }
+
+ Expect.isTrue(m1589 is F1589);
+ Expect.isTrue(m1589 is Function(int x2, [Function x3]) Function(int x));
+ Expect.isTrue(confuse(m1589) is F1589);
+ // In checked mode, verifies the type.
+ x1589 = m1589;
+ l1589 = m1589;
+ x1589 = confuse(m1589);
+ l1589 = confuse(m1589);
+
+ }
+
+ void testF1689() {
+ // Function(int x1, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1689 is F1689);
+ Expect.isTrue(confuse(f1689) is F1689);
+ // In checked mode, verifies the type.
+ Function(int x1, {core.List<core.int> x}) Function(int x) l1689;
+ // The static function f1689 sets `T` to `int`.
+ if (!tIsBool) {
+ x1689 = f1689 as dynamic;
+ l1689 = f1689 as dynamic;
+ x1689 = confuse(f1689);
+ l1689 = confuse(f1689);
+ }
+
+ Expect.isTrue(m1689 is F1689);
+ Expect.isTrue(m1689 is Function(int x1, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1689) is F1689);
+ // In checked mode, verifies the type.
+ x1689 = m1689;
+ l1689 = m1689;
+ x1689 = confuse(m1689);
+ l1689 = confuse(m1689);
+
+ }
+
+ void testF1789() {
+ // Function Function<A>(core.List<core.int> x) Function(int x)
+ Expect.isTrue(f1789 is F1789);
+ Expect.isTrue(confuse(f1789) is F1789);
+ // In checked mode, verifies the type.
+ Function Function<A>(core.List<core.int> x) Function(int x) l1789;
+ // The static function f1789 sets `T` to `int`.
+ if (!tIsBool) {
+ x1789 = f1789 as dynamic;
+ l1789 = f1789 as dynamic;
+ x1789 = confuse(f1789);
+ l1789 = confuse(f1789);
+ }
+
+ Expect.isTrue(m1789 is F1789);
+ Expect.isTrue(m1789 is Function Function<A>(core.List<core.int> x) Function(int x));
+ Expect.isTrue(confuse(m1789) is F1789);
+ // In checked mode, verifies the type.
+ x1789 = m1789;
+ l1789 = m1789;
+ x1789 = confuse(m1789);
+ l1789 = confuse(m1789);
+
+ }
+
+ void testF1889() {
+ // List<T> Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1889 is F1889);
+ Expect.isTrue(confuse(f1889) is F1889);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<T> x) Function(int x) l1889;
+ // The static function f1889 sets `T` to `int`.
+ if (!tIsBool) {
+ x1889 = f1889 as dynamic;
+ l1889 = f1889 as dynamic;
+ x1889 = confuse(f1889);
+ l1889 = confuse(f1889);
+ }
+
+ Expect.isTrue(m1889 is F1889);
+ Expect.isTrue(m1889 is List<T> Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1889) is F1889);
+ // In checked mode, verifies the type.
+ x1889 = m1889;
+ l1889 = m1889;
+ x1889 = confuse(m1889);
+ l1889 = confuse(m1889);
+ if (!tIsBool) {
+ Expect.isTrue(f1889 is F1889<int>);
+ Expect.isFalse(f1889 is F1889<bool>);
+ Expect.isTrue(confuse(f1889) is F1889<int>);
+ Expect.isFalse(confuse(f1889) is F1889<bool>);
+ Expect.equals(tIsDynamic, m1889 is F1889<bool>);
+ Expect.equals(tIsDynamic, confuse(m1889) is F1889<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1889 = (f1889 as dynamic); });
+ Expect.throws(() { x1889 = confuse(f1889); });
+ List<T> Function<A>(List<T> x) Function(int x) l1889;
+ Expect.throws(() { l1889 = (f1889 as dynamic); });
+ Expect.throws(() { l1889 = confuse(f1889); });
+ }
+ List<T> Function<A>(List<T> x) Function(int x) l1889 = m1889;
+ // In checked mode, verifies the type.
+ x1889 = m1889;
+ x1889 = confuse(m1889);
+ }
+ }
+
+ void testF1989() {
+ // List<A> Function<A>() Function(int x)
+ Expect.isTrue(f1989 is F1989);
+ Expect.isTrue(confuse(f1989) is F1989);
+ // In checked mode, verifies the type.
+ List<A> Function<A>() Function(int x) l1989;
+ // The static function f1989 sets `T` to `int`.
+ if (!tIsBool) {
+ x1989 = f1989 as dynamic;
+ l1989 = f1989 as dynamic;
+ x1989 = confuse(f1989);
+ l1989 = confuse(f1989);
+ }
+
+ Expect.isTrue(m1989 is F1989);
+ Expect.isTrue(m1989 is List<A> Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1989) is F1989);
+ // In checked mode, verifies the type.
+ x1989 = m1989;
+ l1989 = m1989;
+ x1989 = confuse(m1989);
+ l1989 = confuse(m1989);
+
+ }
+
+
+}
+
+class C90<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([core.List<core.int> x]) x90;
+ core.List<core.int> Function(List<Function> x) x190;
+ Function(int y, {int x}) x290;
+ A Function<A>(A x) x390;
+ int Function(List<Function> x) Function<B extends core.int>() x490;
+ int Function(int y, [List<T> x]) Function<B extends core.int>() x590;
+ Function Function([Function x1]) Function<B extends core.int>() x690;
+ Function Function({core.List<core.int> x}) Function<B extends core.int>() x790;
+ List<Function> Function(int y, {int x}) Function<B extends core.int>() x890;
+ List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() x990;
+ core.List<core.int> Function(int x1) Function<B extends core.int>() x1090;
+ core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>() x1190;
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>() x1290;
+ List<T> Function([List<Function> x]) Function<B extends core.int>() x1390;
+ List<T> Function(List<T> x1) Function<B extends core.int>() x1490;
+ Function(int x2, [Function x3]) Function<B extends core.int>() x1590;
+ Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() x1690;
+ Function Function<A>(core.List<core.int> x) Function<B extends core.int>() x1790;
+ List<T> Function<A>(List<T> x) Function<B extends core.int>() x1890;
+ List<A> Function<A>() Function<B extends core.int>() x1990;
+
+
+ C90({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m90([core.List<core.int> x]) => null;
+ core.List<core.int> m190(List<Function> x) => null;
+ m290(int y, {int x}) => null;
+ A m390<A>(A x) => null;
+ int Function(List<Function> x) m490<B extends core.int>() => null;
+ int Function(int y, [List<T> x]) m590<B extends core.int>() => null;
+ Function Function([Function x0]) m690<B extends core.int>() => null;
+ Function Function({core.List<core.int> x}) m790<B extends core.int>() => null;
+ List<Function> Function(int y, {int x}) m890<B extends core.int>() => null;
+ List<Function> Function(int x0, [core.List<core.int> x]) m990<B extends core.int>() => null;
+ core.List<core.int> Function(int x0) m1090<B extends core.int>() => null;
+ core.List<core.int> Function(int x, [List<Function> x0]) m1190<B extends core.int>() => null;
+ core.List<core.int> Function(int y, {List<T> x}) m1290<B extends core.int>() => null;
+ List<T> Function([List<Function> x]) m1390<B extends core.int>() => null;
+ List<T> Function(List<T> x0) m1490<B extends core.int>() => null;
+ Function(int x0, [Function x1]) m1590<B extends core.int>() => null;
+ Function(int x0, {core.List<core.int> x}) m1690<B extends core.int>() => null;
+ Function Function<A>(core.List<core.int> x) m1790<B extends core.int>() => null;
+ List<T> Function<A>(List<T> x) m1890<B extends core.int>() => null;
+ List<A> Function<A>() m1990<B extends core.int>() => null;
+
+
+ runTests() {
+ testF90();
+ testF190();
+ testF290();
+ testF390();
+ testF490();
+ testF590();
+ testF690();
+ testF790();
+ testF890();
+ testF990();
+ testF1090();
+ testF1190();
+ testF1290();
+ testF1390();
+ testF1490();
+ testF1590();
+ testF1690();
+ testF1790();
+ testF1890();
+ testF1990();
+ }
+
+ void testF90() {
+ // Function Function([core.List<core.int> x])
+ Expect.isTrue(f90 is F90);
+ Expect.isTrue(confuse(f90) is F90);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x]) l90;
+ // The static function f90 sets `T` to `int`.
+ if (!tIsBool) {
+ x90 = f90 as dynamic;
+ l90 = f90 as dynamic;
+ x90 = confuse(f90);
+ l90 = confuse(f90);
+ }
+
+ Expect.isTrue(m90 is F90);
+ Expect.isTrue(m90 is Function Function([core.List<core.int> x]));
+ Expect.isTrue(confuse(m90) is F90);
+ // In checked mode, verifies the type.
+ x90 = m90;
+ l90 = m90;
+ x90 = confuse(m90);
+ l90 = confuse(m90);
+
+ }
+
+ void testF190() {
+ // core.List<core.int> Function(List<Function> x)
+ Expect.isTrue(f190 is F190);
+ Expect.isTrue(confuse(f190) is F190);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x) l190;
+ // The static function f190 sets `T` to `int`.
+ if (!tIsBool) {
+ x190 = f190 as dynamic;
+ l190 = f190 as dynamic;
+ x190 = confuse(f190);
+ l190 = confuse(f190);
+ }
+
+ Expect.isTrue(m190 is F190);
+ Expect.isTrue(m190 is core.List<core.int> Function(List<Function> x));
+ Expect.isTrue(confuse(m190) is F190);
+ // In checked mode, verifies the type.
+ x190 = m190;
+ l190 = m190;
+ x190 = confuse(m190);
+ l190 = confuse(m190);
+
+ }
+
+ void testF290() {
+ // Function(int y, {int x})
+ Expect.isTrue(f290 is F290);
+ Expect.isTrue(confuse(f290) is F290);
+ // In checked mode, verifies the type.
+ Function(int y, {int x}) l290;
+ // The static function f290 sets `T` to `int`.
+ if (!tIsBool) {
+ x290 = f290 as dynamic;
+ l290 = f290 as dynamic;
+ x290 = confuse(f290);
+ l290 = confuse(f290);
+ }
+
+ Expect.isTrue(m290 is F290);
+ Expect.isTrue(m290 is Function(int y, {int x}));
+ Expect.isTrue(confuse(m290) is F290);
+ // In checked mode, verifies the type.
+ x290 = m290;
+ l290 = m290;
+ x290 = confuse(m290);
+ l290 = confuse(m290);
+
+ }
+
+ void testF390() {
+ // A Function<A>(A x)
+ Expect.isTrue(f390 is F390);
+ Expect.isTrue(confuse(f390) is F390);
+ // In checked mode, verifies the type.
+ A Function<A>(A x) l390;
+ // The static function f390 sets `T` to `int`.
+ if (!tIsBool) {
+ x390 = f390 as dynamic;
+ l390 = f390 as dynamic;
+ x390 = confuse(f390);
+ l390 = confuse(f390);
+ }
+
+ Expect.isTrue(m390 is F390);
+ Expect.isTrue(m390 is A Function<A>(A x));
+ Expect.isTrue(confuse(m390) is F390);
+ // In checked mode, verifies the type.
+ x390 = m390;
+ l390 = m390;
+ x390 = confuse(m390);
+ l390 = confuse(m390);
+
+ }
+
+ void testF490() {
+ // int Function(List<Function> x) Function<B extends core.int>()
+ Expect.isTrue(f490 is F490);
+ Expect.isTrue(confuse(f490) is F490);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x) Function<B extends core.int>() l490;
+ // The static function f490 sets `T` to `int`.
+ if (!tIsBool) {
+ x490 = f490 as dynamic;
+ l490 = f490 as dynamic;
+ x490 = confuse(f490);
+ l490 = confuse(f490);
+ }
+
+ Expect.isTrue(m490 is F490);
+ Expect.isTrue(m490 is int Function(List<Function> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m490) is F490);
+ // In checked mode, verifies the type.
+ x490 = m490;
+ l490 = m490;
+ x490 = confuse(m490);
+ l490 = confuse(m490);
+
+ }
+
+ void testF590() {
+ // int Function(int y, [List<T> x]) Function<B extends core.int>()
+ Expect.isTrue(f590 is F590);
+ Expect.isTrue(confuse(f590) is F590);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<T> x]) Function<B extends core.int>() l590;
+ // The static function f590 sets `T` to `int`.
+ if (!tIsBool) {
+ x590 = f590 as dynamic;
+ l590 = f590 as dynamic;
+ x590 = confuse(f590);
+ l590 = confuse(f590);
+ }
+
+ Expect.isTrue(m590 is F590);
+ Expect.isTrue(m590 is int Function(int y, [List<T> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m590) is F590);
+ // In checked mode, verifies the type.
+ x590 = m590;
+ l590 = m590;
+ x590 = confuse(m590);
+ l590 = confuse(m590);
+ if (!tIsBool) {
+ Expect.isTrue(f590 is F590<int>);
+ Expect.isFalse(f590 is F590<bool>);
+ Expect.isTrue(confuse(f590) is F590<int>);
+ Expect.isFalse(confuse(f590) is F590<bool>);
+ Expect.equals(tIsDynamic, m590 is F590<bool>);
+ Expect.equals(tIsDynamic, confuse(m590) is F590<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x590 = (f590 as dynamic); });
+ Expect.throws(() { x590 = confuse(f590); });
+ int Function(int y, [List<T> x]) Function<B extends core.int>() l590;
+ Expect.throws(() { l590 = (f590 as dynamic); });
+ Expect.throws(() { l590 = confuse(f590); });
+ }
+ int Function(int y, [List<T> x]) Function<B extends core.int>() l590 = m590;
+ // In checked mode, verifies the type.
+ x590 = m590;
+ x590 = confuse(m590);
+ }
+ }
+
+ void testF690() {
+ // Function Function([Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f690 is F690);
+ Expect.isTrue(confuse(f690) is F690);
+ // In checked mode, verifies the type.
+ Function Function([Function x1]) Function<B extends core.int>() l690;
+ // The static function f690 sets `T` to `int`.
+ if (!tIsBool) {
+ x690 = f690 as dynamic;
+ l690 = f690 as dynamic;
+ x690 = confuse(f690);
+ l690 = confuse(f690);
+ }
+
+ Expect.isTrue(m690 is F690);
+ Expect.isTrue(m690 is Function Function([Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m690) is F690);
+ // In checked mode, verifies the type.
+ x690 = m690;
+ l690 = m690;
+ x690 = confuse(m690);
+ l690 = confuse(m690);
+
+ }
+
+ void testF790() {
+ // Function Function({core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f790 is F790);
+ Expect.isTrue(confuse(f790) is F790);
+ // In checked mode, verifies the type.
+ Function Function({core.List<core.int> x}) Function<B extends core.int>() l790;
+ // The static function f790 sets `T` to `int`.
+ if (!tIsBool) {
+ x790 = f790 as dynamic;
+ l790 = f790 as dynamic;
+ x790 = confuse(f790);
+ l790 = confuse(f790);
+ }
+
+ Expect.isTrue(m790 is F790);
+ Expect.isTrue(m790 is Function Function({core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m790) is F790);
+ // In checked mode, verifies the type.
+ x790 = m790;
+ l790 = m790;
+ x790 = confuse(m790);
+ l790 = confuse(m790);
+
+ }
+
+ void testF890() {
+ // List<Function> Function(int y, {int x}) Function<B extends core.int>()
+ Expect.isTrue(f890 is F890);
+ Expect.isTrue(confuse(f890) is F890);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {int x}) Function<B extends core.int>() l890;
+ // The static function f890 sets `T` to `int`.
+ if (!tIsBool) {
+ x890 = f890 as dynamic;
+ l890 = f890 as dynamic;
+ x890 = confuse(f890);
+ l890 = confuse(f890);
+ }
+
+ Expect.isTrue(m890 is F890);
+ Expect.isTrue(m890 is List<Function> Function(int y, {int x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m890) is F890);
+ // In checked mode, verifies the type.
+ x890 = m890;
+ l890 = m890;
+ x890 = confuse(m890);
+ l890 = confuse(m890);
+
+ }
+
+ void testF990() {
+ // List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f990 is F990);
+ Expect.isTrue(confuse(f990) is F990);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>() l990;
+ // The static function f990 sets `T` to `int`.
+ if (!tIsBool) {
+ x990 = f990 as dynamic;
+ l990 = f990 as dynamic;
+ x990 = confuse(f990);
+ l990 = confuse(f990);
+ }
+
+ Expect.isTrue(m990 is F990);
+ Expect.isTrue(m990 is List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m990) is F990);
+ // In checked mode, verifies the type.
+ x990 = m990;
+ l990 = m990;
+ x990 = confuse(m990);
+ l990 = confuse(m990);
+
+ }
+
+ void testF1090() {
+ // core.List<core.int> Function(int x1) Function<B extends core.int>()
+ Expect.isTrue(f1090 is F1090);
+ Expect.isTrue(confuse(f1090) is F1090);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1) Function<B extends core.int>() l1090;
+ // The static function f1090 sets `T` to `int`.
+ if (!tIsBool) {
+ x1090 = f1090 as dynamic;
+ l1090 = f1090 as dynamic;
+ x1090 = confuse(f1090);
+ l1090 = confuse(f1090);
+ }
+
+ Expect.isTrue(m1090 is F1090);
+ Expect.isTrue(m1090 is core.List<core.int> Function(int x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1090) is F1090);
+ // In checked mode, verifies the type.
+ x1090 = m1090;
+ l1090 = m1090;
+ x1090 = confuse(m1090);
+ l1090 = confuse(m1090);
+
+ }
+
+ void testF1190() {
+ // core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1190 is F1190);
+ Expect.isTrue(confuse(f1190) is F1190);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>() l1190;
+ // The static function f1190 sets `T` to `int`.
+ if (!tIsBool) {
+ x1190 = f1190 as dynamic;
+ l1190 = f1190 as dynamic;
+ x1190 = confuse(f1190);
+ l1190 = confuse(f1190);
+ }
+
+ Expect.isTrue(m1190 is F1190);
+ Expect.isTrue(m1190 is core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1190) is F1190);
+ // In checked mode, verifies the type.
+ x1190 = m1190;
+ l1190 = m1190;
+ x1190 = confuse(m1190);
+ l1190 = confuse(m1190);
+
+ }
+
+ void testF1290() {
+ // core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>()
+ Expect.isTrue(f1290 is F1290);
+ Expect.isTrue(confuse(f1290) is F1290);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>() l1290;
+ // The static function f1290 sets `T` to `int`.
+ if (!tIsBool) {
+ x1290 = f1290 as dynamic;
+ l1290 = f1290 as dynamic;
+ x1290 = confuse(f1290);
+ l1290 = confuse(f1290);
+ }
+
+ Expect.isTrue(m1290 is F1290);
+ Expect.isTrue(m1290 is core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1290) is F1290);
+ // In checked mode, verifies the type.
+ x1290 = m1290;
+ l1290 = m1290;
+ x1290 = confuse(m1290);
+ l1290 = confuse(m1290);
+ if (!tIsBool) {
+ Expect.isTrue(f1290 is F1290<int>);
+ Expect.isFalse(f1290 is F1290<bool>);
+ Expect.isTrue(confuse(f1290) is F1290<int>);
+ Expect.isFalse(confuse(f1290) is F1290<bool>);
+ Expect.equals(tIsDynamic, m1290 is F1290<bool>);
+ Expect.equals(tIsDynamic, confuse(m1290) is F1290<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1290 = (f1290 as dynamic); });
+ Expect.throws(() { x1290 = confuse(f1290); });
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>() l1290;
+ Expect.throws(() { l1290 = (f1290 as dynamic); });
+ Expect.throws(() { l1290 = confuse(f1290); });
+ }
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>() l1290 = m1290;
+ // In checked mode, verifies the type.
+ x1290 = m1290;
+ x1290 = confuse(m1290);
+ }
+ }
+
+ void testF1390() {
+ // List<T> Function([List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1390 is F1390);
+ Expect.isTrue(confuse(f1390) is F1390);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x]) Function<B extends core.int>() l1390;
+ // The static function f1390 sets `T` to `int`.
+ if (!tIsBool) {
+ x1390 = f1390 as dynamic;
+ l1390 = f1390 as dynamic;
+ x1390 = confuse(f1390);
+ l1390 = confuse(f1390);
+ }
+
+ Expect.isTrue(m1390 is F1390);
+ Expect.isTrue(m1390 is List<T> Function([List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1390) is F1390);
+ // In checked mode, verifies the type.
+ x1390 = m1390;
+ l1390 = m1390;
+ x1390 = confuse(m1390);
+ l1390 = confuse(m1390);
+ if (!tIsBool) {
+ Expect.isTrue(f1390 is F1390<int>);
+ Expect.isFalse(f1390 is F1390<bool>);
+ Expect.isTrue(confuse(f1390) is F1390<int>);
+ Expect.isFalse(confuse(f1390) is F1390<bool>);
+ Expect.equals(tIsDynamic, m1390 is F1390<bool>);
+ Expect.equals(tIsDynamic, confuse(m1390) is F1390<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1390 = (f1390 as dynamic); });
+ Expect.throws(() { x1390 = confuse(f1390); });
+ List<T> Function([List<Function> x]) Function<B extends core.int>() l1390;
+ Expect.throws(() { l1390 = (f1390 as dynamic); });
+ Expect.throws(() { l1390 = confuse(f1390); });
+ }
+ List<T> Function([List<Function> x]) Function<B extends core.int>() l1390 = m1390;
+ // In checked mode, verifies the type.
+ x1390 = m1390;
+ x1390 = confuse(m1390);
+ }
+ }
+
+ void testF1490() {
+ // List<T> Function(List<T> x1) Function<B extends core.int>()
+ Expect.isTrue(f1490 is F1490);
+ Expect.isTrue(confuse(f1490) is F1490);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x1) Function<B extends core.int>() l1490;
+ // The static function f1490 sets `T` to `int`.
+ if (!tIsBool) {
+ x1490 = f1490 as dynamic;
+ l1490 = f1490 as dynamic;
+ x1490 = confuse(f1490);
+ l1490 = confuse(f1490);
+ }
+
+ Expect.isTrue(m1490 is F1490);
+ Expect.isTrue(m1490 is List<T> Function(List<T> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1490) is F1490);
+ // In checked mode, verifies the type.
+ x1490 = m1490;
+ l1490 = m1490;
+ x1490 = confuse(m1490);
+ l1490 = confuse(m1490);
+ if (!tIsBool) {
+ Expect.isTrue(f1490 is F1490<int>);
+ Expect.isFalse(f1490 is F1490<bool>);
+ Expect.isTrue(confuse(f1490) is F1490<int>);
+ Expect.isFalse(confuse(f1490) is F1490<bool>);
+ Expect.equals(tIsDynamic, m1490 is F1490<bool>);
+ Expect.equals(tIsDynamic, confuse(m1490) is F1490<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1490 = (f1490 as dynamic); });
+ Expect.throws(() { x1490 = confuse(f1490); });
+ List<T> Function(List<T> x1) Function<B extends core.int>() l1490;
+ Expect.throws(() { l1490 = (f1490 as dynamic); });
+ Expect.throws(() { l1490 = confuse(f1490); });
+ }
+ List<T> Function(List<T> x1) Function<B extends core.int>() l1490 = m1490;
+ // In checked mode, verifies the type.
+ x1490 = m1490;
+ x1490 = confuse(m1490);
+ }
+ }
+
+ void testF1590() {
+ // Function(int x2, [Function x3]) Function<B extends core.int>()
+ Expect.isTrue(f1590 is F1590);
+ Expect.isTrue(confuse(f1590) is F1590);
+ // In checked mode, verifies the type.
+ Function(int x2, [Function x3]) Function<B extends core.int>() l1590;
+ // The static function f1590 sets `T` to `int`.
+ if (!tIsBool) {
+ x1590 = f1590 as dynamic;
+ l1590 = f1590 as dynamic;
+ x1590 = confuse(f1590);
+ l1590 = confuse(f1590);
+ }
+
+ Expect.isTrue(m1590 is F1590);
+ Expect.isTrue(m1590 is Function(int x2, [Function x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1590) is F1590);
+ // In checked mode, verifies the type.
+ x1590 = m1590;
+ l1590 = m1590;
+ x1590 = confuse(m1590);
+ l1590 = confuse(m1590);
+
+ }
+
+ void testF1690() {
+ // Function(int x1, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1690 is F1690);
+ Expect.isTrue(confuse(f1690) is F1690);
+ // In checked mode, verifies the type.
+ Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l1690;
+ // The static function f1690 sets `T` to `int`.
+ if (!tIsBool) {
+ x1690 = f1690 as dynamic;
+ l1690 = f1690 as dynamic;
+ x1690 = confuse(f1690);
+ l1690 = confuse(f1690);
+ }
+
+ Expect.isTrue(m1690 is F1690);
+ Expect.isTrue(m1690 is Function(int x1, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1690) is F1690);
+ // In checked mode, verifies the type.
+ x1690 = m1690;
+ l1690 = m1690;
+ x1690 = confuse(m1690);
+ l1690 = confuse(m1690);
+
+ }
+
+ void testF1790() {
+ // Function Function<A>(core.List<core.int> x) Function<B extends core.int>()
+ Expect.isTrue(f1790 is F1790);
+ Expect.isTrue(confuse(f1790) is F1790);
+ // In checked mode, verifies the type.
+ Function Function<A>(core.List<core.int> x) Function<B extends core.int>() l1790;
+ // The static function f1790 sets `T` to `int`.
+ if (!tIsBool) {
+ x1790 = f1790 as dynamic;
+ l1790 = f1790 as dynamic;
+ x1790 = confuse(f1790);
+ l1790 = confuse(f1790);
+ }
+
+ Expect.isTrue(m1790 is F1790);
+ Expect.isTrue(m1790 is Function Function<A>(core.List<core.int> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1790) is F1790);
+ // In checked mode, verifies the type.
+ x1790 = m1790;
+ l1790 = m1790;
+ x1790 = confuse(m1790);
+ l1790 = confuse(m1790);
+
+ }
+
+ void testF1890() {
+ // List<T> Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1890 is F1890);
+ Expect.isTrue(confuse(f1890) is F1890);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<T> x) Function<B extends core.int>() l1890;
+ // The static function f1890 sets `T` to `int`.
+ if (!tIsBool) {
+ x1890 = f1890 as dynamic;
+ l1890 = f1890 as dynamic;
+ x1890 = confuse(f1890);
+ l1890 = confuse(f1890);
+ }
+
+ Expect.isTrue(m1890 is F1890);
+ Expect.isTrue(m1890 is List<T> Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1890) is F1890);
+ // In checked mode, verifies the type.
+ x1890 = m1890;
+ l1890 = m1890;
+ x1890 = confuse(m1890);
+ l1890 = confuse(m1890);
+ if (!tIsBool) {
+ Expect.isTrue(f1890 is F1890<int>);
+ Expect.isFalse(f1890 is F1890<bool>);
+ Expect.isTrue(confuse(f1890) is F1890<int>);
+ Expect.isFalse(confuse(f1890) is F1890<bool>);
+ Expect.equals(tIsDynamic, m1890 is F1890<bool>);
+ Expect.equals(tIsDynamic, confuse(m1890) is F1890<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1890 = (f1890 as dynamic); });
+ Expect.throws(() { x1890 = confuse(f1890); });
+ List<T> Function<A>(List<T> x) Function<B extends core.int>() l1890;
+ Expect.throws(() { l1890 = (f1890 as dynamic); });
+ Expect.throws(() { l1890 = confuse(f1890); });
+ }
+ List<T> Function<A>(List<T> x) Function<B extends core.int>() l1890 = m1890;
+ // In checked mode, verifies the type.
+ x1890 = m1890;
+ x1890 = confuse(m1890);
+ }
+ }
+
+ void testF1990() {
+ // List<A> Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1990 is F1990);
+ Expect.isTrue(confuse(f1990) is F1990);
+ // In checked mode, verifies the type.
+ List<A> Function<A>() Function<B extends core.int>() l1990;
+ // The static function f1990 sets `T` to `int`.
+ if (!tIsBool) {
+ x1990 = f1990 as dynamic;
+ l1990 = f1990 as dynamic;
+ x1990 = confuse(f1990);
+ l1990 = confuse(f1990);
+ }
+
+ Expect.isTrue(m1990 is F1990);
+ Expect.isTrue(m1990 is List<A> Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1990) is F1990);
+ // In checked mode, verifies the type.
+ x1990 = m1990;
+ l1990 = m1990;
+ x1990 = confuse(m1990);
+ l1990 = confuse(m1990);
+
+ }
+
+
+}
+
+class C91<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, [core.List<core.int> x]) x91;
+ core.List<core.int> Function([List<Function> x]) x191;
+ Function(Function x) x291;
+ A Function<A>(List<A> x) x391;
+ int Function(List<Function> x) Function<B extends core.int>(int x) x491;
+ int Function(int y, [List<T> x]) Function<B extends core.int>(int x) x591;
+ Function Function([Function x1]) Function<B extends core.int>(int x) x691;
+ Function Function({core.List<core.int> x}) Function<B extends core.int>(int x) x791;
+ List<Function> Function(int y, {int x}) Function<B extends core.int>(int x) x891;
+ List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) x991;
+ core.List<core.int> Function(int x1) Function<B extends core.int>(int x) x1091;
+ core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) x1191;
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x) x1291;
+ List<T> Function([List<Function> x]) Function<B extends core.int>(int x) x1391;
+ List<T> Function(List<T> x1) Function<B extends core.int>(int x) x1491;
+ Function(int x2, [Function x3]) Function<B extends core.int>(int x) x1591;
+ Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) x1691;
+ Function Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) x1791;
+ List<T> Function<A>(List<T> x) Function<B extends core.int>(int x) x1891;
+ List<A> Function<A>() Function<B extends core.int>(int x) x1991;
+
+
+ C91({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m91(int x0, [core.List<core.int> x]) => null;
+ core.List<core.int> m191([List<Function> x]) => null;
+ m291(Function x) => null;
+ A m391<A>(List<A> x) => null;
+ int Function(List<Function> x) m491<B extends core.int>(int x) => null;
+ int Function(int y, [List<T> x]) m591<B extends core.int>(int x) => null;
+ Function Function([Function x0]) m691<B extends core.int>(int x) => null;
+ Function Function({core.List<core.int> x}) m791<B extends core.int>(int x) => null;
+ List<Function> Function(int y, {int x}) m891<B extends core.int>(int x) => null;
+ List<Function> Function(int x0, [core.List<core.int> x]) m991<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0) m1091<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x, [List<Function> x0]) m1191<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int y, {List<T> x}) m1291<B extends core.int>(int x) => null;
+ List<T> Function([List<Function> x]) m1391<B extends core.int>(int x) => null;
+ List<T> Function(List<T> x0) m1491<B extends core.int>(int x) => null;
+ Function(int x0, [Function x1]) m1591<B extends core.int>(int x) => null;
+ Function(int x0, {core.List<core.int> x}) m1691<B extends core.int>(int x) => null;
+ Function Function<A>(core.List<core.int> x) m1791<B extends core.int>(int x) => null;
+ List<T> Function<A>(List<T> x) m1891<B extends core.int>(int x) => null;
+ List<A> Function<A>() m1991<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF91();
+ testF191();
+ testF291();
+ testF391();
+ testF491();
+ testF591();
+ testF691();
+ testF791();
+ testF891();
+ testF991();
+ testF1091();
+ testF1191();
+ testF1291();
+ testF1391();
+ testF1491();
+ testF1591();
+ testF1691();
+ testF1791();
+ testF1891();
+ testF1991();
+ }
+
+ void testF91() {
+ // Function Function(int x0, [core.List<core.int> x])
+ Expect.isTrue(f91 is F91);
+ Expect.isTrue(confuse(f91) is F91);
+ // In checked mode, verifies the type.
+ Function Function(int x0, [core.List<core.int> x]) l91;
+ // The static function f91 sets `T` to `int`.
+ if (!tIsBool) {
+ x91 = f91 as dynamic;
+ l91 = f91 as dynamic;
+ x91 = confuse(f91);
+ l91 = confuse(f91);
+ }
+
+ Expect.isTrue(m91 is F91);
+ Expect.isTrue(m91 is Function Function(int x0, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m91) is F91);
+ // In checked mode, verifies the type.
+ x91 = m91;
+ l91 = m91;
+ x91 = confuse(m91);
+ l91 = confuse(m91);
+
+ }
+
+ void testF191() {
+ // core.List<core.int> Function([List<Function> x])
+ Expect.isTrue(f191 is F191);
+ Expect.isTrue(confuse(f191) is F191);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x]) l191;
+ // The static function f191 sets `T` to `int`.
+ if (!tIsBool) {
+ x191 = f191 as dynamic;
+ l191 = f191 as dynamic;
+ x191 = confuse(f191);
+ l191 = confuse(f191);
+ }
+
+ Expect.isTrue(m191 is F191);
+ Expect.isTrue(m191 is core.List<core.int> Function([List<Function> x]));
+ Expect.isTrue(confuse(m191) is F191);
+ // In checked mode, verifies the type.
+ x191 = m191;
+ l191 = m191;
+ x191 = confuse(m191);
+ l191 = confuse(m191);
+
+ }
+
+ void testF291() {
+ // Function(Function x)
+ Expect.isTrue(f291 is F291);
+ Expect.isTrue(confuse(f291) is F291);
+ // In checked mode, verifies the type.
+ Function(Function x) l291;
+ // The static function f291 sets `T` to `int`.
+ if (!tIsBool) {
+ x291 = f291 as dynamic;
+ l291 = f291 as dynamic;
+ x291 = confuse(f291);
+ l291 = confuse(f291);
+ }
+
+ Expect.isTrue(m291 is F291);
+ Expect.isTrue(m291 is Function(Function x));
+ Expect.isTrue(confuse(m291) is F291);
+ // In checked mode, verifies the type.
+ x291 = m291;
+ l291 = m291;
+ x291 = confuse(m291);
+ l291 = confuse(m291);
+
+ }
+
+ void testF391() {
+ // A Function<A>(List<A> x)
+ Expect.isTrue(f391 is F391);
+ Expect.isTrue(confuse(f391) is F391);
+ // In checked mode, verifies the type.
+ A Function<A>(List<A> x) l391;
+ // The static function f391 sets `T` to `int`.
+ if (!tIsBool) {
+ x391 = f391 as dynamic;
+ l391 = f391 as dynamic;
+ x391 = confuse(f391);
+ l391 = confuse(f391);
+ }
+
+ Expect.isTrue(m391 is F391);
+ Expect.isTrue(m391 is A Function<A>(List<A> x));
+ Expect.isTrue(confuse(m391) is F391);
+ // In checked mode, verifies the type.
+ x391 = m391;
+ l391 = m391;
+ x391 = confuse(m391);
+ l391 = confuse(m391);
+
+ }
+
+ void testF491() {
+ // int Function(List<Function> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f491 is F491);
+ Expect.isTrue(confuse(f491) is F491);
+ // In checked mode, verifies the type.
+ int Function(List<Function> x) Function<B extends core.int>(int x) l491;
+ // The static function f491 sets `T` to `int`.
+ if (!tIsBool) {
+ x491 = f491 as dynamic;
+ l491 = f491 as dynamic;
+ x491 = confuse(f491);
+ l491 = confuse(f491);
+ }
+
+ Expect.isTrue(m491 is F491);
+ Expect.isTrue(m491 is int Function(List<Function> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m491) is F491);
+ // In checked mode, verifies the type.
+ x491 = m491;
+ l491 = m491;
+ x491 = confuse(m491);
+ l491 = confuse(m491);
+
+ }
+
+ void testF591() {
+ // int Function(int y, [List<T> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f591 is F591);
+ Expect.isTrue(confuse(f591) is F591);
+ // In checked mode, verifies the type.
+ int Function(int y, [List<T> x]) Function<B extends core.int>(int x) l591;
+ // The static function f591 sets `T` to `int`.
+ if (!tIsBool) {
+ x591 = f591 as dynamic;
+ l591 = f591 as dynamic;
+ x591 = confuse(f591);
+ l591 = confuse(f591);
+ }
+
+ Expect.isTrue(m591 is F591);
+ Expect.isTrue(m591 is int Function(int y, [List<T> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m591) is F591);
+ // In checked mode, verifies the type.
+ x591 = m591;
+ l591 = m591;
+ x591 = confuse(m591);
+ l591 = confuse(m591);
+ if (!tIsBool) {
+ Expect.isTrue(f591 is F591<int>);
+ Expect.isFalse(f591 is F591<bool>);
+ Expect.isTrue(confuse(f591) is F591<int>);
+ Expect.isFalse(confuse(f591) is F591<bool>);
+ Expect.equals(tIsDynamic, m591 is F591<bool>);
+ Expect.equals(tIsDynamic, confuse(m591) is F591<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x591 = (f591 as dynamic); });
+ Expect.throws(() { x591 = confuse(f591); });
+ int Function(int y, [List<T> x]) Function<B extends core.int>(int x) l591;
+ Expect.throws(() { l591 = (f591 as dynamic); });
+ Expect.throws(() { l591 = confuse(f591); });
+ }
+ int Function(int y, [List<T> x]) Function<B extends core.int>(int x) l591 = m591;
+ // In checked mode, verifies the type.
+ x591 = m591;
+ x591 = confuse(m591);
+ }
+ }
+
+ void testF691() {
+ // Function Function([Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f691 is F691);
+ Expect.isTrue(confuse(f691) is F691);
+ // In checked mode, verifies the type.
+ Function Function([Function x1]) Function<B extends core.int>(int x) l691;
+ // The static function f691 sets `T` to `int`.
+ if (!tIsBool) {
+ x691 = f691 as dynamic;
+ l691 = f691 as dynamic;
+ x691 = confuse(f691);
+ l691 = confuse(f691);
+ }
+
+ Expect.isTrue(m691 is F691);
+ Expect.isTrue(m691 is Function Function([Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m691) is F691);
+ // In checked mode, verifies the type.
+ x691 = m691;
+ l691 = m691;
+ x691 = confuse(m691);
+ l691 = confuse(m691);
+
+ }
+
+ void testF791() {
+ // Function Function({core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f791 is F791);
+ Expect.isTrue(confuse(f791) is F791);
+ // In checked mode, verifies the type.
+ Function Function({core.List<core.int> x}) Function<B extends core.int>(int x) l791;
+ // The static function f791 sets `T` to `int`.
+ if (!tIsBool) {
+ x791 = f791 as dynamic;
+ l791 = f791 as dynamic;
+ x791 = confuse(f791);
+ l791 = confuse(f791);
+ }
+
+ Expect.isTrue(m791 is F791);
+ Expect.isTrue(m791 is Function Function({core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m791) is F791);
+ // In checked mode, verifies the type.
+ x791 = m791;
+ l791 = m791;
+ x791 = confuse(m791);
+ l791 = confuse(m791);
+
+ }
+
+ void testF891() {
+ // List<Function> Function(int y, {int x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f891 is F891);
+ Expect.isTrue(confuse(f891) is F891);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, {int x}) Function<B extends core.int>(int x) l891;
+ // The static function f891 sets `T` to `int`.
+ if (!tIsBool) {
+ x891 = f891 as dynamic;
+ l891 = f891 as dynamic;
+ x891 = confuse(f891);
+ l891 = confuse(f891);
+ }
+
+ Expect.isTrue(m891 is F891);
+ Expect.isTrue(m891 is List<Function> Function(int y, {int x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m891) is F891);
+ // In checked mode, verifies the type.
+ x891 = m891;
+ l891 = m891;
+ x891 = confuse(m891);
+ l891 = confuse(m891);
+
+ }
+
+ void testF991() {
+ // List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f991 is F991);
+ Expect.isTrue(confuse(f991) is F991);
+ // In checked mode, verifies the type.
+ List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x) l991;
+ // The static function f991 sets `T` to `int`.
+ if (!tIsBool) {
+ x991 = f991 as dynamic;
+ l991 = f991 as dynamic;
+ x991 = confuse(f991);
+ l991 = confuse(f991);
+ }
+
+ Expect.isTrue(m991 is F991);
+ Expect.isTrue(m991 is List<Function> Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m991) is F991);
+ // In checked mode, verifies the type.
+ x991 = m991;
+ l991 = m991;
+ x991 = confuse(m991);
+ l991 = confuse(m991);
+
+ }
+
+ void testF1091() {
+ // core.List<core.int> Function(int x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1091 is F1091);
+ Expect.isTrue(confuse(f1091) is F1091);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1) Function<B extends core.int>(int x) l1091;
+ // The static function f1091 sets `T` to `int`.
+ if (!tIsBool) {
+ x1091 = f1091 as dynamic;
+ l1091 = f1091 as dynamic;
+ x1091 = confuse(f1091);
+ l1091 = confuse(f1091);
+ }
+
+ Expect.isTrue(m1091 is F1091);
+ Expect.isTrue(m1091 is core.List<core.int> Function(int x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1091) is F1091);
+ // In checked mode, verifies the type.
+ x1091 = m1091;
+ l1091 = m1091;
+ x1091 = confuse(m1091);
+ l1091 = confuse(m1091);
+
+ }
+
+ void testF1191() {
+ // core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1191 is F1191);
+ Expect.isTrue(confuse(f1191) is F1191);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x) l1191;
+ // The static function f1191 sets `T` to `int`.
+ if (!tIsBool) {
+ x1191 = f1191 as dynamic;
+ l1191 = f1191 as dynamic;
+ x1191 = confuse(f1191);
+ l1191 = confuse(f1191);
+ }
+
+ Expect.isTrue(m1191 is F1191);
+ Expect.isTrue(m1191 is core.List<core.int> Function(int x, [List<Function> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1191) is F1191);
+ // In checked mode, verifies the type.
+ x1191 = m1191;
+ l1191 = m1191;
+ x1191 = confuse(m1191);
+ l1191 = confuse(m1191);
+
+ }
+
+ void testF1291() {
+ // core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1291 is F1291);
+ Expect.isTrue(confuse(f1291) is F1291);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1291;
+ // The static function f1291 sets `T` to `int`.
+ if (!tIsBool) {
+ x1291 = f1291 as dynamic;
+ l1291 = f1291 as dynamic;
+ x1291 = confuse(f1291);
+ l1291 = confuse(f1291);
+ }
+
+ Expect.isTrue(m1291 is F1291);
+ Expect.isTrue(m1291 is core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1291) is F1291);
+ // In checked mode, verifies the type.
+ x1291 = m1291;
+ l1291 = m1291;
+ x1291 = confuse(m1291);
+ l1291 = confuse(m1291);
+ if (!tIsBool) {
+ Expect.isTrue(f1291 is F1291<int>);
+ Expect.isFalse(f1291 is F1291<bool>);
+ Expect.isTrue(confuse(f1291) is F1291<int>);
+ Expect.isFalse(confuse(f1291) is F1291<bool>);
+ Expect.equals(tIsDynamic, m1291 is F1291<bool>);
+ Expect.equals(tIsDynamic, confuse(m1291) is F1291<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1291 = (f1291 as dynamic); });
+ Expect.throws(() { x1291 = confuse(f1291); });
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1291;
+ Expect.throws(() { l1291 = (f1291 as dynamic); });
+ Expect.throws(() { l1291 = confuse(f1291); });
+ }
+ core.List<core.int> Function(int y, {List<T> x}) Function<B extends core.int>(int x) l1291 = m1291;
+ // In checked mode, verifies the type.
+ x1291 = m1291;
+ x1291 = confuse(m1291);
+ }
+ }
+
+ void testF1391() {
+ // List<T> Function([List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1391 is F1391);
+ Expect.isTrue(confuse(f1391) is F1391);
+ // In checked mode, verifies the type.
+ List<T> Function([List<Function> x]) Function<B extends core.int>(int x) l1391;
+ // The static function f1391 sets `T` to `int`.
+ if (!tIsBool) {
+ x1391 = f1391 as dynamic;
+ l1391 = f1391 as dynamic;
+ x1391 = confuse(f1391);
+ l1391 = confuse(f1391);
+ }
+
+ Expect.isTrue(m1391 is F1391);
+ Expect.isTrue(m1391 is List<T> Function([List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1391) is F1391);
+ // In checked mode, verifies the type.
+ x1391 = m1391;
+ l1391 = m1391;
+ x1391 = confuse(m1391);
+ l1391 = confuse(m1391);
+ if (!tIsBool) {
+ Expect.isTrue(f1391 is F1391<int>);
+ Expect.isFalse(f1391 is F1391<bool>);
+ Expect.isTrue(confuse(f1391) is F1391<int>);
+ Expect.isFalse(confuse(f1391) is F1391<bool>);
+ Expect.equals(tIsDynamic, m1391 is F1391<bool>);
+ Expect.equals(tIsDynamic, confuse(m1391) is F1391<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1391 = (f1391 as dynamic); });
+ Expect.throws(() { x1391 = confuse(f1391); });
+ List<T> Function([List<Function> x]) Function<B extends core.int>(int x) l1391;
+ Expect.throws(() { l1391 = (f1391 as dynamic); });
+ Expect.throws(() { l1391 = confuse(f1391); });
+ }
+ List<T> Function([List<Function> x]) Function<B extends core.int>(int x) l1391 = m1391;
+ // In checked mode, verifies the type.
+ x1391 = m1391;
+ x1391 = confuse(m1391);
+ }
+ }
+
+ void testF1491() {
+ // List<T> Function(List<T> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f1491 is F1491);
+ Expect.isTrue(confuse(f1491) is F1491);
+ // In checked mode, verifies the type.
+ List<T> Function(List<T> x1) Function<B extends core.int>(int x) l1491;
+ // The static function f1491 sets `T` to `int`.
+ if (!tIsBool) {
+ x1491 = f1491 as dynamic;
+ l1491 = f1491 as dynamic;
+ x1491 = confuse(f1491);
+ l1491 = confuse(f1491);
+ }
+
+ Expect.isTrue(m1491 is F1491);
+ Expect.isTrue(m1491 is List<T> Function(List<T> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1491) is F1491);
+ // In checked mode, verifies the type.
+ x1491 = m1491;
+ l1491 = m1491;
+ x1491 = confuse(m1491);
+ l1491 = confuse(m1491);
+ if (!tIsBool) {
+ Expect.isTrue(f1491 is F1491<int>);
+ Expect.isFalse(f1491 is F1491<bool>);
+ Expect.isTrue(confuse(f1491) is F1491<int>);
+ Expect.isFalse(confuse(f1491) is F1491<bool>);
+ Expect.equals(tIsDynamic, m1491 is F1491<bool>);
+ Expect.equals(tIsDynamic, confuse(m1491) is F1491<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1491 = (f1491 as dynamic); });
+ Expect.throws(() { x1491 = confuse(f1491); });
+ List<T> Function(List<T> x1) Function<B extends core.int>(int x) l1491;
+ Expect.throws(() { l1491 = (f1491 as dynamic); });
+ Expect.throws(() { l1491 = confuse(f1491); });
+ }
+ List<T> Function(List<T> x1) Function<B extends core.int>(int x) l1491 = m1491;
+ // In checked mode, verifies the type.
+ x1491 = m1491;
+ x1491 = confuse(m1491);
+ }
+ }
+
+ void testF1591() {
+ // Function(int x2, [Function x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1591 is F1591);
+ Expect.isTrue(confuse(f1591) is F1591);
+ // In checked mode, verifies the type.
+ Function(int x2, [Function x3]) Function<B extends core.int>(int x) l1591;
+ // The static function f1591 sets `T` to `int`.
+ if (!tIsBool) {
+ x1591 = f1591 as dynamic;
+ l1591 = f1591 as dynamic;
+ x1591 = confuse(f1591);
+ l1591 = confuse(f1591);
+ }
+
+ Expect.isTrue(m1591 is F1591);
+ Expect.isTrue(m1591 is Function(int x2, [Function x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1591) is F1591);
+ // In checked mode, verifies the type.
+ x1591 = m1591;
+ l1591 = m1591;
+ x1591 = confuse(m1591);
+ l1591 = confuse(m1591);
+
+ }
+
+ void testF1691() {
+ // Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1691 is F1691);
+ Expect.isTrue(confuse(f1691) is F1691);
+ // In checked mode, verifies the type.
+ Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l1691;
+ // The static function f1691 sets `T` to `int`.
+ if (!tIsBool) {
+ x1691 = f1691 as dynamic;
+ l1691 = f1691 as dynamic;
+ x1691 = confuse(f1691);
+ l1691 = confuse(f1691);
+ }
+
+ Expect.isTrue(m1691 is F1691);
+ Expect.isTrue(m1691 is Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1691) is F1691);
+ // In checked mode, verifies the type.
+ x1691 = m1691;
+ l1691 = m1691;
+ x1691 = confuse(m1691);
+ l1691 = confuse(m1691);
+
+ }
+
+ void testF1791() {
+ // Function Function<A>(core.List<core.int> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1791 is F1791);
+ Expect.isTrue(confuse(f1791) is F1791);
+ // In checked mode, verifies the type.
+ Function Function<A>(core.List<core.int> x) Function<B extends core.int>(int x) l1791;
+ // The static function f1791 sets `T` to `int`.
+ if (!tIsBool) {
+ x1791 = f1791 as dynamic;
+ l1791 = f1791 as dynamic;
+ x1791 = confuse(f1791);
+ l1791 = confuse(f1791);
+ }
+
+ Expect.isTrue(m1791 is F1791);
+ Expect.isTrue(m1791 is Function Function<A>(core.List<core.int> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1791) is F1791);
+ // In checked mode, verifies the type.
+ x1791 = m1791;
+ l1791 = m1791;
+ x1791 = confuse(m1791);
+ l1791 = confuse(m1791);
+
+ }
+
+ void testF1891() {
+ // List<T> Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1891 is F1891);
+ Expect.isTrue(confuse(f1891) is F1891);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(List<T> x) Function<B extends core.int>(int x) l1891;
+ // The static function f1891 sets `T` to `int`.
+ if (!tIsBool) {
+ x1891 = f1891 as dynamic;
+ l1891 = f1891 as dynamic;
+ x1891 = confuse(f1891);
+ l1891 = confuse(f1891);
+ }
+
+ Expect.isTrue(m1891 is F1891);
+ Expect.isTrue(m1891 is List<T> Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1891) is F1891);
+ // In checked mode, verifies the type.
+ x1891 = m1891;
+ l1891 = m1891;
+ x1891 = confuse(m1891);
+ l1891 = confuse(m1891);
+ if (!tIsBool) {
+ Expect.isTrue(f1891 is F1891<int>);
+ Expect.isFalse(f1891 is F1891<bool>);
+ Expect.isTrue(confuse(f1891) is F1891<int>);
+ Expect.isFalse(confuse(f1891) is F1891<bool>);
+ Expect.equals(tIsDynamic, m1891 is F1891<bool>);
+ Expect.equals(tIsDynamic, confuse(m1891) is F1891<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1891 = (f1891 as dynamic); });
+ Expect.throws(() { x1891 = confuse(f1891); });
+ List<T> Function<A>(List<T> x) Function<B extends core.int>(int x) l1891;
+ Expect.throws(() { l1891 = (f1891 as dynamic); });
+ Expect.throws(() { l1891 = confuse(f1891); });
+ }
+ List<T> Function<A>(List<T> x) Function<B extends core.int>(int x) l1891 = m1891;
+ // In checked mode, verifies the type.
+ x1891 = m1891;
+ x1891 = confuse(m1891);
+ }
+ }
+
+ void testF1991() {
+ // List<A> Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1991 is F1991);
+ Expect.isTrue(confuse(f1991) is F1991);
+ // In checked mode, verifies the type.
+ List<A> Function<A>() Function<B extends core.int>(int x) l1991;
+ // The static function f1991 sets `T` to `int`.
+ if (!tIsBool) {
+ x1991 = f1991 as dynamic;
+ l1991 = f1991 as dynamic;
+ x1991 = confuse(f1991);
+ l1991 = confuse(f1991);
+ }
+
+ Expect.isTrue(m1991 is F1991);
+ Expect.isTrue(m1991 is List<A> Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1991) is F1991);
+ // In checked mode, verifies the type.
+ x1991 = m1991;
+ l1991 = m1991;
+ x1991 = confuse(m1991);
+ l1991 = confuse(m1991);
+
+ }
+
+
+}
+
+class C92<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, [core.List<core.int> x]) x92;
+ core.List<core.int> Function(int x0, [List<Function> x]) x192;
+ Function([Function x]) x292;
+ List<A> Function<A>(int x) x392;
+ int Function([List<Function> x]) Function() x492;
+ int Function(List<T> x0) Function() x592;
+ Function Function(int x1, [Function x2]) Function() x692;
+ Function Function(int x0, {core.List<core.int> x}) Function() x792;
+ List<Function> Function(Function x) Function() x892;
+ List<Function> Function(int y, [core.List<core.int> x]) Function() x992;
+ core.List<core.int> Function([int x1]) Function() x1092;
+ core.List<core.int> Function({List<Function> x}) Function() x1192;
+ core.List<core.int> Function() Function() x1292;
+ List<T> Function(int x0, [List<Function> x]) Function() x1392;
+ List<T> Function([List<T> x1]) Function() x1492;
+ Function(int x, [Function x2]) Function() x1592;
+ Function(int y, {core.List<core.int> x}) Function() x1692;
+ Function Function<A>(List<T> x) Function() x1792;
+ List<T> Function<A>() Function() x1892;
+ List<A> Function<A>(A x) Function() x1992;
+
+
+ C92({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m92(int y, [core.List<core.int> x]) => null;
+ core.List<core.int> m192(int x0, [List<Function> x]) => null;
+ m292([Function x]) => null;
+ List<A> m392<A>(int x) => null;
+ int Function([List<Function> x]) m492() => null;
+ int Function(List<T> x0) m592() => null;
+ Function Function(int x0, [Function x1]) m692() => null;
+ Function Function(int x0, {core.List<core.int> x}) m792() => null;
+ List<Function> Function(Function x) m892() => null;
+ List<Function> Function(int y, [core.List<core.int> x]) m992() => null;
+ core.List<core.int> Function([int x0]) m1092() => null;
+ core.List<core.int> Function({List<Function> x}) m1192() => null;
+ core.List<core.int> Function() m1292() => null;
+ List<T> Function(int x0, [List<Function> x]) m1392() => null;
+ List<T> Function([List<T> x0]) m1492() => null;
+ Function(int x, [Function x0]) m1592() => null;
+ Function(int y, {core.List<core.int> x}) m1692() => null;
+ Function Function<A>(List<T> x) m1792() => null;
+ List<T> Function<A>() m1892() => null;
+ List<A> Function<A>(A x) m1992() => null;
+
+
+ runTests() {
+ testF92();
+ testF192();
+ testF292();
+ testF392();
+ testF492();
+ testF592();
+ testF692();
+ testF792();
+ testF892();
+ testF992();
+ testF1092();
+ testF1192();
+ testF1292();
+ testF1392();
+ testF1492();
+ testF1592();
+ testF1692();
+ testF1792();
+ testF1892();
+ testF1992();
+ }
+
+ void testF92() {
+ // Function Function(int y, [core.List<core.int> x])
+ Expect.isTrue(f92 is F92);
+ Expect.isTrue(confuse(f92) is F92);
+ // In checked mode, verifies the type.
+ Function Function(int y, [core.List<core.int> x]) l92;
+ // The static function f92 sets `T` to `int`.
+ if (!tIsBool) {
+ x92 = f92 as dynamic;
+ l92 = f92 as dynamic;
+ x92 = confuse(f92);
+ l92 = confuse(f92);
+ }
+
+ Expect.isTrue(m92 is F92);
+ Expect.isTrue(m92 is Function Function(int y, [core.List<core.int> x]));
+ Expect.isTrue(confuse(m92) is F92);
+ // In checked mode, verifies the type.
+ x92 = m92;
+ l92 = m92;
+ x92 = confuse(m92);
+ l92 = confuse(m92);
+
+ }
+
+ void testF192() {
+ // core.List<core.int> Function(int x0, [List<Function> x])
+ Expect.isTrue(f192 is F192);
+ Expect.isTrue(confuse(f192) is F192);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, [List<Function> x]) l192;
+ // The static function f192 sets `T` to `int`.
+ if (!tIsBool) {
+ x192 = f192 as dynamic;
+ l192 = f192 as dynamic;
+ x192 = confuse(f192);
+ l192 = confuse(f192);
+ }
+
+ Expect.isTrue(m192 is F192);
+ Expect.isTrue(m192 is core.List<core.int> Function(int x0, [List<Function> x]));
+ Expect.isTrue(confuse(m192) is F192);
+ // In checked mode, verifies the type.
+ x192 = m192;
+ l192 = m192;
+ x192 = confuse(m192);
+ l192 = confuse(m192);
+
+ }
+
+ void testF292() {
+ // Function([Function x])
+ Expect.isTrue(f292 is F292);
+ Expect.isTrue(confuse(f292) is F292);
+ // In checked mode, verifies the type.
+ Function([Function x]) l292;
+ // The static function f292 sets `T` to `int`.
+ if (!tIsBool) {
+ x292 = f292 as dynamic;
+ l292 = f292 as dynamic;
+ x292 = confuse(f292);
+ l292 = confuse(f292);
+ }
+
+ Expect.isTrue(m292 is F292);
+ Expect.isTrue(m292 is Function([Function x]));
+ Expect.isTrue(confuse(m292) is F292);
+ // In checked mode, verifies the type.
+ x292 = m292;
+ l292 = m292;
+ x292 = confuse(m292);
+ l292 = confuse(m292);
+
+ }
+
+ void testF392() {
+ // List<A> Function<A>(int x)
+ Expect.isTrue(f392 is F392);
+ Expect.isTrue(confuse(f392) is F392);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(int x) l392;
+ // The static function f392 sets `T` to `int`.
+ if (!tIsBool) {
+ x392 = f392 as dynamic;
+ l392 = f392 as dynamic;
+ x392 = confuse(f392);
+ l392 = confuse(f392);
+ }
+
+ Expect.isTrue(m392 is F392);
+ Expect.isTrue(m392 is List<A> Function<A>(int x));
+ Expect.isTrue(confuse(m392) is F392);
+ // In checked mode, verifies the type.
+ x392 = m392;
+ l392 = m392;
+ x392 = confuse(m392);
+ l392 = confuse(m392);
+
+ }
+
+ void testF492() {
+ // int Function([List<Function> x]) Function()
+ Expect.isTrue(f492 is F492);
+ Expect.isTrue(confuse(f492) is F492);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x]) Function() l492;
+ // The static function f492 sets `T` to `int`.
+ if (!tIsBool) {
+ x492 = f492 as dynamic;
+ l492 = f492 as dynamic;
+ x492 = confuse(f492);
+ l492 = confuse(f492);
+ }
+
+ Expect.isTrue(m492 is F492);
+ Expect.isTrue(m492 is int Function([List<Function> x]) Function());
+ Expect.isTrue(confuse(m492) is F492);
+ // In checked mode, verifies the type.
+ x492 = m492;
+ l492 = m492;
+ x492 = confuse(m492);
+ l492 = confuse(m492);
+
+ }
+
+ void testF592() {
+ // int Function(List<T> x0) Function()
+ Expect.isTrue(f592 is F592);
+ Expect.isTrue(confuse(f592) is F592);
+ // In checked mode, verifies the type.
+ int Function(List<T> x0) Function() l592;
+ // The static function f592 sets `T` to `int`.
+ if (!tIsBool) {
+ x592 = f592 as dynamic;
+ l592 = f592 as dynamic;
+ x592 = confuse(f592);
+ l592 = confuse(f592);
+ }
+
+ Expect.isTrue(m592 is F592);
+ Expect.isTrue(m592 is int Function(List<T> x0) Function());
+ Expect.isTrue(confuse(m592) is F592);
+ // In checked mode, verifies the type.
+ x592 = m592;
+ l592 = m592;
+ x592 = confuse(m592);
+ l592 = confuse(m592);
+ if (!tIsBool) {
+ Expect.isTrue(f592 is F592<int>);
+ Expect.isFalse(f592 is F592<bool>);
+ Expect.isTrue(confuse(f592) is F592<int>);
+ Expect.isFalse(confuse(f592) is F592<bool>);
+ Expect.equals(tIsDynamic, m592 is F592<bool>);
+ Expect.equals(tIsDynamic, confuse(m592) is F592<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x592 = (f592 as dynamic); });
+ Expect.throws(() { x592 = confuse(f592); });
+ int Function(List<T> x0) Function() l592;
+ Expect.throws(() { l592 = (f592 as dynamic); });
+ Expect.throws(() { l592 = confuse(f592); });
+ }
+ int Function(List<T> x0) Function() l592 = m592;
+ // In checked mode, verifies the type.
+ x592 = m592;
+ x592 = confuse(m592);
+ }
+ }
+
+ void testF692() {
+ // Function Function(int x1, [Function x2]) Function()
+ Expect.isTrue(f692 is F692);
+ Expect.isTrue(confuse(f692) is F692);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [Function x2]) Function() l692;
+ // The static function f692 sets `T` to `int`.
+ if (!tIsBool) {
+ x692 = f692 as dynamic;
+ l692 = f692 as dynamic;
+ x692 = confuse(f692);
+ l692 = confuse(f692);
+ }
+
+ Expect.isTrue(m692 is F692);
+ Expect.isTrue(m692 is Function Function(int x1, [Function x2]) Function());
+ Expect.isTrue(confuse(m692) is F692);
+ // In checked mode, verifies the type.
+ x692 = m692;
+ l692 = m692;
+ x692 = confuse(m692);
+ l692 = confuse(m692);
+
+ }
+
+ void testF792() {
+ // Function Function(int x0, {core.List<core.int> x}) Function()
+ Expect.isTrue(f792 is F792);
+ Expect.isTrue(confuse(f792) is F792);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {core.List<core.int> x}) Function() l792;
+ // The static function f792 sets `T` to `int`.
+ if (!tIsBool) {
+ x792 = f792 as dynamic;
+ l792 = f792 as dynamic;
+ x792 = confuse(f792);
+ l792 = confuse(f792);
+ }
+
+ Expect.isTrue(m792 is F792);
+ Expect.isTrue(m792 is Function Function(int x0, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m792) is F792);
+ // In checked mode, verifies the type.
+ x792 = m792;
+ l792 = m792;
+ x792 = confuse(m792);
+ l792 = confuse(m792);
+
+ }
+
+ void testF892() {
+ // List<Function> Function(Function x) Function()
+ Expect.isTrue(f892 is F892);
+ Expect.isTrue(confuse(f892) is F892);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x) Function() l892;
+ // The static function f892 sets `T` to `int`.
+ if (!tIsBool) {
+ x892 = f892 as dynamic;
+ l892 = f892 as dynamic;
+ x892 = confuse(f892);
+ l892 = confuse(f892);
+ }
+
+ Expect.isTrue(m892 is F892);
+ Expect.isTrue(m892 is List<Function> Function(Function x) Function());
+ Expect.isTrue(confuse(m892) is F892);
+ // In checked mode, verifies the type.
+ x892 = m892;
+ l892 = m892;
+ x892 = confuse(m892);
+ l892 = confuse(m892);
+
+ }
+
+ void testF992() {
+ // List<Function> Function(int y, [core.List<core.int> x]) Function()
+ Expect.isTrue(f992 is F992);
+ Expect.isTrue(confuse(f992) is F992);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [core.List<core.int> x]) Function() l992;
+ // The static function f992 sets `T` to `int`.
+ if (!tIsBool) {
+ x992 = f992 as dynamic;
+ l992 = f992 as dynamic;
+ x992 = confuse(f992);
+ l992 = confuse(f992);
+ }
+
+ Expect.isTrue(m992 is F992);
+ Expect.isTrue(m992 is List<Function> Function(int y, [core.List<core.int> x]) Function());
+ Expect.isTrue(confuse(m992) is F992);
+ // In checked mode, verifies the type.
+ x992 = m992;
+ l992 = m992;
+ x992 = confuse(m992);
+ l992 = confuse(m992);
+
+ }
+
+ void testF1092() {
+ // core.List<core.int> Function([int x1]) Function()
+ Expect.isTrue(f1092 is F1092);
+ Expect.isTrue(confuse(f1092) is F1092);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x1]) Function() l1092;
+ // The static function f1092 sets `T` to `int`.
+ if (!tIsBool) {
+ x1092 = f1092 as dynamic;
+ l1092 = f1092 as dynamic;
+ x1092 = confuse(f1092);
+ l1092 = confuse(f1092);
+ }
+
+ Expect.isTrue(m1092 is F1092);
+ Expect.isTrue(m1092 is core.List<core.int> Function([int x1]) Function());
+ Expect.isTrue(confuse(m1092) is F1092);
+ // In checked mode, verifies the type.
+ x1092 = m1092;
+ l1092 = m1092;
+ x1092 = confuse(m1092);
+ l1092 = confuse(m1092);
+
+ }
+
+ void testF1192() {
+ // core.List<core.int> Function({List<Function> x}) Function()
+ Expect.isTrue(f1192 is F1192);
+ Expect.isTrue(confuse(f1192) is F1192);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<Function> x}) Function() l1192;
+ // The static function f1192 sets `T` to `int`.
+ if (!tIsBool) {
+ x1192 = f1192 as dynamic;
+ l1192 = f1192 as dynamic;
+ x1192 = confuse(f1192);
+ l1192 = confuse(f1192);
+ }
+
+ Expect.isTrue(m1192 is F1192);
+ Expect.isTrue(m1192 is core.List<core.int> Function({List<Function> x}) Function());
+ Expect.isTrue(confuse(m1192) is F1192);
+ // In checked mode, verifies the type.
+ x1192 = m1192;
+ l1192 = m1192;
+ x1192 = confuse(m1192);
+ l1192 = confuse(m1192);
+
+ }
+
+ void testF1292() {
+ // core.List<core.int> Function() Function()
+ Expect.isTrue(f1292 is F1292);
+ Expect.isTrue(confuse(f1292) is F1292);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function() Function() l1292;
+ // The static function f1292 sets `T` to `int`.
+ if (!tIsBool) {
+ x1292 = f1292 as dynamic;
+ l1292 = f1292 as dynamic;
+ x1292 = confuse(f1292);
+ l1292 = confuse(f1292);
+ }
+
+ Expect.isTrue(m1292 is F1292);
+ Expect.isTrue(m1292 is core.List<core.int> Function() Function());
+ Expect.isTrue(confuse(m1292) is F1292);
+ // In checked mode, verifies the type.
+ x1292 = m1292;
+ l1292 = m1292;
+ x1292 = confuse(m1292);
+ l1292 = confuse(m1292);
+
+ }
+
+ void testF1392() {
+ // List<T> Function(int x0, [List<Function> x]) Function()
+ Expect.isTrue(f1392 is F1392);
+ Expect.isTrue(confuse(f1392) is F1392);
+ // In checked mode, verifies the type.
+ List<T> Function(int x0, [List<Function> x]) Function() l1392;
+ // The static function f1392 sets `T` to `int`.
+ if (!tIsBool) {
+ x1392 = f1392 as dynamic;
+ l1392 = f1392 as dynamic;
+ x1392 = confuse(f1392);
+ l1392 = confuse(f1392);
+ }
+
+ Expect.isTrue(m1392 is F1392);
+ Expect.isTrue(m1392 is List<T> Function(int x0, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m1392) is F1392);
+ // In checked mode, verifies the type.
+ x1392 = m1392;
+ l1392 = m1392;
+ x1392 = confuse(m1392);
+ l1392 = confuse(m1392);
+ if (!tIsBool) {
+ Expect.isTrue(f1392 is F1392<int>);
+ Expect.isFalse(f1392 is F1392<bool>);
+ Expect.isTrue(confuse(f1392) is F1392<int>);
+ Expect.isFalse(confuse(f1392) is F1392<bool>);
+ Expect.equals(tIsDynamic, m1392 is F1392<bool>);
+ Expect.equals(tIsDynamic, confuse(m1392) is F1392<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1392 = (f1392 as dynamic); });
+ Expect.throws(() { x1392 = confuse(f1392); });
+ List<T> Function(int x0, [List<Function> x]) Function() l1392;
+ Expect.throws(() { l1392 = (f1392 as dynamic); });
+ Expect.throws(() { l1392 = confuse(f1392); });
+ }
+ List<T> Function(int x0, [List<Function> x]) Function() l1392 = m1392;
+ // In checked mode, verifies the type.
+ x1392 = m1392;
+ x1392 = confuse(m1392);
+ }
+ }
+
+ void testF1492() {
+ // List<T> Function([List<T> x1]) Function()
+ Expect.isTrue(f1492 is F1492);
+ Expect.isTrue(confuse(f1492) is F1492);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x1]) Function() l1492;
+ // The static function f1492 sets `T` to `int`.
+ if (!tIsBool) {
+ x1492 = f1492 as dynamic;
+ l1492 = f1492 as dynamic;
+ x1492 = confuse(f1492);
+ l1492 = confuse(f1492);
+ }
+
+ Expect.isTrue(m1492 is F1492);
+ Expect.isTrue(m1492 is List<T> Function([List<T> x1]) Function());
+ Expect.isTrue(confuse(m1492) is F1492);
+ // In checked mode, verifies the type.
+ x1492 = m1492;
+ l1492 = m1492;
+ x1492 = confuse(m1492);
+ l1492 = confuse(m1492);
+ if (!tIsBool) {
+ Expect.isTrue(f1492 is F1492<int>);
+ Expect.isFalse(f1492 is F1492<bool>);
+ Expect.isTrue(confuse(f1492) is F1492<int>);
+ Expect.isFalse(confuse(f1492) is F1492<bool>);
+ Expect.equals(tIsDynamic, m1492 is F1492<bool>);
+ Expect.equals(tIsDynamic, confuse(m1492) is F1492<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1492 = (f1492 as dynamic); });
+ Expect.throws(() { x1492 = confuse(f1492); });
+ List<T> Function([List<T> x1]) Function() l1492;
+ Expect.throws(() { l1492 = (f1492 as dynamic); });
+ Expect.throws(() { l1492 = confuse(f1492); });
+ }
+ List<T> Function([List<T> x1]) Function() l1492 = m1492;
+ // In checked mode, verifies the type.
+ x1492 = m1492;
+ x1492 = confuse(m1492);
+ }
+ }
+
+ void testF1592() {
+ // Function(int x, [Function x2]) Function()
+ Expect.isTrue(f1592 is F1592);
+ Expect.isTrue(confuse(f1592) is F1592);
+ // In checked mode, verifies the type.
+ Function(int x, [Function x2]) Function() l1592;
+ // The static function f1592 sets `T` to `int`.
+ if (!tIsBool) {
+ x1592 = f1592 as dynamic;
+ l1592 = f1592 as dynamic;
+ x1592 = confuse(f1592);
+ l1592 = confuse(f1592);
+ }
+
+ Expect.isTrue(m1592 is F1592);
+ Expect.isTrue(m1592 is Function(int x, [Function x2]) Function());
+ Expect.isTrue(confuse(m1592) is F1592);
+ // In checked mode, verifies the type.
+ x1592 = m1592;
+ l1592 = m1592;
+ x1592 = confuse(m1592);
+ l1592 = confuse(m1592);
+
+ }
+
+ void testF1692() {
+ // Function(int y, {core.List<core.int> x}) Function()
+ Expect.isTrue(f1692 is F1692);
+ Expect.isTrue(confuse(f1692) is F1692);
+ // In checked mode, verifies the type.
+ Function(int y, {core.List<core.int> x}) Function() l1692;
+ // The static function f1692 sets `T` to `int`.
+ if (!tIsBool) {
+ x1692 = f1692 as dynamic;
+ l1692 = f1692 as dynamic;
+ x1692 = confuse(f1692);
+ l1692 = confuse(f1692);
+ }
+
+ Expect.isTrue(m1692 is F1692);
+ Expect.isTrue(m1692 is Function(int y, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m1692) is F1692);
+ // In checked mode, verifies the type.
+ x1692 = m1692;
+ l1692 = m1692;
+ x1692 = confuse(m1692);
+ l1692 = confuse(m1692);
+
+ }
+
+ void testF1792() {
+ // Function Function<A>(List<T> x) Function()
+ Expect.isTrue(f1792 is F1792);
+ Expect.isTrue(confuse(f1792) is F1792);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<T> x) Function() l1792;
+ // The static function f1792 sets `T` to `int`.
+ if (!tIsBool) {
+ x1792 = f1792 as dynamic;
+ l1792 = f1792 as dynamic;
+ x1792 = confuse(f1792);
+ l1792 = confuse(f1792);
+ }
+
+ Expect.isTrue(m1792 is F1792);
+ Expect.isTrue(m1792 is Function Function<A>(List<T> x) Function());
+ Expect.isTrue(confuse(m1792) is F1792);
+ // In checked mode, verifies the type.
+ x1792 = m1792;
+ l1792 = m1792;
+ x1792 = confuse(m1792);
+ l1792 = confuse(m1792);
+ if (!tIsBool) {
+ Expect.isTrue(f1792 is F1792<int>);
+ Expect.isFalse(f1792 is F1792<bool>);
+ Expect.isTrue(confuse(f1792) is F1792<int>);
+ Expect.isFalse(confuse(f1792) is F1792<bool>);
+ Expect.equals(tIsDynamic, m1792 is F1792<bool>);
+ Expect.equals(tIsDynamic, confuse(m1792) is F1792<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1792 = (f1792 as dynamic); });
+ Expect.throws(() { x1792 = confuse(f1792); });
+ Function Function<A>(List<T> x) Function() l1792;
+ Expect.throws(() { l1792 = (f1792 as dynamic); });
+ Expect.throws(() { l1792 = confuse(f1792); });
+ }
+ Function Function<A>(List<T> x) Function() l1792 = m1792;
+ // In checked mode, verifies the type.
+ x1792 = m1792;
+ x1792 = confuse(m1792);
+ }
+ }
+
+ void testF1892() {
+ // List<T> Function<A>() Function()
+ Expect.isTrue(f1892 is F1892);
+ Expect.isTrue(confuse(f1892) is F1892);
+ // In checked mode, verifies the type.
+ List<T> Function<A>() Function() l1892;
+ // The static function f1892 sets `T` to `int`.
+ if (!tIsBool) {
+ x1892 = f1892 as dynamic;
+ l1892 = f1892 as dynamic;
+ x1892 = confuse(f1892);
+ l1892 = confuse(f1892);
+ }
+
+ Expect.isTrue(m1892 is F1892);
+ Expect.isTrue(m1892 is List<T> Function<A>() Function());
+ Expect.isTrue(confuse(m1892) is F1892);
+ // In checked mode, verifies the type.
+ x1892 = m1892;
+ l1892 = m1892;
+ x1892 = confuse(m1892);
+ l1892 = confuse(m1892);
+ if (!tIsBool) {
+ Expect.isTrue(f1892 is F1892<int>);
+ Expect.isFalse(f1892 is F1892<bool>);
+ Expect.isTrue(confuse(f1892) is F1892<int>);
+ Expect.isFalse(confuse(f1892) is F1892<bool>);
+ Expect.equals(tIsDynamic, m1892 is F1892<bool>);
+ Expect.equals(tIsDynamic, confuse(m1892) is F1892<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1892 = (f1892 as dynamic); });
+ Expect.throws(() { x1892 = confuse(f1892); });
+ List<T> Function<A>() Function() l1892;
+ Expect.throws(() { l1892 = (f1892 as dynamic); });
+ Expect.throws(() { l1892 = confuse(f1892); });
+ }
+ List<T> Function<A>() Function() l1892 = m1892;
+ // In checked mode, verifies the type.
+ x1892 = m1892;
+ x1892 = confuse(m1892);
+ }
+ }
+
+ void testF1992() {
+ // List<A> Function<A>(A x) Function()
+ Expect.isTrue(f1992 is F1992);
+ Expect.isTrue(confuse(f1992) is F1992);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(A x) Function() l1992;
+ // The static function f1992 sets `T` to `int`.
+ if (!tIsBool) {
+ x1992 = f1992 as dynamic;
+ l1992 = f1992 as dynamic;
+ x1992 = confuse(f1992);
+ l1992 = confuse(f1992);
+ }
+
+ Expect.isTrue(m1992 is F1992);
+ Expect.isTrue(m1992 is List<A> Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1992) is F1992);
+ // In checked mode, verifies the type.
+ x1992 = m1992;
+ l1992 = m1992;
+ x1992 = confuse(m1992);
+ l1992 = confuse(m1992);
+
+ }
+
+
+}
+
+class C93<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(core.List<core.int> x0) x93;
+ core.List<core.int> Function(int y, [List<Function> x]) x193;
+ Function(int x0, [Function x]) x293;
+ List<A> Function<A>(Function x) x393;
+ int Function([List<Function> x]) Function(int x) x493;
+ int Function(List<T> x1) Function(int x) x593;
+ Function Function(int x2, [Function x3]) Function(int x) x693;
+ Function Function(int x1, {core.List<core.int> x}) Function(int x) x793;
+ List<Function> Function(Function x) Function(int x) x893;
+ List<Function> Function(int y, [core.List<core.int> x]) Function(int x) x993;
+ core.List<core.int> Function([int x1]) Function(int x) x1093;
+ core.List<core.int> Function({List<Function> x}) Function(int x) x1193;
+ core.List<core.int> Function() Function(int x) x1293;
+ List<T> Function(int x1, [List<Function> x]) Function(int x) x1393;
+ List<T> Function([List<T> x1]) Function(int x) x1493;
+ Function(int x, [Function x1]) Function(int x) x1593;
+ Function(int y, {core.List<core.int> x}) Function(int x) x1693;
+ Function Function<A>(List<T> x) Function(int x) x1793;
+ List<T> Function<A>() Function(int x) x1893;
+ List<A> Function<A>(A x) Function(int x) x1993;
+
+
+ C93({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m93(core.List<core.int> x0) => null;
+ core.List<core.int> m193(int y, [List<Function> x]) => null;
+ m293(int x0, [Function x]) => null;
+ List<A> m393<A>(Function x) => null;
+ int Function([List<Function> x]) m493(int x) => null;
+ int Function(List<T> x0) m593(int x) => null;
+ Function Function(int x0, [Function x1]) m693(int x) => null;
+ Function Function(int x0, {core.List<core.int> x}) m793(int x) => null;
+ List<Function> Function(Function x) m893(int x) => null;
+ List<Function> Function(int y, [core.List<core.int> x]) m993(int x) => null;
+ core.List<core.int> Function([int x0]) m1093(int x) => null;
+ core.List<core.int> Function({List<Function> x}) m1193(int x) => null;
+ core.List<core.int> Function() m1293(int x) => null;
+ List<T> Function(int x0, [List<Function> x]) m1393(int x) => null;
+ List<T> Function([List<T> x0]) m1493(int x) => null;
+ Function(int x, [Function x0]) m1593(int x) => null;
+ Function(int y, {core.List<core.int> x}) m1693(int x) => null;
+ Function Function<A>(List<T> x) m1793(int x) => null;
+ List<T> Function<A>() m1893(int x) => null;
+ List<A> Function<A>(A x) m1993(int x) => null;
+
+
+ runTests() {
+ testF93();
+ testF193();
+ testF293();
+ testF393();
+ testF493();
+ testF593();
+ testF693();
+ testF793();
+ testF893();
+ testF993();
+ testF1093();
+ testF1193();
+ testF1293();
+ testF1393();
+ testF1493();
+ testF1593();
+ testF1693();
+ testF1793();
+ testF1893();
+ testF1993();
+ }
+
+ void testF93() {
+ // Function Function(core.List<core.int> x0)
+ Expect.isTrue(f93 is F93);
+ Expect.isTrue(confuse(f93) is F93);
+ // In checked mode, verifies the type.
+ Function Function(core.List<core.int> x0) l93;
+ // The static function f93 sets `T` to `int`.
+ if (!tIsBool) {
+ x93 = f93 as dynamic;
+ l93 = f93 as dynamic;
+ x93 = confuse(f93);
+ l93 = confuse(f93);
+ }
+
+ Expect.isTrue(m93 is F93);
+ Expect.isTrue(m93 is Function Function(core.List<core.int> x0));
+ Expect.isTrue(confuse(m93) is F93);
+ // In checked mode, verifies the type.
+ x93 = m93;
+ l93 = m93;
+ x93 = confuse(m93);
+ l93 = confuse(m93);
+
+ }
+
+ void testF193() {
+ // core.List<core.int> Function(int y, [List<Function> x])
+ Expect.isTrue(f193 is F193);
+ Expect.isTrue(confuse(f193) is F193);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int y, [List<Function> x]) l193;
+ // The static function f193 sets `T` to `int`.
+ if (!tIsBool) {
+ x193 = f193 as dynamic;
+ l193 = f193 as dynamic;
+ x193 = confuse(f193);
+ l193 = confuse(f193);
+ }
+
+ Expect.isTrue(m193 is F193);
+ Expect.isTrue(m193 is core.List<core.int> Function(int y, [List<Function> x]));
+ Expect.isTrue(confuse(m193) is F193);
+ // In checked mode, verifies the type.
+ x193 = m193;
+ l193 = m193;
+ x193 = confuse(m193);
+ l193 = confuse(m193);
+
+ }
+
+ void testF293() {
+ // Function(int x0, [Function x])
+ Expect.isTrue(f293 is F293);
+ Expect.isTrue(confuse(f293) is F293);
+ // In checked mode, verifies the type.
+ Function(int x0, [Function x]) l293;
+ // The static function f293 sets `T` to `int`.
+ if (!tIsBool) {
+ x293 = f293 as dynamic;
+ l293 = f293 as dynamic;
+ x293 = confuse(f293);
+ l293 = confuse(f293);
+ }
+
+ Expect.isTrue(m293 is F293);
+ Expect.isTrue(m293 is Function(int x0, [Function x]));
+ Expect.isTrue(confuse(m293) is F293);
+ // In checked mode, verifies the type.
+ x293 = m293;
+ l293 = m293;
+ x293 = confuse(m293);
+ l293 = confuse(m293);
+
+ }
+
+ void testF393() {
+ // List<A> Function<A>(Function x)
+ Expect.isTrue(f393 is F393);
+ Expect.isTrue(confuse(f393) is F393);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(Function x) l393;
+ // The static function f393 sets `T` to `int`.
+ if (!tIsBool) {
+ x393 = f393 as dynamic;
+ l393 = f393 as dynamic;
+ x393 = confuse(f393);
+ l393 = confuse(f393);
+ }
+
+ Expect.isTrue(m393 is F393);
+ Expect.isTrue(m393 is List<A> Function<A>(Function x));
+ Expect.isTrue(confuse(m393) is F393);
+ // In checked mode, verifies the type.
+ x393 = m393;
+ l393 = m393;
+ x393 = confuse(m393);
+ l393 = confuse(m393);
+
+ }
+
+ void testF493() {
+ // int Function([List<Function> x]) Function(int x)
+ Expect.isTrue(f493 is F493);
+ Expect.isTrue(confuse(f493) is F493);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x]) Function(int x) l493;
+ // The static function f493 sets `T` to `int`.
+ if (!tIsBool) {
+ x493 = f493 as dynamic;
+ l493 = f493 as dynamic;
+ x493 = confuse(f493);
+ l493 = confuse(f493);
+ }
+
+ Expect.isTrue(m493 is F493);
+ Expect.isTrue(m493 is int Function([List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m493) is F493);
+ // In checked mode, verifies the type.
+ x493 = m493;
+ l493 = m493;
+ x493 = confuse(m493);
+ l493 = confuse(m493);
+
+ }
+
+ void testF593() {
+ // int Function(List<T> x1) Function(int x)
+ Expect.isTrue(f593 is F593);
+ Expect.isTrue(confuse(f593) is F593);
+ // In checked mode, verifies the type.
+ int Function(List<T> x1) Function(int x) l593;
+ // The static function f593 sets `T` to `int`.
+ if (!tIsBool) {
+ x593 = f593 as dynamic;
+ l593 = f593 as dynamic;
+ x593 = confuse(f593);
+ l593 = confuse(f593);
+ }
+
+ Expect.isTrue(m593 is F593);
+ Expect.isTrue(m593 is int Function(List<T> x1) Function(int x));
+ Expect.isTrue(confuse(m593) is F593);
+ // In checked mode, verifies the type.
+ x593 = m593;
+ l593 = m593;
+ x593 = confuse(m593);
+ l593 = confuse(m593);
+ if (!tIsBool) {
+ Expect.isTrue(f593 is F593<int>);
+ Expect.isFalse(f593 is F593<bool>);
+ Expect.isTrue(confuse(f593) is F593<int>);
+ Expect.isFalse(confuse(f593) is F593<bool>);
+ Expect.equals(tIsDynamic, m593 is F593<bool>);
+ Expect.equals(tIsDynamic, confuse(m593) is F593<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x593 = (f593 as dynamic); });
+ Expect.throws(() { x593 = confuse(f593); });
+ int Function(List<T> x1) Function(int x) l593;
+ Expect.throws(() { l593 = (f593 as dynamic); });
+ Expect.throws(() { l593 = confuse(f593); });
+ }
+ int Function(List<T> x1) Function(int x) l593 = m593;
+ // In checked mode, verifies the type.
+ x593 = m593;
+ x593 = confuse(m593);
+ }
+ }
+
+ void testF693() {
+ // Function Function(int x2, [Function x3]) Function(int x)
+ Expect.isTrue(f693 is F693);
+ Expect.isTrue(confuse(f693) is F693);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [Function x3]) Function(int x) l693;
+ // The static function f693 sets `T` to `int`.
+ if (!tIsBool) {
+ x693 = f693 as dynamic;
+ l693 = f693 as dynamic;
+ x693 = confuse(f693);
+ l693 = confuse(f693);
+ }
+
+ Expect.isTrue(m693 is F693);
+ Expect.isTrue(m693 is Function Function(int x2, [Function x3]) Function(int x));
+ Expect.isTrue(confuse(m693) is F693);
+ // In checked mode, verifies the type.
+ x693 = m693;
+ l693 = m693;
+ x693 = confuse(m693);
+ l693 = confuse(m693);
+
+ }
+
+ void testF793() {
+ // Function Function(int x1, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f793 is F793);
+ Expect.isTrue(confuse(f793) is F793);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {core.List<core.int> x}) Function(int x) l793;
+ // The static function f793 sets `T` to `int`.
+ if (!tIsBool) {
+ x793 = f793 as dynamic;
+ l793 = f793 as dynamic;
+ x793 = confuse(f793);
+ l793 = confuse(f793);
+ }
+
+ Expect.isTrue(m793 is F793);
+ Expect.isTrue(m793 is Function Function(int x1, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m793) is F793);
+ // In checked mode, verifies the type.
+ x793 = m793;
+ l793 = m793;
+ x793 = confuse(m793);
+ l793 = confuse(m793);
+
+ }
+
+ void testF893() {
+ // List<Function> Function(Function x) Function(int x)
+ Expect.isTrue(f893 is F893);
+ Expect.isTrue(confuse(f893) is F893);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x) Function(int x) l893;
+ // The static function f893 sets `T` to `int`.
+ if (!tIsBool) {
+ x893 = f893 as dynamic;
+ l893 = f893 as dynamic;
+ x893 = confuse(f893);
+ l893 = confuse(f893);
+ }
+
+ Expect.isTrue(m893 is F893);
+ Expect.isTrue(m893 is List<Function> Function(Function x) Function(int x));
+ Expect.isTrue(confuse(m893) is F893);
+ // In checked mode, verifies the type.
+ x893 = m893;
+ l893 = m893;
+ x893 = confuse(m893);
+ l893 = confuse(m893);
+
+ }
+
+ void testF993() {
+ // List<Function> Function(int y, [core.List<core.int> x]) Function(int x)
+ Expect.isTrue(f993 is F993);
+ Expect.isTrue(confuse(f993) is F993);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [core.List<core.int> x]) Function(int x) l993;
+ // The static function f993 sets `T` to `int`.
+ if (!tIsBool) {
+ x993 = f993 as dynamic;
+ l993 = f993 as dynamic;
+ x993 = confuse(f993);
+ l993 = confuse(f993);
+ }
+
+ Expect.isTrue(m993 is F993);
+ Expect.isTrue(m993 is List<Function> Function(int y, [core.List<core.int> x]) Function(int x));
+ Expect.isTrue(confuse(m993) is F993);
+ // In checked mode, verifies the type.
+ x993 = m993;
+ l993 = m993;
+ x993 = confuse(m993);
+ l993 = confuse(m993);
+
+ }
+
+ void testF1093() {
+ // core.List<core.int> Function([int x1]) Function(int x)
+ Expect.isTrue(f1093 is F1093);
+ Expect.isTrue(confuse(f1093) is F1093);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x1]) Function(int x) l1093;
+ // The static function f1093 sets `T` to `int`.
+ if (!tIsBool) {
+ x1093 = f1093 as dynamic;
+ l1093 = f1093 as dynamic;
+ x1093 = confuse(f1093);
+ l1093 = confuse(f1093);
+ }
+
+ Expect.isTrue(m1093 is F1093);
+ Expect.isTrue(m1093 is core.List<core.int> Function([int x1]) Function(int x));
+ Expect.isTrue(confuse(m1093) is F1093);
+ // In checked mode, verifies the type.
+ x1093 = m1093;
+ l1093 = m1093;
+ x1093 = confuse(m1093);
+ l1093 = confuse(m1093);
+
+ }
+
+ void testF1193() {
+ // core.List<core.int> Function({List<Function> x}) Function(int x)
+ Expect.isTrue(f1193 is F1193);
+ Expect.isTrue(confuse(f1193) is F1193);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<Function> x}) Function(int x) l1193;
+ // The static function f1193 sets `T` to `int`.
+ if (!tIsBool) {
+ x1193 = f1193 as dynamic;
+ l1193 = f1193 as dynamic;
+ x1193 = confuse(f1193);
+ l1193 = confuse(f1193);
+ }
+
+ Expect.isTrue(m1193 is F1193);
+ Expect.isTrue(m1193 is core.List<core.int> Function({List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1193) is F1193);
+ // In checked mode, verifies the type.
+ x1193 = m1193;
+ l1193 = m1193;
+ x1193 = confuse(m1193);
+ l1193 = confuse(m1193);
+
+ }
+
+ void testF1293() {
+ // core.List<core.int> Function() Function(int x)
+ Expect.isTrue(f1293 is F1293);
+ Expect.isTrue(confuse(f1293) is F1293);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function() Function(int x) l1293;
+ // The static function f1293 sets `T` to `int`.
+ if (!tIsBool) {
+ x1293 = f1293 as dynamic;
+ l1293 = f1293 as dynamic;
+ x1293 = confuse(f1293);
+ l1293 = confuse(f1293);
+ }
+
+ Expect.isTrue(m1293 is F1293);
+ Expect.isTrue(m1293 is core.List<core.int> Function() Function(int x));
+ Expect.isTrue(confuse(m1293) is F1293);
+ // In checked mode, verifies the type.
+ x1293 = m1293;
+ l1293 = m1293;
+ x1293 = confuse(m1293);
+ l1293 = confuse(m1293);
+
+ }
+
+ void testF1393() {
+ // List<T> Function(int x1, [List<Function> x]) Function(int x)
+ Expect.isTrue(f1393 is F1393);
+ Expect.isTrue(confuse(f1393) is F1393);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<Function> x]) Function(int x) l1393;
+ // The static function f1393 sets `T` to `int`.
+ if (!tIsBool) {
+ x1393 = f1393 as dynamic;
+ l1393 = f1393 as dynamic;
+ x1393 = confuse(f1393);
+ l1393 = confuse(f1393);
+ }
+
+ Expect.isTrue(m1393 is F1393);
+ Expect.isTrue(m1393 is List<T> Function(int x1, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1393) is F1393);
+ // In checked mode, verifies the type.
+ x1393 = m1393;
+ l1393 = m1393;
+ x1393 = confuse(m1393);
+ l1393 = confuse(m1393);
+ if (!tIsBool) {
+ Expect.isTrue(f1393 is F1393<int>);
+ Expect.isFalse(f1393 is F1393<bool>);
+ Expect.isTrue(confuse(f1393) is F1393<int>);
+ Expect.isFalse(confuse(f1393) is F1393<bool>);
+ Expect.equals(tIsDynamic, m1393 is F1393<bool>);
+ Expect.equals(tIsDynamic, confuse(m1393) is F1393<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1393 = (f1393 as dynamic); });
+ Expect.throws(() { x1393 = confuse(f1393); });
+ List<T> Function(int x1, [List<Function> x]) Function(int x) l1393;
+ Expect.throws(() { l1393 = (f1393 as dynamic); });
+ Expect.throws(() { l1393 = confuse(f1393); });
+ }
+ List<T> Function(int x1, [List<Function> x]) Function(int x) l1393 = m1393;
+ // In checked mode, verifies the type.
+ x1393 = m1393;
+ x1393 = confuse(m1393);
+ }
+ }
+
+ void testF1493() {
+ // List<T> Function([List<T> x1]) Function(int x)
+ Expect.isTrue(f1493 is F1493);
+ Expect.isTrue(confuse(f1493) is F1493);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x1]) Function(int x) l1493;
+ // The static function f1493 sets `T` to `int`.
+ if (!tIsBool) {
+ x1493 = f1493 as dynamic;
+ l1493 = f1493 as dynamic;
+ x1493 = confuse(f1493);
+ l1493 = confuse(f1493);
+ }
+
+ Expect.isTrue(m1493 is F1493);
+ Expect.isTrue(m1493 is List<T> Function([List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m1493) is F1493);
+ // In checked mode, verifies the type.
+ x1493 = m1493;
+ l1493 = m1493;
+ x1493 = confuse(m1493);
+ l1493 = confuse(m1493);
+ if (!tIsBool) {
+ Expect.isTrue(f1493 is F1493<int>);
+ Expect.isFalse(f1493 is F1493<bool>);
+ Expect.isTrue(confuse(f1493) is F1493<int>);
+ Expect.isFalse(confuse(f1493) is F1493<bool>);
+ Expect.equals(tIsDynamic, m1493 is F1493<bool>);
+ Expect.equals(tIsDynamic, confuse(m1493) is F1493<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1493 = (f1493 as dynamic); });
+ Expect.throws(() { x1493 = confuse(f1493); });
+ List<T> Function([List<T> x1]) Function(int x) l1493;
+ Expect.throws(() { l1493 = (f1493 as dynamic); });
+ Expect.throws(() { l1493 = confuse(f1493); });
+ }
+ List<T> Function([List<T> x1]) Function(int x) l1493 = m1493;
+ // In checked mode, verifies the type.
+ x1493 = m1493;
+ x1493 = confuse(m1493);
+ }
+ }
+
+ void testF1593() {
+ // Function(int x, [Function x1]) Function(int x)
+ Expect.isTrue(f1593 is F1593);
+ Expect.isTrue(confuse(f1593) is F1593);
+ // In checked mode, verifies the type.
+ Function(int x, [Function x1]) Function(int x) l1593;
+ // The static function f1593 sets `T` to `int`.
+ if (!tIsBool) {
+ x1593 = f1593 as dynamic;
+ l1593 = f1593 as dynamic;
+ x1593 = confuse(f1593);
+ l1593 = confuse(f1593);
+ }
+
+ Expect.isTrue(m1593 is F1593);
+ Expect.isTrue(m1593 is Function(int x, [Function x1]) Function(int x));
+ Expect.isTrue(confuse(m1593) is F1593);
+ // In checked mode, verifies the type.
+ x1593 = m1593;
+ l1593 = m1593;
+ x1593 = confuse(m1593);
+ l1593 = confuse(m1593);
+
+ }
+
+ void testF1693() {
+ // Function(int y, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f1693 is F1693);
+ Expect.isTrue(confuse(f1693) is F1693);
+ // In checked mode, verifies the type.
+ Function(int y, {core.List<core.int> x}) Function(int x) l1693;
+ // The static function f1693 sets `T` to `int`.
+ if (!tIsBool) {
+ x1693 = f1693 as dynamic;
+ l1693 = f1693 as dynamic;
+ x1693 = confuse(f1693);
+ l1693 = confuse(f1693);
+ }
+
+ Expect.isTrue(m1693 is F1693);
+ Expect.isTrue(m1693 is Function(int y, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m1693) is F1693);
+ // In checked mode, verifies the type.
+ x1693 = m1693;
+ l1693 = m1693;
+ x1693 = confuse(m1693);
+ l1693 = confuse(m1693);
+
+ }
+
+ void testF1793() {
+ // Function Function<A>(List<T> x) Function(int x)
+ Expect.isTrue(f1793 is F1793);
+ Expect.isTrue(confuse(f1793) is F1793);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<T> x) Function(int x) l1793;
+ // The static function f1793 sets `T` to `int`.
+ if (!tIsBool) {
+ x1793 = f1793 as dynamic;
+ l1793 = f1793 as dynamic;
+ x1793 = confuse(f1793);
+ l1793 = confuse(f1793);
+ }
+
+ Expect.isTrue(m1793 is F1793);
+ Expect.isTrue(m1793 is Function Function<A>(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1793) is F1793);
+ // In checked mode, verifies the type.
+ x1793 = m1793;
+ l1793 = m1793;
+ x1793 = confuse(m1793);
+ l1793 = confuse(m1793);
+ if (!tIsBool) {
+ Expect.isTrue(f1793 is F1793<int>);
+ Expect.isFalse(f1793 is F1793<bool>);
+ Expect.isTrue(confuse(f1793) is F1793<int>);
+ Expect.isFalse(confuse(f1793) is F1793<bool>);
+ Expect.equals(tIsDynamic, m1793 is F1793<bool>);
+ Expect.equals(tIsDynamic, confuse(m1793) is F1793<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1793 = (f1793 as dynamic); });
+ Expect.throws(() { x1793 = confuse(f1793); });
+ Function Function<A>(List<T> x) Function(int x) l1793;
+ Expect.throws(() { l1793 = (f1793 as dynamic); });
+ Expect.throws(() { l1793 = confuse(f1793); });
+ }
+ Function Function<A>(List<T> x) Function(int x) l1793 = m1793;
+ // In checked mode, verifies the type.
+ x1793 = m1793;
+ x1793 = confuse(m1793);
+ }
+ }
+
+ void testF1893() {
+ // List<T> Function<A>() Function(int x)
+ Expect.isTrue(f1893 is F1893);
+ Expect.isTrue(confuse(f1893) is F1893);
+ // In checked mode, verifies the type.
+ List<T> Function<A>() Function(int x) l1893;
+ // The static function f1893 sets `T` to `int`.
+ if (!tIsBool) {
+ x1893 = f1893 as dynamic;
+ l1893 = f1893 as dynamic;
+ x1893 = confuse(f1893);
+ l1893 = confuse(f1893);
+ }
+
+ Expect.isTrue(m1893 is F1893);
+ Expect.isTrue(m1893 is List<T> Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1893) is F1893);
+ // In checked mode, verifies the type.
+ x1893 = m1893;
+ l1893 = m1893;
+ x1893 = confuse(m1893);
+ l1893 = confuse(m1893);
+ if (!tIsBool) {
+ Expect.isTrue(f1893 is F1893<int>);
+ Expect.isFalse(f1893 is F1893<bool>);
+ Expect.isTrue(confuse(f1893) is F1893<int>);
+ Expect.isFalse(confuse(f1893) is F1893<bool>);
+ Expect.equals(tIsDynamic, m1893 is F1893<bool>);
+ Expect.equals(tIsDynamic, confuse(m1893) is F1893<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1893 = (f1893 as dynamic); });
+ Expect.throws(() { x1893 = confuse(f1893); });
+ List<T> Function<A>() Function(int x) l1893;
+ Expect.throws(() { l1893 = (f1893 as dynamic); });
+ Expect.throws(() { l1893 = confuse(f1893); });
+ }
+ List<T> Function<A>() Function(int x) l1893 = m1893;
+ // In checked mode, verifies the type.
+ x1893 = m1893;
+ x1893 = confuse(m1893);
+ }
+ }
+
+ void testF1993() {
+ // List<A> Function<A>(A x) Function(int x)
+ Expect.isTrue(f1993 is F1993);
+ Expect.isTrue(confuse(f1993) is F1993);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(A x) Function(int x) l1993;
+ // The static function f1993 sets `T` to `int`.
+ if (!tIsBool) {
+ x1993 = f1993 as dynamic;
+ l1993 = f1993 as dynamic;
+ x1993 = confuse(f1993);
+ l1993 = confuse(f1993);
+ }
+
+ Expect.isTrue(m1993 is F1993);
+ Expect.isTrue(m1993 is List<A> Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1993) is F1993);
+ // In checked mode, verifies the type.
+ x1993 = m1993;
+ l1993 = m1993;
+ x1993 = confuse(m1993);
+ l1993 = confuse(m1993);
+
+ }
+
+
+}
+
+class C94<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function([core.List<core.int> x1]) x94;
+ core.List<core.int> Function(List<Function> x0) x194;
+ Function(int y, [Function x]) x294;
+ List<A> Function<A>(List<Function> x) x394;
+ int Function([List<Function> x]) Function<B extends core.int>() x494;
+ int Function(List<T> x1) Function<B extends core.int>() x594;
+ Function Function(int x2, [Function x3]) Function<B extends core.int>() x694;
+ Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() x794;
+ List<Function> Function(Function x) Function<B extends core.int>() x894;
+ List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() x994;
+ core.List<core.int> Function([int x1]) Function<B extends core.int>() x1094;
+ core.List<core.int> Function({List<Function> x}) Function<B extends core.int>() x1194;
+ core.List<core.int> Function() Function<B extends core.int>() x1294;
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>() x1394;
+ List<T> Function([List<T> x1]) Function<B extends core.int>() x1494;
+ Function(int x, [Function x1]) Function<B extends core.int>() x1594;
+ Function(int y, {core.List<core.int> x}) Function<B extends core.int>() x1694;
+ Function Function<A>(List<T> x) Function<B extends core.int>() x1794;
+ List<T> Function<A>() Function<B extends core.int>() x1894;
+ List<A> Function<A>(A x) Function<B extends core.int>() x1994;
+
+
+ C94({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m94([core.List<core.int> x0]) => null;
+ core.List<core.int> m194(List<Function> x0) => null;
+ m294(int y, [Function x]) => null;
+ List<A> m394<A>(List<Function> x) => null;
+ int Function([List<Function> x]) m494<B extends core.int>() => null;
+ int Function(List<T> x0) m594<B extends core.int>() => null;
+ Function Function(int x0, [Function x1]) m694<B extends core.int>() => null;
+ Function Function(int x0, {core.List<core.int> x}) m794<B extends core.int>() => null;
+ List<Function> Function(Function x) m894<B extends core.int>() => null;
+ List<Function> Function(int y, [core.List<core.int> x]) m994<B extends core.int>() => null;
+ core.List<core.int> Function([int x0]) m1094<B extends core.int>() => null;
+ core.List<core.int> Function({List<Function> x}) m1194<B extends core.int>() => null;
+ core.List<core.int> Function() m1294<B extends core.int>() => null;
+ List<T> Function(int x0, [List<Function> x]) m1394<B extends core.int>() => null;
+ List<T> Function([List<T> x0]) m1494<B extends core.int>() => null;
+ Function(int x, [Function x0]) m1594<B extends core.int>() => null;
+ Function(int y, {core.List<core.int> x}) m1694<B extends core.int>() => null;
+ Function Function<A>(List<T> x) m1794<B extends core.int>() => null;
+ List<T> Function<A>() m1894<B extends core.int>() => null;
+ List<A> Function<A>(A x) m1994<B extends core.int>() => null;
+
+
+ runTests() {
+ testF94();
+ testF194();
+ testF294();
+ testF394();
+ testF494();
+ testF594();
+ testF694();
+ testF794();
+ testF894();
+ testF994();
+ testF1094();
+ testF1194();
+ testF1294();
+ testF1394();
+ testF1494();
+ testF1594();
+ testF1694();
+ testF1794();
+ testF1894();
+ testF1994();
+ }
+
+ void testF94() {
+ // Function Function([core.List<core.int> x1])
+ Expect.isTrue(f94 is F94);
+ Expect.isTrue(confuse(f94) is F94);
+ // In checked mode, verifies the type.
+ Function Function([core.List<core.int> x1]) l94;
+ // The static function f94 sets `T` to `int`.
+ if (!tIsBool) {
+ x94 = f94 as dynamic;
+ l94 = f94 as dynamic;
+ x94 = confuse(f94);
+ l94 = confuse(f94);
+ }
+
+ Expect.isTrue(m94 is F94);
+ Expect.isTrue(m94 is Function Function([core.List<core.int> x1]));
+ Expect.isTrue(confuse(m94) is F94);
+ // In checked mode, verifies the type.
+ x94 = m94;
+ l94 = m94;
+ x94 = confuse(m94);
+ l94 = confuse(m94);
+
+ }
+
+ void testF194() {
+ // core.List<core.int> Function(List<Function> x0)
+ Expect.isTrue(f194 is F194);
+ Expect.isTrue(confuse(f194) is F194);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(List<Function> x0) l194;
+ // The static function f194 sets `T` to `int`.
+ if (!tIsBool) {
+ x194 = f194 as dynamic;
+ l194 = f194 as dynamic;
+ x194 = confuse(f194);
+ l194 = confuse(f194);
+ }
+
+ Expect.isTrue(m194 is F194);
+ Expect.isTrue(m194 is core.List<core.int> Function(List<Function> x0));
+ Expect.isTrue(confuse(m194) is F194);
+ // In checked mode, verifies the type.
+ x194 = m194;
+ l194 = m194;
+ x194 = confuse(m194);
+ l194 = confuse(m194);
+
+ }
+
+ void testF294() {
+ // Function(int y, [Function x])
+ Expect.isTrue(f294 is F294);
+ Expect.isTrue(confuse(f294) is F294);
+ // In checked mode, verifies the type.
+ Function(int y, [Function x]) l294;
+ // The static function f294 sets `T` to `int`.
+ if (!tIsBool) {
+ x294 = f294 as dynamic;
+ l294 = f294 as dynamic;
+ x294 = confuse(f294);
+ l294 = confuse(f294);
+ }
+
+ Expect.isTrue(m294 is F294);
+ Expect.isTrue(m294 is Function(int y, [Function x]));
+ Expect.isTrue(confuse(m294) is F294);
+ // In checked mode, verifies the type.
+ x294 = m294;
+ l294 = m294;
+ x294 = confuse(m294);
+ l294 = confuse(m294);
+
+ }
+
+ void testF394() {
+ // List<A> Function<A>(List<Function> x)
+ Expect.isTrue(f394 is F394);
+ Expect.isTrue(confuse(f394) is F394);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<Function> x) l394;
+ // The static function f394 sets `T` to `int`.
+ if (!tIsBool) {
+ x394 = f394 as dynamic;
+ l394 = f394 as dynamic;
+ x394 = confuse(f394);
+ l394 = confuse(f394);
+ }
+
+ Expect.isTrue(m394 is F394);
+ Expect.isTrue(m394 is List<A> Function<A>(List<Function> x));
+ Expect.isTrue(confuse(m394) is F394);
+ // In checked mode, verifies the type.
+ x394 = m394;
+ l394 = m394;
+ x394 = confuse(m394);
+ l394 = confuse(m394);
+
+ }
+
+ void testF494() {
+ // int Function([List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f494 is F494);
+ Expect.isTrue(confuse(f494) is F494);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x]) Function<B extends core.int>() l494;
+ // The static function f494 sets `T` to `int`.
+ if (!tIsBool) {
+ x494 = f494 as dynamic;
+ l494 = f494 as dynamic;
+ x494 = confuse(f494);
+ l494 = confuse(f494);
+ }
+
+ Expect.isTrue(m494 is F494);
+ Expect.isTrue(m494 is int Function([List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m494) is F494);
+ // In checked mode, verifies the type.
+ x494 = m494;
+ l494 = m494;
+ x494 = confuse(m494);
+ l494 = confuse(m494);
+
+ }
+
+ void testF594() {
+ // int Function(List<T> x1) Function<B extends core.int>()
+ Expect.isTrue(f594 is F594);
+ Expect.isTrue(confuse(f594) is F594);
+ // In checked mode, verifies the type.
+ int Function(List<T> x1) Function<B extends core.int>() l594;
+ // The static function f594 sets `T` to `int`.
+ if (!tIsBool) {
+ x594 = f594 as dynamic;
+ l594 = f594 as dynamic;
+ x594 = confuse(f594);
+ l594 = confuse(f594);
+ }
+
+ Expect.isTrue(m594 is F594);
+ Expect.isTrue(m594 is int Function(List<T> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m594) is F594);
+ // In checked mode, verifies the type.
+ x594 = m594;
+ l594 = m594;
+ x594 = confuse(m594);
+ l594 = confuse(m594);
+ if (!tIsBool) {
+ Expect.isTrue(f594 is F594<int>);
+ Expect.isFalse(f594 is F594<bool>);
+ Expect.isTrue(confuse(f594) is F594<int>);
+ Expect.isFalse(confuse(f594) is F594<bool>);
+ Expect.equals(tIsDynamic, m594 is F594<bool>);
+ Expect.equals(tIsDynamic, confuse(m594) is F594<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x594 = (f594 as dynamic); });
+ Expect.throws(() { x594 = confuse(f594); });
+ int Function(List<T> x1) Function<B extends core.int>() l594;
+ Expect.throws(() { l594 = (f594 as dynamic); });
+ Expect.throws(() { l594 = confuse(f594); });
+ }
+ int Function(List<T> x1) Function<B extends core.int>() l594 = m594;
+ // In checked mode, verifies the type.
+ x594 = m594;
+ x594 = confuse(m594);
+ }
+ }
+
+ void testF694() {
+ // Function Function(int x2, [Function x3]) Function<B extends core.int>()
+ Expect.isTrue(f694 is F694);
+ Expect.isTrue(confuse(f694) is F694);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [Function x3]) Function<B extends core.int>() l694;
+ // The static function f694 sets `T` to `int`.
+ if (!tIsBool) {
+ x694 = f694 as dynamic;
+ l694 = f694 as dynamic;
+ x694 = confuse(f694);
+ l694 = confuse(f694);
+ }
+
+ Expect.isTrue(m694 is F694);
+ Expect.isTrue(m694 is Function Function(int x2, [Function x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m694) is F694);
+ // In checked mode, verifies the type.
+ x694 = m694;
+ l694 = m694;
+ x694 = confuse(m694);
+ l694 = confuse(m694);
+
+ }
+
+ void testF794() {
+ // Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f794 is F794);
+ Expect.isTrue(confuse(f794) is F794);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>() l794;
+ // The static function f794 sets `T` to `int`.
+ if (!tIsBool) {
+ x794 = f794 as dynamic;
+ l794 = f794 as dynamic;
+ x794 = confuse(f794);
+ l794 = confuse(f794);
+ }
+
+ Expect.isTrue(m794 is F794);
+ Expect.isTrue(m794 is Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m794) is F794);
+ // In checked mode, verifies the type.
+ x794 = m794;
+ l794 = m794;
+ x794 = confuse(m794);
+ l794 = confuse(m794);
+
+ }
+
+ void testF894() {
+ // List<Function> Function(Function x) Function<B extends core.int>()
+ Expect.isTrue(f894 is F894);
+ Expect.isTrue(confuse(f894) is F894);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x) Function<B extends core.int>() l894;
+ // The static function f894 sets `T` to `int`.
+ if (!tIsBool) {
+ x894 = f894 as dynamic;
+ l894 = f894 as dynamic;
+ x894 = confuse(f894);
+ l894 = confuse(f894);
+ }
+
+ Expect.isTrue(m894 is F894);
+ Expect.isTrue(m894 is List<Function> Function(Function x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m894) is F894);
+ // In checked mode, verifies the type.
+ x894 = m894;
+ l894 = m894;
+ x894 = confuse(m894);
+ l894 = confuse(m894);
+
+ }
+
+ void testF994() {
+ // List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>()
+ Expect.isTrue(f994 is F994);
+ Expect.isTrue(confuse(f994) is F994);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>() l994;
+ // The static function f994 sets `T` to `int`.
+ if (!tIsBool) {
+ x994 = f994 as dynamic;
+ l994 = f994 as dynamic;
+ x994 = confuse(f994);
+ l994 = confuse(f994);
+ }
+
+ Expect.isTrue(m994 is F994);
+ Expect.isTrue(m994 is List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m994) is F994);
+ // In checked mode, verifies the type.
+ x994 = m994;
+ l994 = m994;
+ x994 = confuse(m994);
+ l994 = confuse(m994);
+
+ }
+
+ void testF1094() {
+ // core.List<core.int> Function([int x1]) Function<B extends core.int>()
+ Expect.isTrue(f1094 is F1094);
+ Expect.isTrue(confuse(f1094) is F1094);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x1]) Function<B extends core.int>() l1094;
+ // The static function f1094 sets `T` to `int`.
+ if (!tIsBool) {
+ x1094 = f1094 as dynamic;
+ l1094 = f1094 as dynamic;
+ x1094 = confuse(f1094);
+ l1094 = confuse(f1094);
+ }
+
+ Expect.isTrue(m1094 is F1094);
+ Expect.isTrue(m1094 is core.List<core.int> Function([int x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1094) is F1094);
+ // In checked mode, verifies the type.
+ x1094 = m1094;
+ l1094 = m1094;
+ x1094 = confuse(m1094);
+ l1094 = confuse(m1094);
+
+ }
+
+ void testF1194() {
+ // core.List<core.int> Function({List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1194 is F1194);
+ Expect.isTrue(confuse(f1194) is F1194);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<Function> x}) Function<B extends core.int>() l1194;
+ // The static function f1194 sets `T` to `int`.
+ if (!tIsBool) {
+ x1194 = f1194 as dynamic;
+ l1194 = f1194 as dynamic;
+ x1194 = confuse(f1194);
+ l1194 = confuse(f1194);
+ }
+
+ Expect.isTrue(m1194 is F1194);
+ Expect.isTrue(m1194 is core.List<core.int> Function({List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1194) is F1194);
+ // In checked mode, verifies the type.
+ x1194 = m1194;
+ l1194 = m1194;
+ x1194 = confuse(m1194);
+ l1194 = confuse(m1194);
+
+ }
+
+ void testF1294() {
+ // core.List<core.int> Function() Function<B extends core.int>()
+ Expect.isTrue(f1294 is F1294);
+ Expect.isTrue(confuse(f1294) is F1294);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function() Function<B extends core.int>() l1294;
+ // The static function f1294 sets `T` to `int`.
+ if (!tIsBool) {
+ x1294 = f1294 as dynamic;
+ l1294 = f1294 as dynamic;
+ x1294 = confuse(f1294);
+ l1294 = confuse(f1294);
+ }
+
+ Expect.isTrue(m1294 is F1294);
+ Expect.isTrue(m1294 is core.List<core.int> Function() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1294) is F1294);
+ // In checked mode, verifies the type.
+ x1294 = m1294;
+ l1294 = m1294;
+ x1294 = confuse(m1294);
+ l1294 = confuse(m1294);
+
+ }
+
+ void testF1394() {
+ // List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1394 is F1394);
+ Expect.isTrue(confuse(f1394) is F1394);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>() l1394;
+ // The static function f1394 sets `T` to `int`.
+ if (!tIsBool) {
+ x1394 = f1394 as dynamic;
+ l1394 = f1394 as dynamic;
+ x1394 = confuse(f1394);
+ l1394 = confuse(f1394);
+ }
+
+ Expect.isTrue(m1394 is F1394);
+ Expect.isTrue(m1394 is List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1394) is F1394);
+ // In checked mode, verifies the type.
+ x1394 = m1394;
+ l1394 = m1394;
+ x1394 = confuse(m1394);
+ l1394 = confuse(m1394);
+ if (!tIsBool) {
+ Expect.isTrue(f1394 is F1394<int>);
+ Expect.isFalse(f1394 is F1394<bool>);
+ Expect.isTrue(confuse(f1394) is F1394<int>);
+ Expect.isFalse(confuse(f1394) is F1394<bool>);
+ Expect.equals(tIsDynamic, m1394 is F1394<bool>);
+ Expect.equals(tIsDynamic, confuse(m1394) is F1394<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1394 = (f1394 as dynamic); });
+ Expect.throws(() { x1394 = confuse(f1394); });
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>() l1394;
+ Expect.throws(() { l1394 = (f1394 as dynamic); });
+ Expect.throws(() { l1394 = confuse(f1394); });
+ }
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>() l1394 = m1394;
+ // In checked mode, verifies the type.
+ x1394 = m1394;
+ x1394 = confuse(m1394);
+ }
+ }
+
+ void testF1494() {
+ // List<T> Function([List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f1494 is F1494);
+ Expect.isTrue(confuse(f1494) is F1494);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x1]) Function<B extends core.int>() l1494;
+ // The static function f1494 sets `T` to `int`.
+ if (!tIsBool) {
+ x1494 = f1494 as dynamic;
+ l1494 = f1494 as dynamic;
+ x1494 = confuse(f1494);
+ l1494 = confuse(f1494);
+ }
+
+ Expect.isTrue(m1494 is F1494);
+ Expect.isTrue(m1494 is List<T> Function([List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1494) is F1494);
+ // In checked mode, verifies the type.
+ x1494 = m1494;
+ l1494 = m1494;
+ x1494 = confuse(m1494);
+ l1494 = confuse(m1494);
+ if (!tIsBool) {
+ Expect.isTrue(f1494 is F1494<int>);
+ Expect.isFalse(f1494 is F1494<bool>);
+ Expect.isTrue(confuse(f1494) is F1494<int>);
+ Expect.isFalse(confuse(f1494) is F1494<bool>);
+ Expect.equals(tIsDynamic, m1494 is F1494<bool>);
+ Expect.equals(tIsDynamic, confuse(m1494) is F1494<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1494 = (f1494 as dynamic); });
+ Expect.throws(() { x1494 = confuse(f1494); });
+ List<T> Function([List<T> x1]) Function<B extends core.int>() l1494;
+ Expect.throws(() { l1494 = (f1494 as dynamic); });
+ Expect.throws(() { l1494 = confuse(f1494); });
+ }
+ List<T> Function([List<T> x1]) Function<B extends core.int>() l1494 = m1494;
+ // In checked mode, verifies the type.
+ x1494 = m1494;
+ x1494 = confuse(m1494);
+ }
+ }
+
+ void testF1594() {
+ // Function(int x, [Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f1594 is F1594);
+ Expect.isTrue(confuse(f1594) is F1594);
+ // In checked mode, verifies the type.
+ Function(int x, [Function x1]) Function<B extends core.int>() l1594;
+ // The static function f1594 sets `T` to `int`.
+ if (!tIsBool) {
+ x1594 = f1594 as dynamic;
+ l1594 = f1594 as dynamic;
+ x1594 = confuse(f1594);
+ l1594 = confuse(f1594);
+ }
+
+ Expect.isTrue(m1594 is F1594);
+ Expect.isTrue(m1594 is Function(int x, [Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1594) is F1594);
+ // In checked mode, verifies the type.
+ x1594 = m1594;
+ l1594 = m1594;
+ x1594 = confuse(m1594);
+ l1594 = confuse(m1594);
+
+ }
+
+ void testF1694() {
+ // Function(int y, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f1694 is F1694);
+ Expect.isTrue(confuse(f1694) is F1694);
+ // In checked mode, verifies the type.
+ Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l1694;
+ // The static function f1694 sets `T` to `int`.
+ if (!tIsBool) {
+ x1694 = f1694 as dynamic;
+ l1694 = f1694 as dynamic;
+ x1694 = confuse(f1694);
+ l1694 = confuse(f1694);
+ }
+
+ Expect.isTrue(m1694 is F1694);
+ Expect.isTrue(m1694 is Function(int y, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1694) is F1694);
+ // In checked mode, verifies the type.
+ x1694 = m1694;
+ l1694 = m1694;
+ x1694 = confuse(m1694);
+ l1694 = confuse(m1694);
+
+ }
+
+ void testF1794() {
+ // Function Function<A>(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1794 is F1794);
+ Expect.isTrue(confuse(f1794) is F1794);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<T> x) Function<B extends core.int>() l1794;
+ // The static function f1794 sets `T` to `int`.
+ if (!tIsBool) {
+ x1794 = f1794 as dynamic;
+ l1794 = f1794 as dynamic;
+ x1794 = confuse(f1794);
+ l1794 = confuse(f1794);
+ }
+
+ Expect.isTrue(m1794 is F1794);
+ Expect.isTrue(m1794 is Function Function<A>(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1794) is F1794);
+ // In checked mode, verifies the type.
+ x1794 = m1794;
+ l1794 = m1794;
+ x1794 = confuse(m1794);
+ l1794 = confuse(m1794);
+ if (!tIsBool) {
+ Expect.isTrue(f1794 is F1794<int>);
+ Expect.isFalse(f1794 is F1794<bool>);
+ Expect.isTrue(confuse(f1794) is F1794<int>);
+ Expect.isFalse(confuse(f1794) is F1794<bool>);
+ Expect.equals(tIsDynamic, m1794 is F1794<bool>);
+ Expect.equals(tIsDynamic, confuse(m1794) is F1794<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1794 = (f1794 as dynamic); });
+ Expect.throws(() { x1794 = confuse(f1794); });
+ Function Function<A>(List<T> x) Function<B extends core.int>() l1794;
+ Expect.throws(() { l1794 = (f1794 as dynamic); });
+ Expect.throws(() { l1794 = confuse(f1794); });
+ }
+ Function Function<A>(List<T> x) Function<B extends core.int>() l1794 = m1794;
+ // In checked mode, verifies the type.
+ x1794 = m1794;
+ x1794 = confuse(m1794);
+ }
+ }
+
+ void testF1894() {
+ // List<T> Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1894 is F1894);
+ Expect.isTrue(confuse(f1894) is F1894);
+ // In checked mode, verifies the type.
+ List<T> Function<A>() Function<B extends core.int>() l1894;
+ // The static function f1894 sets `T` to `int`.
+ if (!tIsBool) {
+ x1894 = f1894 as dynamic;
+ l1894 = f1894 as dynamic;
+ x1894 = confuse(f1894);
+ l1894 = confuse(f1894);
+ }
+
+ Expect.isTrue(m1894 is F1894);
+ Expect.isTrue(m1894 is List<T> Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1894) is F1894);
+ // In checked mode, verifies the type.
+ x1894 = m1894;
+ l1894 = m1894;
+ x1894 = confuse(m1894);
+ l1894 = confuse(m1894);
+ if (!tIsBool) {
+ Expect.isTrue(f1894 is F1894<int>);
+ Expect.isFalse(f1894 is F1894<bool>);
+ Expect.isTrue(confuse(f1894) is F1894<int>);
+ Expect.isFalse(confuse(f1894) is F1894<bool>);
+ Expect.equals(tIsDynamic, m1894 is F1894<bool>);
+ Expect.equals(tIsDynamic, confuse(m1894) is F1894<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1894 = (f1894 as dynamic); });
+ Expect.throws(() { x1894 = confuse(f1894); });
+ List<T> Function<A>() Function<B extends core.int>() l1894;
+ Expect.throws(() { l1894 = (f1894 as dynamic); });
+ Expect.throws(() { l1894 = confuse(f1894); });
+ }
+ List<T> Function<A>() Function<B extends core.int>() l1894 = m1894;
+ // In checked mode, verifies the type.
+ x1894 = m1894;
+ x1894 = confuse(m1894);
+ }
+ }
+
+ void testF1994() {
+ // List<A> Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1994 is F1994);
+ Expect.isTrue(confuse(f1994) is F1994);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(A x) Function<B extends core.int>() l1994;
+ // The static function f1994 sets `T` to `int`.
+ if (!tIsBool) {
+ x1994 = f1994 as dynamic;
+ l1994 = f1994 as dynamic;
+ x1994 = confuse(f1994);
+ l1994 = confuse(f1994);
+ }
+
+ Expect.isTrue(m1994 is F1994);
+ Expect.isTrue(m1994 is List<A> Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1994) is F1994);
+ // In checked mode, verifies the type.
+ x1994 = m1994;
+ l1994 = m1994;
+ x1994 = confuse(m1994);
+ l1994 = confuse(m1994);
+
+ }
+
+
+}
+
+class C95<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x1, [core.List<core.int> x2]) x95;
+ core.List<core.int> Function([List<Function> x1]) x195;
+ Function(Function x0) x295;
+ List<A> Function<A>(core.List<core.int> x) x395;
+ int Function([List<Function> x]) Function<B extends core.int>(int x) x495;
+ int Function(List<T> x1) Function<B extends core.int>(int x) x595;
+ Function Function(int x2, [Function x3]) Function<B extends core.int>(int x) x695;
+ Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) x795;
+ List<Function> Function(Function x) Function<B extends core.int>(int x) x895;
+ List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) x995;
+ core.List<core.int> Function([int x1]) Function<B extends core.int>(int x) x1095;
+ core.List<core.int> Function({List<Function> x}) Function<B extends core.int>(int x) x1195;
+ core.List<core.int> Function() Function<B extends core.int>(int x) x1295;
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) x1395;
+ List<T> Function([List<T> x1]) Function<B extends core.int>(int x) x1495;
+ Function(int x, [Function x1]) Function<B extends core.int>(int x) x1595;
+ Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) x1695;
+ Function Function<A>(List<T> x) Function<B extends core.int>(int x) x1795;
+ List<T> Function<A>() Function<B extends core.int>(int x) x1895;
+ List<A> Function<A>(A x) Function<B extends core.int>(int x) x1995;
+
+
+ C95({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m95(int x0, [core.List<core.int> x1]) => null;
+ core.List<core.int> m195([List<Function> x0]) => null;
+ m295(Function x0) => null;
+ List<A> m395<A>(core.List<core.int> x) => null;
+ int Function([List<Function> x]) m495<B extends core.int>(int x) => null;
+ int Function(List<T> x0) m595<B extends core.int>(int x) => null;
+ Function Function(int x0, [Function x1]) m695<B extends core.int>(int x) => null;
+ Function Function(int x0, {core.List<core.int> x}) m795<B extends core.int>(int x) => null;
+ List<Function> Function(Function x) m895<B extends core.int>(int x) => null;
+ List<Function> Function(int y, [core.List<core.int> x]) m995<B extends core.int>(int x) => null;
+ core.List<core.int> Function([int x0]) m1095<B extends core.int>(int x) => null;
+ core.List<core.int> Function({List<Function> x}) m1195<B extends core.int>(int x) => null;
+ core.List<core.int> Function() m1295<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [List<Function> x]) m1395<B extends core.int>(int x) => null;
+ List<T> Function([List<T> x0]) m1495<B extends core.int>(int x) => null;
+ Function(int x, [Function x0]) m1595<B extends core.int>(int x) => null;
+ Function(int y, {core.List<core.int> x}) m1695<B extends core.int>(int x) => null;
+ Function Function<A>(List<T> x) m1795<B extends core.int>(int x) => null;
+ List<T> Function<A>() m1895<B extends core.int>(int x) => null;
+ List<A> Function<A>(A x) m1995<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF95();
+ testF195();
+ testF295();
+ testF395();
+ testF495();
+ testF595();
+ testF695();
+ testF795();
+ testF895();
+ testF995();
+ testF1095();
+ testF1195();
+ testF1295();
+ testF1395();
+ testF1495();
+ testF1595();
+ testF1695();
+ testF1795();
+ testF1895();
+ testF1995();
+ }
+
+ void testF95() {
+ // Function Function(int x1, [core.List<core.int> x2])
+ Expect.isTrue(f95 is F95);
+ Expect.isTrue(confuse(f95) is F95);
+ // In checked mode, verifies the type.
+ Function Function(int x1, [core.List<core.int> x2]) l95;
+ // The static function f95 sets `T` to `int`.
+ if (!tIsBool) {
+ x95 = f95 as dynamic;
+ l95 = f95 as dynamic;
+ x95 = confuse(f95);
+ l95 = confuse(f95);
+ }
+
+ Expect.isTrue(m95 is F95);
+ Expect.isTrue(m95 is Function Function(int x1, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m95) is F95);
+ // In checked mode, verifies the type.
+ x95 = m95;
+ l95 = m95;
+ x95 = confuse(m95);
+ l95 = confuse(m95);
+
+ }
+
+ void testF195() {
+ // core.List<core.int> Function([List<Function> x1])
+ Expect.isTrue(f195 is F195);
+ Expect.isTrue(confuse(f195) is F195);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([List<Function> x1]) l195;
+ // The static function f195 sets `T` to `int`.
+ if (!tIsBool) {
+ x195 = f195 as dynamic;
+ l195 = f195 as dynamic;
+ x195 = confuse(f195);
+ l195 = confuse(f195);
+ }
+
+ Expect.isTrue(m195 is F195);
+ Expect.isTrue(m195 is core.List<core.int> Function([List<Function> x1]));
+ Expect.isTrue(confuse(m195) is F195);
+ // In checked mode, verifies the type.
+ x195 = m195;
+ l195 = m195;
+ x195 = confuse(m195);
+ l195 = confuse(m195);
+
+ }
+
+ void testF295() {
+ // Function(Function x0)
+ Expect.isTrue(f295 is F295);
+ Expect.isTrue(confuse(f295) is F295);
+ // In checked mode, verifies the type.
+ Function(Function x0) l295;
+ // The static function f295 sets `T` to `int`.
+ if (!tIsBool) {
+ x295 = f295 as dynamic;
+ l295 = f295 as dynamic;
+ x295 = confuse(f295);
+ l295 = confuse(f295);
+ }
+
+ Expect.isTrue(m295 is F295);
+ Expect.isTrue(m295 is Function(Function x0));
+ Expect.isTrue(confuse(m295) is F295);
+ // In checked mode, verifies the type.
+ x295 = m295;
+ l295 = m295;
+ x295 = confuse(m295);
+ l295 = confuse(m295);
+
+ }
+
+ void testF395() {
+ // List<A> Function<A>(core.List<core.int> x)
+ Expect.isTrue(f395 is F395);
+ Expect.isTrue(confuse(f395) is F395);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(core.List<core.int> x) l395;
+ // The static function f395 sets `T` to `int`.
+ if (!tIsBool) {
+ x395 = f395 as dynamic;
+ l395 = f395 as dynamic;
+ x395 = confuse(f395);
+ l395 = confuse(f395);
+ }
+
+ Expect.isTrue(m395 is F395);
+ Expect.isTrue(m395 is List<A> Function<A>(core.List<core.int> x));
+ Expect.isTrue(confuse(m395) is F395);
+ // In checked mode, verifies the type.
+ x395 = m395;
+ l395 = m395;
+ x395 = confuse(m395);
+ l395 = confuse(m395);
+
+ }
+
+ void testF495() {
+ // int Function([List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f495 is F495);
+ Expect.isTrue(confuse(f495) is F495);
+ // In checked mode, verifies the type.
+ int Function([List<Function> x]) Function<B extends core.int>(int x) l495;
+ // The static function f495 sets `T` to `int`.
+ if (!tIsBool) {
+ x495 = f495 as dynamic;
+ l495 = f495 as dynamic;
+ x495 = confuse(f495);
+ l495 = confuse(f495);
+ }
+
+ Expect.isTrue(m495 is F495);
+ Expect.isTrue(m495 is int Function([List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m495) is F495);
+ // In checked mode, verifies the type.
+ x495 = m495;
+ l495 = m495;
+ x495 = confuse(m495);
+ l495 = confuse(m495);
+
+ }
+
+ void testF595() {
+ // int Function(List<T> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f595 is F595);
+ Expect.isTrue(confuse(f595) is F595);
+ // In checked mode, verifies the type.
+ int Function(List<T> x1) Function<B extends core.int>(int x) l595;
+ // The static function f595 sets `T` to `int`.
+ if (!tIsBool) {
+ x595 = f595 as dynamic;
+ l595 = f595 as dynamic;
+ x595 = confuse(f595);
+ l595 = confuse(f595);
+ }
+
+ Expect.isTrue(m595 is F595);
+ Expect.isTrue(m595 is int Function(List<T> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m595) is F595);
+ // In checked mode, verifies the type.
+ x595 = m595;
+ l595 = m595;
+ x595 = confuse(m595);
+ l595 = confuse(m595);
+ if (!tIsBool) {
+ Expect.isTrue(f595 is F595<int>);
+ Expect.isFalse(f595 is F595<bool>);
+ Expect.isTrue(confuse(f595) is F595<int>);
+ Expect.isFalse(confuse(f595) is F595<bool>);
+ Expect.equals(tIsDynamic, m595 is F595<bool>);
+ Expect.equals(tIsDynamic, confuse(m595) is F595<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x595 = (f595 as dynamic); });
+ Expect.throws(() { x595 = confuse(f595); });
+ int Function(List<T> x1) Function<B extends core.int>(int x) l595;
+ Expect.throws(() { l595 = (f595 as dynamic); });
+ Expect.throws(() { l595 = confuse(f595); });
+ }
+ int Function(List<T> x1) Function<B extends core.int>(int x) l595 = m595;
+ // In checked mode, verifies the type.
+ x595 = m595;
+ x595 = confuse(m595);
+ }
+ }
+
+ void testF695() {
+ // Function Function(int x2, [Function x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f695 is F695);
+ Expect.isTrue(confuse(f695) is F695);
+ // In checked mode, verifies the type.
+ Function Function(int x2, [Function x3]) Function<B extends core.int>(int x) l695;
+ // The static function f695 sets `T` to `int`.
+ if (!tIsBool) {
+ x695 = f695 as dynamic;
+ l695 = f695 as dynamic;
+ x695 = confuse(f695);
+ l695 = confuse(f695);
+ }
+
+ Expect.isTrue(m695 is F695);
+ Expect.isTrue(m695 is Function Function(int x2, [Function x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m695) is F695);
+ // In checked mode, verifies the type.
+ x695 = m695;
+ l695 = m695;
+ x695 = confuse(m695);
+ l695 = confuse(m695);
+
+ }
+
+ void testF795() {
+ // Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f795 is F795);
+ Expect.isTrue(confuse(f795) is F795);
+ // In checked mode, verifies the type.
+ Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x) l795;
+ // The static function f795 sets `T` to `int`.
+ if (!tIsBool) {
+ x795 = f795 as dynamic;
+ l795 = f795 as dynamic;
+ x795 = confuse(f795);
+ l795 = confuse(f795);
+ }
+
+ Expect.isTrue(m795 is F795);
+ Expect.isTrue(m795 is Function Function(int x1, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m795) is F795);
+ // In checked mode, verifies the type.
+ x795 = m795;
+ l795 = m795;
+ x795 = confuse(m795);
+ l795 = confuse(m795);
+
+ }
+
+ void testF895() {
+ // List<Function> Function(Function x) Function<B extends core.int>(int x)
+ Expect.isTrue(f895 is F895);
+ Expect.isTrue(confuse(f895) is F895);
+ // In checked mode, verifies the type.
+ List<Function> Function(Function x) Function<B extends core.int>(int x) l895;
+ // The static function f895 sets `T` to `int`.
+ if (!tIsBool) {
+ x895 = f895 as dynamic;
+ l895 = f895 as dynamic;
+ x895 = confuse(f895);
+ l895 = confuse(f895);
+ }
+
+ Expect.isTrue(m895 is F895);
+ Expect.isTrue(m895 is List<Function> Function(Function x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m895) is F895);
+ // In checked mode, verifies the type.
+ x895 = m895;
+ l895 = m895;
+ x895 = confuse(m895);
+ l895 = confuse(m895);
+
+ }
+
+ void testF995() {
+ // List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f995 is F995);
+ Expect.isTrue(confuse(f995) is F995);
+ // In checked mode, verifies the type.
+ List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x) l995;
+ // The static function f995 sets `T` to `int`.
+ if (!tIsBool) {
+ x995 = f995 as dynamic;
+ l995 = f995 as dynamic;
+ x995 = confuse(f995);
+ l995 = confuse(f995);
+ }
+
+ Expect.isTrue(m995 is F995);
+ Expect.isTrue(m995 is List<Function> Function(int y, [core.List<core.int> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m995) is F995);
+ // In checked mode, verifies the type.
+ x995 = m995;
+ l995 = m995;
+ x995 = confuse(m995);
+ l995 = confuse(m995);
+
+ }
+
+ void testF1095() {
+ // core.List<core.int> Function([int x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1095 is F1095);
+ Expect.isTrue(confuse(f1095) is F1095);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function([int x1]) Function<B extends core.int>(int x) l1095;
+ // The static function f1095 sets `T` to `int`.
+ if (!tIsBool) {
+ x1095 = f1095 as dynamic;
+ l1095 = f1095 as dynamic;
+ x1095 = confuse(f1095);
+ l1095 = confuse(f1095);
+ }
+
+ Expect.isTrue(m1095 is F1095);
+ Expect.isTrue(m1095 is core.List<core.int> Function([int x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1095) is F1095);
+ // In checked mode, verifies the type.
+ x1095 = m1095;
+ l1095 = m1095;
+ x1095 = confuse(m1095);
+ l1095 = confuse(m1095);
+
+ }
+
+ void testF1195() {
+ // core.List<core.int> Function({List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1195 is F1195);
+ Expect.isTrue(confuse(f1195) is F1195);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<Function> x}) Function<B extends core.int>(int x) l1195;
+ // The static function f1195 sets `T` to `int`.
+ if (!tIsBool) {
+ x1195 = f1195 as dynamic;
+ l1195 = f1195 as dynamic;
+ x1195 = confuse(f1195);
+ l1195 = confuse(f1195);
+ }
+
+ Expect.isTrue(m1195 is F1195);
+ Expect.isTrue(m1195 is core.List<core.int> Function({List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1195) is F1195);
+ // In checked mode, verifies the type.
+ x1195 = m1195;
+ l1195 = m1195;
+ x1195 = confuse(m1195);
+ l1195 = confuse(m1195);
+
+ }
+
+ void testF1295() {
+ // core.List<core.int> Function() Function<B extends core.int>(int x)
+ Expect.isTrue(f1295 is F1295);
+ Expect.isTrue(confuse(f1295) is F1295);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function() Function<B extends core.int>(int x) l1295;
+ // The static function f1295 sets `T` to `int`.
+ if (!tIsBool) {
+ x1295 = f1295 as dynamic;
+ l1295 = f1295 as dynamic;
+ x1295 = confuse(f1295);
+ l1295 = confuse(f1295);
+ }
+
+ Expect.isTrue(m1295 is F1295);
+ Expect.isTrue(m1295 is core.List<core.int> Function() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1295) is F1295);
+ // In checked mode, verifies the type.
+ x1295 = m1295;
+ l1295 = m1295;
+ x1295 = confuse(m1295);
+ l1295 = confuse(m1295);
+
+ }
+
+ void testF1395() {
+ // List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1395 is F1395);
+ Expect.isTrue(confuse(f1395) is F1395);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l1395;
+ // The static function f1395 sets `T` to `int`.
+ if (!tIsBool) {
+ x1395 = f1395 as dynamic;
+ l1395 = f1395 as dynamic;
+ x1395 = confuse(f1395);
+ l1395 = confuse(f1395);
+ }
+
+ Expect.isTrue(m1395 is F1395);
+ Expect.isTrue(m1395 is List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1395) is F1395);
+ // In checked mode, verifies the type.
+ x1395 = m1395;
+ l1395 = m1395;
+ x1395 = confuse(m1395);
+ l1395 = confuse(m1395);
+ if (!tIsBool) {
+ Expect.isTrue(f1395 is F1395<int>);
+ Expect.isFalse(f1395 is F1395<bool>);
+ Expect.isTrue(confuse(f1395) is F1395<int>);
+ Expect.isFalse(confuse(f1395) is F1395<bool>);
+ Expect.equals(tIsDynamic, m1395 is F1395<bool>);
+ Expect.equals(tIsDynamic, confuse(m1395) is F1395<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1395 = (f1395 as dynamic); });
+ Expect.throws(() { x1395 = confuse(f1395); });
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l1395;
+ Expect.throws(() { l1395 = (f1395 as dynamic); });
+ Expect.throws(() { l1395 = confuse(f1395); });
+ }
+ List<T> Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l1395 = m1395;
+ // In checked mode, verifies the type.
+ x1395 = m1395;
+ x1395 = confuse(m1395);
+ }
+ }
+
+ void testF1495() {
+ // List<T> Function([List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1495 is F1495);
+ Expect.isTrue(confuse(f1495) is F1495);
+ // In checked mode, verifies the type.
+ List<T> Function([List<T> x1]) Function<B extends core.int>(int x) l1495;
+ // The static function f1495 sets `T` to `int`.
+ if (!tIsBool) {
+ x1495 = f1495 as dynamic;
+ l1495 = f1495 as dynamic;
+ x1495 = confuse(f1495);
+ l1495 = confuse(f1495);
+ }
+
+ Expect.isTrue(m1495 is F1495);
+ Expect.isTrue(m1495 is List<T> Function([List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1495) is F1495);
+ // In checked mode, verifies the type.
+ x1495 = m1495;
+ l1495 = m1495;
+ x1495 = confuse(m1495);
+ l1495 = confuse(m1495);
+ if (!tIsBool) {
+ Expect.isTrue(f1495 is F1495<int>);
+ Expect.isFalse(f1495 is F1495<bool>);
+ Expect.isTrue(confuse(f1495) is F1495<int>);
+ Expect.isFalse(confuse(f1495) is F1495<bool>);
+ Expect.equals(tIsDynamic, m1495 is F1495<bool>);
+ Expect.equals(tIsDynamic, confuse(m1495) is F1495<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1495 = (f1495 as dynamic); });
+ Expect.throws(() { x1495 = confuse(f1495); });
+ List<T> Function([List<T> x1]) Function<B extends core.int>(int x) l1495;
+ Expect.throws(() { l1495 = (f1495 as dynamic); });
+ Expect.throws(() { l1495 = confuse(f1495); });
+ }
+ List<T> Function([List<T> x1]) Function<B extends core.int>(int x) l1495 = m1495;
+ // In checked mode, verifies the type.
+ x1495 = m1495;
+ x1495 = confuse(m1495);
+ }
+ }
+
+ void testF1595() {
+ // Function(int x, [Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1595 is F1595);
+ Expect.isTrue(confuse(f1595) is F1595);
+ // In checked mode, verifies the type.
+ Function(int x, [Function x1]) Function<B extends core.int>(int x) l1595;
+ // The static function f1595 sets `T` to `int`.
+ if (!tIsBool) {
+ x1595 = f1595 as dynamic;
+ l1595 = f1595 as dynamic;
+ x1595 = confuse(f1595);
+ l1595 = confuse(f1595);
+ }
+
+ Expect.isTrue(m1595 is F1595);
+ Expect.isTrue(m1595 is Function(int x, [Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1595) is F1595);
+ // In checked mode, verifies the type.
+ x1595 = m1595;
+ l1595 = m1595;
+ x1595 = confuse(m1595);
+ l1595 = confuse(m1595);
+
+ }
+
+ void testF1695() {
+ // Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1695 is F1695);
+ Expect.isTrue(confuse(f1695) is F1695);
+ // In checked mode, verifies the type.
+ Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l1695;
+ // The static function f1695 sets `T` to `int`.
+ if (!tIsBool) {
+ x1695 = f1695 as dynamic;
+ l1695 = f1695 as dynamic;
+ x1695 = confuse(f1695);
+ l1695 = confuse(f1695);
+ }
+
+ Expect.isTrue(m1695 is F1695);
+ Expect.isTrue(m1695 is Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1695) is F1695);
+ // In checked mode, verifies the type.
+ x1695 = m1695;
+ l1695 = m1695;
+ x1695 = confuse(m1695);
+ l1695 = confuse(m1695);
+
+ }
+
+ void testF1795() {
+ // Function Function<A>(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1795 is F1795);
+ Expect.isTrue(confuse(f1795) is F1795);
+ // In checked mode, verifies the type.
+ Function Function<A>(List<T> x) Function<B extends core.int>(int x) l1795;
+ // The static function f1795 sets `T` to `int`.
+ if (!tIsBool) {
+ x1795 = f1795 as dynamic;
+ l1795 = f1795 as dynamic;
+ x1795 = confuse(f1795);
+ l1795 = confuse(f1795);
+ }
+
+ Expect.isTrue(m1795 is F1795);
+ Expect.isTrue(m1795 is Function Function<A>(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1795) is F1795);
+ // In checked mode, verifies the type.
+ x1795 = m1795;
+ l1795 = m1795;
+ x1795 = confuse(m1795);
+ l1795 = confuse(m1795);
+ if (!tIsBool) {
+ Expect.isTrue(f1795 is F1795<int>);
+ Expect.isFalse(f1795 is F1795<bool>);
+ Expect.isTrue(confuse(f1795) is F1795<int>);
+ Expect.isFalse(confuse(f1795) is F1795<bool>);
+ Expect.equals(tIsDynamic, m1795 is F1795<bool>);
+ Expect.equals(tIsDynamic, confuse(m1795) is F1795<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1795 = (f1795 as dynamic); });
+ Expect.throws(() { x1795 = confuse(f1795); });
+ Function Function<A>(List<T> x) Function<B extends core.int>(int x) l1795;
+ Expect.throws(() { l1795 = (f1795 as dynamic); });
+ Expect.throws(() { l1795 = confuse(f1795); });
+ }
+ Function Function<A>(List<T> x) Function<B extends core.int>(int x) l1795 = m1795;
+ // In checked mode, verifies the type.
+ x1795 = m1795;
+ x1795 = confuse(m1795);
+ }
+ }
+
+ void testF1895() {
+ // List<T> Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1895 is F1895);
+ Expect.isTrue(confuse(f1895) is F1895);
+ // In checked mode, verifies the type.
+ List<T> Function<A>() Function<B extends core.int>(int x) l1895;
+ // The static function f1895 sets `T` to `int`.
+ if (!tIsBool) {
+ x1895 = f1895 as dynamic;
+ l1895 = f1895 as dynamic;
+ x1895 = confuse(f1895);
+ l1895 = confuse(f1895);
+ }
+
+ Expect.isTrue(m1895 is F1895);
+ Expect.isTrue(m1895 is List<T> Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1895) is F1895);
+ // In checked mode, verifies the type.
+ x1895 = m1895;
+ l1895 = m1895;
+ x1895 = confuse(m1895);
+ l1895 = confuse(m1895);
+ if (!tIsBool) {
+ Expect.isTrue(f1895 is F1895<int>);
+ Expect.isFalse(f1895 is F1895<bool>);
+ Expect.isTrue(confuse(f1895) is F1895<int>);
+ Expect.isFalse(confuse(f1895) is F1895<bool>);
+ Expect.equals(tIsDynamic, m1895 is F1895<bool>);
+ Expect.equals(tIsDynamic, confuse(m1895) is F1895<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1895 = (f1895 as dynamic); });
+ Expect.throws(() { x1895 = confuse(f1895); });
+ List<T> Function<A>() Function<B extends core.int>(int x) l1895;
+ Expect.throws(() { l1895 = (f1895 as dynamic); });
+ Expect.throws(() { l1895 = confuse(f1895); });
+ }
+ List<T> Function<A>() Function<B extends core.int>(int x) l1895 = m1895;
+ // In checked mode, verifies the type.
+ x1895 = m1895;
+ x1895 = confuse(m1895);
+ }
+ }
+
+ void testF1995() {
+ // List<A> Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1995 is F1995);
+ Expect.isTrue(confuse(f1995) is F1995);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(A x) Function<B extends core.int>(int x) l1995;
+ // The static function f1995 sets `T` to `int`.
+ if (!tIsBool) {
+ x1995 = f1995 as dynamic;
+ l1995 = f1995 as dynamic;
+ x1995 = confuse(f1995);
+ l1995 = confuse(f1995);
+ }
+
+ Expect.isTrue(m1995 is F1995);
+ Expect.isTrue(m1995 is List<A> Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1995) is F1995);
+ // In checked mode, verifies the type.
+ x1995 = m1995;
+ l1995 = m1995;
+ x1995 = confuse(m1995);
+ l1995 = confuse(m1995);
+
+ }
+
+
+}
+
+class C96<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x, [core.List<core.int> x2]) x96;
+ core.List<core.int> Function(int x1, [List<Function> x2]) x196;
+ Function([Function x1]) x296;
+ List<A> Function<A>(List<T> x) x396;
+ int Function(int x0, [List<Function> x]) Function() x496;
+ int Function([List<T> x1]) Function() x596;
+ Function Function(int x, [Function x2]) Function() x696;
+ Function Function(int y, {core.List<core.int> x}) Function() x796;
+ List<Function> Function([Function x]) Function() x896;
+ List<Function> Function(core.List<core.int> x0) Function() x996;
+ core.List<core.int> Function(int x1, [int x2]) Function() x1096;
+ core.List<core.int> Function(int x0, {List<Function> x}) Function() x1196;
+ List<T> Function(int x) Function() x1296;
+ List<T> Function(int y, [List<Function> x]) Function() x1396;
+ List<T> Function(int x1, [List<T> x2]) Function() x1496;
+ Function({Function x}) Function() x1596;
+ Function(List<T> x) Function() x1696;
+ Function Function<A>() Function() x1796;
+ List<T> Function<A>(A x) Function() x1896;
+ List<A> Function<A>(List<A> x) Function() x1996;
+
+
+ C96({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m96(int x, [core.List<core.int> x0]) => null;
+ core.List<core.int> m196(int x0, [List<Function> x1]) => null;
+ m296([Function x0]) => null;
+ List<A> m396<A>(List<T> x) => null;
+ int Function(int x0, [List<Function> x]) m496() => null;
+ int Function([List<T> x0]) m596() => null;
+ Function Function(int x, [Function x0]) m696() => null;
+ Function Function(int y, {core.List<core.int> x}) m796() => null;
+ List<Function> Function([Function x]) m896() => null;
+ List<Function> Function(core.List<core.int> x0) m996() => null;
+ core.List<core.int> Function(int x0, [int x1]) m1096() => null;
+ core.List<core.int> Function(int x0, {List<Function> x}) m1196() => null;
+ List<T> Function(int x) m1296() => null;
+ List<T> Function(int y, [List<Function> x]) m1396() => null;
+ List<T> Function(int x0, [List<T> x1]) m1496() => null;
+ Function({Function x}) m1596() => null;
+ Function(List<T> x) m1696() => null;
+ Function Function<A>() m1796() => null;
+ List<T> Function<A>(A x) m1896() => null;
+ List<A> Function<A>(List<A> x) m1996() => null;
+
+
+ runTests() {
+ testF96();
+ testF196();
+ testF296();
+ testF396();
+ testF496();
+ testF596();
+ testF696();
+ testF796();
+ testF896();
+ testF996();
+ testF1096();
+ testF1196();
+ testF1296();
+ testF1396();
+ testF1496();
+ testF1596();
+ testF1696();
+ testF1796();
+ testF1896();
+ testF1996();
+ }
+
+ void testF96() {
+ // Function Function(int x, [core.List<core.int> x2])
+ Expect.isTrue(f96 is F96);
+ Expect.isTrue(confuse(f96) is F96);
+ // In checked mode, verifies the type.
+ Function Function(int x, [core.List<core.int> x2]) l96;
+ // The static function f96 sets `T` to `int`.
+ if (!tIsBool) {
+ x96 = f96 as dynamic;
+ l96 = f96 as dynamic;
+ x96 = confuse(f96);
+ l96 = confuse(f96);
+ }
+
+ Expect.isTrue(m96 is F96);
+ Expect.isTrue(m96 is Function Function(int x, [core.List<core.int> x2]));
+ Expect.isTrue(confuse(m96) is F96);
+ // In checked mode, verifies the type.
+ x96 = m96;
+ l96 = m96;
+ x96 = confuse(m96);
+ l96 = confuse(m96);
+
+ }
+
+ void testF196() {
+ // core.List<core.int> Function(int x1, [List<Function> x2])
+ Expect.isTrue(f196 is F196);
+ Expect.isTrue(confuse(f196) is F196);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [List<Function> x2]) l196;
+ // The static function f196 sets `T` to `int`.
+ if (!tIsBool) {
+ x196 = f196 as dynamic;
+ l196 = f196 as dynamic;
+ x196 = confuse(f196);
+ l196 = confuse(f196);
+ }
+
+ Expect.isTrue(m196 is F196);
+ Expect.isTrue(m196 is core.List<core.int> Function(int x1, [List<Function> x2]));
+ Expect.isTrue(confuse(m196) is F196);
+ // In checked mode, verifies the type.
+ x196 = m196;
+ l196 = m196;
+ x196 = confuse(m196);
+ l196 = confuse(m196);
+
+ }
+
+ void testF296() {
+ // Function([Function x1])
+ Expect.isTrue(f296 is F296);
+ Expect.isTrue(confuse(f296) is F296);
+ // In checked mode, verifies the type.
+ Function([Function x1]) l296;
+ // The static function f296 sets `T` to `int`.
+ if (!tIsBool) {
+ x296 = f296 as dynamic;
+ l296 = f296 as dynamic;
+ x296 = confuse(f296);
+ l296 = confuse(f296);
+ }
+
+ Expect.isTrue(m296 is F296);
+ Expect.isTrue(m296 is Function([Function x1]));
+ Expect.isTrue(confuse(m296) is F296);
+ // In checked mode, verifies the type.
+ x296 = m296;
+ l296 = m296;
+ x296 = confuse(m296);
+ l296 = confuse(m296);
+
+ }
+
+ void testF396() {
+ // List<A> Function<A>(List<T> x)
+ Expect.isTrue(f396 is F396);
+ Expect.isTrue(confuse(f396) is F396);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<T> x) l396;
+ // The static function f396 sets `T` to `int`.
+ if (!tIsBool) {
+ x396 = f396 as dynamic;
+ l396 = f396 as dynamic;
+ x396 = confuse(f396);
+ l396 = confuse(f396);
+ }
+
+ Expect.isTrue(m396 is F396);
+ Expect.isTrue(m396 is List<A> Function<A>(List<T> x));
+ Expect.isTrue(confuse(m396) is F396);
+ // In checked mode, verifies the type.
+ x396 = m396;
+ l396 = m396;
+ x396 = confuse(m396);
+ l396 = confuse(m396);
+ if (!tIsBool) {
+ Expect.isTrue(f396 is F396<int>);
+ Expect.isFalse(f396 is F396<bool>);
+ Expect.isTrue(confuse(f396) is F396<int>);
+ Expect.isFalse(confuse(f396) is F396<bool>);
+ Expect.equals(tIsDynamic, m396 is F396<bool>);
+ Expect.equals(tIsDynamic, confuse(m396) is F396<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x396 = (f396 as dynamic); });
+ Expect.throws(() { x396 = confuse(f396); });
+ List<A> Function<A>(List<T> x) l396;
+ Expect.throws(() { l396 = (f396 as dynamic); });
+ Expect.throws(() { l396 = confuse(f396); });
+ }
+ List<A> Function<A>(List<T> x) l396 = m396;
+ // In checked mode, verifies the type.
+ x396 = m396;
+ x396 = confuse(m396);
+ }
+ }
+
+ void testF496() {
+ // int Function(int x0, [List<Function> x]) Function()
+ Expect.isTrue(f496 is F496);
+ Expect.isTrue(confuse(f496) is F496);
+ // In checked mode, verifies the type.
+ int Function(int x0, [List<Function> x]) Function() l496;
+ // The static function f496 sets `T` to `int`.
+ if (!tIsBool) {
+ x496 = f496 as dynamic;
+ l496 = f496 as dynamic;
+ x496 = confuse(f496);
+ l496 = confuse(f496);
+ }
+
+ Expect.isTrue(m496 is F496);
+ Expect.isTrue(m496 is int Function(int x0, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m496) is F496);
+ // In checked mode, verifies the type.
+ x496 = m496;
+ l496 = m496;
+ x496 = confuse(m496);
+ l496 = confuse(m496);
+
+ }
+
+ void testF596() {
+ // int Function([List<T> x1]) Function()
+ Expect.isTrue(f596 is F596);
+ Expect.isTrue(confuse(f596) is F596);
+ // In checked mode, verifies the type.
+ int Function([List<T> x1]) Function() l596;
+ // The static function f596 sets `T` to `int`.
+ if (!tIsBool) {
+ x596 = f596 as dynamic;
+ l596 = f596 as dynamic;
+ x596 = confuse(f596);
+ l596 = confuse(f596);
+ }
+
+ Expect.isTrue(m596 is F596);
+ Expect.isTrue(m596 is int Function([List<T> x1]) Function());
+ Expect.isTrue(confuse(m596) is F596);
+ // In checked mode, verifies the type.
+ x596 = m596;
+ l596 = m596;
+ x596 = confuse(m596);
+ l596 = confuse(m596);
+ if (!tIsBool) {
+ Expect.isTrue(f596 is F596<int>);
+ Expect.isFalse(f596 is F596<bool>);
+ Expect.isTrue(confuse(f596) is F596<int>);
+ Expect.isFalse(confuse(f596) is F596<bool>);
+ Expect.equals(tIsDynamic, m596 is F596<bool>);
+ Expect.equals(tIsDynamic, confuse(m596) is F596<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x596 = (f596 as dynamic); });
+ Expect.throws(() { x596 = confuse(f596); });
+ int Function([List<T> x1]) Function() l596;
+ Expect.throws(() { l596 = (f596 as dynamic); });
+ Expect.throws(() { l596 = confuse(f596); });
+ }
+ int Function([List<T> x1]) Function() l596 = m596;
+ // In checked mode, verifies the type.
+ x596 = m596;
+ x596 = confuse(m596);
+ }
+ }
+
+ void testF696() {
+ // Function Function(int x, [Function x2]) Function()
+ Expect.isTrue(f696 is F696);
+ Expect.isTrue(confuse(f696) is F696);
+ // In checked mode, verifies the type.
+ Function Function(int x, [Function x2]) Function() l696;
+ // The static function f696 sets `T` to `int`.
+ if (!tIsBool) {
+ x696 = f696 as dynamic;
+ l696 = f696 as dynamic;
+ x696 = confuse(f696);
+ l696 = confuse(f696);
+ }
+
+ Expect.isTrue(m696 is F696);
+ Expect.isTrue(m696 is Function Function(int x, [Function x2]) Function());
+ Expect.isTrue(confuse(m696) is F696);
+ // In checked mode, verifies the type.
+ x696 = m696;
+ l696 = m696;
+ x696 = confuse(m696);
+ l696 = confuse(m696);
+
+ }
+
+ void testF796() {
+ // Function Function(int y, {core.List<core.int> x}) Function()
+ Expect.isTrue(f796 is F796);
+ Expect.isTrue(confuse(f796) is F796);
+ // In checked mode, verifies the type.
+ Function Function(int y, {core.List<core.int> x}) Function() l796;
+ // The static function f796 sets `T` to `int`.
+ if (!tIsBool) {
+ x796 = f796 as dynamic;
+ l796 = f796 as dynamic;
+ x796 = confuse(f796);
+ l796 = confuse(f796);
+ }
+
+ Expect.isTrue(m796 is F796);
+ Expect.isTrue(m796 is Function Function(int y, {core.List<core.int> x}) Function());
+ Expect.isTrue(confuse(m796) is F796);
+ // In checked mode, verifies the type.
+ x796 = m796;
+ l796 = m796;
+ x796 = confuse(m796);
+ l796 = confuse(m796);
+
+ }
+
+ void testF896() {
+ // List<Function> Function([Function x]) Function()
+ Expect.isTrue(f896 is F896);
+ Expect.isTrue(confuse(f896) is F896);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x]) Function() l896;
+ // The static function f896 sets `T` to `int`.
+ if (!tIsBool) {
+ x896 = f896 as dynamic;
+ l896 = f896 as dynamic;
+ x896 = confuse(f896);
+ l896 = confuse(f896);
+ }
+
+ Expect.isTrue(m896 is F896);
+ Expect.isTrue(m896 is List<Function> Function([Function x]) Function());
+ Expect.isTrue(confuse(m896) is F896);
+ // In checked mode, verifies the type.
+ x896 = m896;
+ l896 = m896;
+ x896 = confuse(m896);
+ l896 = confuse(m896);
+
+ }
+
+ void testF996() {
+ // List<Function> Function(core.List<core.int> x0) Function()
+ Expect.isTrue(f996 is F996);
+ Expect.isTrue(confuse(f996) is F996);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x0) Function() l996;
+ // The static function f996 sets `T` to `int`.
+ if (!tIsBool) {
+ x996 = f996 as dynamic;
+ l996 = f996 as dynamic;
+ x996 = confuse(f996);
+ l996 = confuse(f996);
+ }
+
+ Expect.isTrue(m996 is F996);
+ Expect.isTrue(m996 is List<Function> Function(core.List<core.int> x0) Function());
+ Expect.isTrue(confuse(m996) is F996);
+ // In checked mode, verifies the type.
+ x996 = m996;
+ l996 = m996;
+ x996 = confuse(m996);
+ l996 = confuse(m996);
+
+ }
+
+ void testF1096() {
+ // core.List<core.int> Function(int x1, [int x2]) Function()
+ Expect.isTrue(f1096 is F1096);
+ Expect.isTrue(confuse(f1096) is F1096);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, [int x2]) Function() l1096;
+ // The static function f1096 sets `T` to `int`.
+ if (!tIsBool) {
+ x1096 = f1096 as dynamic;
+ l1096 = f1096 as dynamic;
+ x1096 = confuse(f1096);
+ l1096 = confuse(f1096);
+ }
+
+ Expect.isTrue(m1096 is F1096);
+ Expect.isTrue(m1096 is core.List<core.int> Function(int x1, [int x2]) Function());
+ Expect.isTrue(confuse(m1096) is F1096);
+ // In checked mode, verifies the type.
+ x1096 = m1096;
+ l1096 = m1096;
+ x1096 = confuse(m1096);
+ l1096 = confuse(m1096);
+
+ }
+
+ void testF1196() {
+ // core.List<core.int> Function(int x0, {List<Function> x}) Function()
+ Expect.isTrue(f1196 is F1196);
+ Expect.isTrue(confuse(f1196) is F1196);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {List<Function> x}) Function() l1196;
+ // The static function f1196 sets `T` to `int`.
+ if (!tIsBool) {
+ x1196 = f1196 as dynamic;
+ l1196 = f1196 as dynamic;
+ x1196 = confuse(f1196);
+ l1196 = confuse(f1196);
+ }
+
+ Expect.isTrue(m1196 is F1196);
+ Expect.isTrue(m1196 is core.List<core.int> Function(int x0, {List<Function> x}) Function());
+ Expect.isTrue(confuse(m1196) is F1196);
+ // In checked mode, verifies the type.
+ x1196 = m1196;
+ l1196 = m1196;
+ x1196 = confuse(m1196);
+ l1196 = confuse(m1196);
+
+ }
+
+ void testF1296() {
+ // List<T> Function(int x) Function()
+ Expect.isTrue(f1296 is F1296);
+ Expect.isTrue(confuse(f1296) is F1296);
+ // In checked mode, verifies the type.
+ List<T> Function(int x) Function() l1296;
+ // The static function f1296 sets `T` to `int`.
+ if (!tIsBool) {
+ x1296 = f1296 as dynamic;
+ l1296 = f1296 as dynamic;
+ x1296 = confuse(f1296);
+ l1296 = confuse(f1296);
+ }
+
+ Expect.isTrue(m1296 is F1296);
+ Expect.isTrue(m1296 is List<T> Function(int x) Function());
+ Expect.isTrue(confuse(m1296) is F1296);
+ // In checked mode, verifies the type.
+ x1296 = m1296;
+ l1296 = m1296;
+ x1296 = confuse(m1296);
+ l1296 = confuse(m1296);
+ if (!tIsBool) {
+ Expect.isTrue(f1296 is F1296<int>);
+ Expect.isFalse(f1296 is F1296<bool>);
+ Expect.isTrue(confuse(f1296) is F1296<int>);
+ Expect.isFalse(confuse(f1296) is F1296<bool>);
+ Expect.equals(tIsDynamic, m1296 is F1296<bool>);
+ Expect.equals(tIsDynamic, confuse(m1296) is F1296<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1296 = (f1296 as dynamic); });
+ Expect.throws(() { x1296 = confuse(f1296); });
+ List<T> Function(int x) Function() l1296;
+ Expect.throws(() { l1296 = (f1296 as dynamic); });
+ Expect.throws(() { l1296 = confuse(f1296); });
+ }
+ List<T> Function(int x) Function() l1296 = m1296;
+ // In checked mode, verifies the type.
+ x1296 = m1296;
+ x1296 = confuse(m1296);
+ }
+ }
+
+ void testF1396() {
+ // List<T> Function(int y, [List<Function> x]) Function()
+ Expect.isTrue(f1396 is F1396);
+ Expect.isTrue(confuse(f1396) is F1396);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<Function> x]) Function() l1396;
+ // The static function f1396 sets `T` to `int`.
+ if (!tIsBool) {
+ x1396 = f1396 as dynamic;
+ l1396 = f1396 as dynamic;
+ x1396 = confuse(f1396);
+ l1396 = confuse(f1396);
+ }
+
+ Expect.isTrue(m1396 is F1396);
+ Expect.isTrue(m1396 is List<T> Function(int y, [List<Function> x]) Function());
+ Expect.isTrue(confuse(m1396) is F1396);
+ // In checked mode, verifies the type.
+ x1396 = m1396;
+ l1396 = m1396;
+ x1396 = confuse(m1396);
+ l1396 = confuse(m1396);
+ if (!tIsBool) {
+ Expect.isTrue(f1396 is F1396<int>);
+ Expect.isFalse(f1396 is F1396<bool>);
+ Expect.isTrue(confuse(f1396) is F1396<int>);
+ Expect.isFalse(confuse(f1396) is F1396<bool>);
+ Expect.equals(tIsDynamic, m1396 is F1396<bool>);
+ Expect.equals(tIsDynamic, confuse(m1396) is F1396<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1396 = (f1396 as dynamic); });
+ Expect.throws(() { x1396 = confuse(f1396); });
+ List<T> Function(int y, [List<Function> x]) Function() l1396;
+ Expect.throws(() { l1396 = (f1396 as dynamic); });
+ Expect.throws(() { l1396 = confuse(f1396); });
+ }
+ List<T> Function(int y, [List<Function> x]) Function() l1396 = m1396;
+ // In checked mode, verifies the type.
+ x1396 = m1396;
+ x1396 = confuse(m1396);
+ }
+ }
+
+ void testF1496() {
+ // List<T> Function(int x1, [List<T> x2]) Function()
+ Expect.isTrue(f1496 is F1496);
+ Expect.isTrue(confuse(f1496) is F1496);
+ // In checked mode, verifies the type.
+ List<T> Function(int x1, [List<T> x2]) Function() l1496;
+ // The static function f1496 sets `T` to `int`.
+ if (!tIsBool) {
+ x1496 = f1496 as dynamic;
+ l1496 = f1496 as dynamic;
+ x1496 = confuse(f1496);
+ l1496 = confuse(f1496);
+ }
+
+ Expect.isTrue(m1496 is F1496);
+ Expect.isTrue(m1496 is List<T> Function(int x1, [List<T> x2]) Function());
+ Expect.isTrue(confuse(m1496) is F1496);
+ // In checked mode, verifies the type.
+ x1496 = m1496;
+ l1496 = m1496;
+ x1496 = confuse(m1496);
+ l1496 = confuse(m1496);
+ if (!tIsBool) {
+ Expect.isTrue(f1496 is F1496<int>);
+ Expect.isFalse(f1496 is F1496<bool>);
+ Expect.isTrue(confuse(f1496) is F1496<int>);
+ Expect.isFalse(confuse(f1496) is F1496<bool>);
+ Expect.equals(tIsDynamic, m1496 is F1496<bool>);
+ Expect.equals(tIsDynamic, confuse(m1496) is F1496<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1496 = (f1496 as dynamic); });
+ Expect.throws(() { x1496 = confuse(f1496); });
+ List<T> Function(int x1, [List<T> x2]) Function() l1496;
+ Expect.throws(() { l1496 = (f1496 as dynamic); });
+ Expect.throws(() { l1496 = confuse(f1496); });
+ }
+ List<T> Function(int x1, [List<T> x2]) Function() l1496 = m1496;
+ // In checked mode, verifies the type.
+ x1496 = m1496;
+ x1496 = confuse(m1496);
+ }
+ }
+
+ void testF1596() {
+ // Function({Function x}) Function()
+ Expect.isTrue(f1596 is F1596);
+ Expect.isTrue(confuse(f1596) is F1596);
+ // In checked mode, verifies the type.
+ Function({Function x}) Function() l1596;
+ // The static function f1596 sets `T` to `int`.
+ if (!tIsBool) {
+ x1596 = f1596 as dynamic;
+ l1596 = f1596 as dynamic;
+ x1596 = confuse(f1596);
+ l1596 = confuse(f1596);
+ }
+
+ Expect.isTrue(m1596 is F1596);
+ Expect.isTrue(m1596 is Function({Function x}) Function());
+ Expect.isTrue(confuse(m1596) is F1596);
+ // In checked mode, verifies the type.
+ x1596 = m1596;
+ l1596 = m1596;
+ x1596 = confuse(m1596);
+ l1596 = confuse(m1596);
+
+ }
+
+ void testF1696() {
+ // Function(List<T> x) Function()
+ Expect.isTrue(f1696 is F1696);
+ Expect.isTrue(confuse(f1696) is F1696);
+ // In checked mode, verifies the type.
+ Function(List<T> x) Function() l1696;
+ // The static function f1696 sets `T` to `int`.
+ if (!tIsBool) {
+ x1696 = f1696 as dynamic;
+ l1696 = f1696 as dynamic;
+ x1696 = confuse(f1696);
+ l1696 = confuse(f1696);
+ }
+
+ Expect.isTrue(m1696 is F1696);
+ Expect.isTrue(m1696 is Function(List<T> x) Function());
+ Expect.isTrue(confuse(m1696) is F1696);
+ // In checked mode, verifies the type.
+ x1696 = m1696;
+ l1696 = m1696;
+ x1696 = confuse(m1696);
+ l1696 = confuse(m1696);
+ if (!tIsBool) {
+ Expect.isTrue(f1696 is F1696<int>);
+ Expect.isFalse(f1696 is F1696<bool>);
+ Expect.isTrue(confuse(f1696) is F1696<int>);
+ Expect.isFalse(confuse(f1696) is F1696<bool>);
+ Expect.equals(tIsDynamic, m1696 is F1696<bool>);
+ Expect.equals(tIsDynamic, confuse(m1696) is F1696<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1696 = (f1696 as dynamic); });
+ Expect.throws(() { x1696 = confuse(f1696); });
+ Function(List<T> x) Function() l1696;
+ Expect.throws(() { l1696 = (f1696 as dynamic); });
+ Expect.throws(() { l1696 = confuse(f1696); });
+ }
+ Function(List<T> x) Function() l1696 = m1696;
+ // In checked mode, verifies the type.
+ x1696 = m1696;
+ x1696 = confuse(m1696);
+ }
+ }
+
+ void testF1796() {
+ // Function Function<A>() Function()
+ Expect.isTrue(f1796 is F1796);
+ Expect.isTrue(confuse(f1796) is F1796);
+ // In checked mode, verifies the type.
+ Function Function<A>() Function() l1796;
+ // The static function f1796 sets `T` to `int`.
+ if (!tIsBool) {
+ x1796 = f1796 as dynamic;
+ l1796 = f1796 as dynamic;
+ x1796 = confuse(f1796);
+ l1796 = confuse(f1796);
+ }
+
+ Expect.isTrue(m1796 is F1796);
+ Expect.isTrue(m1796 is Function Function<A>() Function());
+ Expect.isTrue(confuse(m1796) is F1796);
+ // In checked mode, verifies the type.
+ x1796 = m1796;
+ l1796 = m1796;
+ x1796 = confuse(m1796);
+ l1796 = confuse(m1796);
+
+ }
+
+ void testF1896() {
+ // List<T> Function<A>(A x) Function()
+ Expect.isTrue(f1896 is F1896);
+ Expect.isTrue(confuse(f1896) is F1896);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(A x) Function() l1896;
+ // The static function f1896 sets `T` to `int`.
+ if (!tIsBool) {
+ x1896 = f1896 as dynamic;
+ l1896 = f1896 as dynamic;
+ x1896 = confuse(f1896);
+ l1896 = confuse(f1896);
+ }
+
+ Expect.isTrue(m1896 is F1896);
+ Expect.isTrue(m1896 is List<T> Function<A>(A x) Function());
+ Expect.isTrue(confuse(m1896) is F1896);
+ // In checked mode, verifies the type.
+ x1896 = m1896;
+ l1896 = m1896;
+ x1896 = confuse(m1896);
+ l1896 = confuse(m1896);
+ if (!tIsBool) {
+ Expect.isTrue(f1896 is F1896<int>);
+ Expect.isFalse(f1896 is F1896<bool>);
+ Expect.isTrue(confuse(f1896) is F1896<int>);
+ Expect.isFalse(confuse(f1896) is F1896<bool>);
+ Expect.equals(tIsDynamic, m1896 is F1896<bool>);
+ Expect.equals(tIsDynamic, confuse(m1896) is F1896<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1896 = (f1896 as dynamic); });
+ Expect.throws(() { x1896 = confuse(f1896); });
+ List<T> Function<A>(A x) Function() l1896;
+ Expect.throws(() { l1896 = (f1896 as dynamic); });
+ Expect.throws(() { l1896 = confuse(f1896); });
+ }
+ List<T> Function<A>(A x) Function() l1896 = m1896;
+ // In checked mode, verifies the type.
+ x1896 = m1896;
+ x1896 = confuse(m1896);
+ }
+ }
+
+ void testF1996() {
+ // List<A> Function<A>(List<A> x) Function()
+ Expect.isTrue(f1996 is F1996);
+ Expect.isTrue(confuse(f1996) is F1996);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<A> x) Function() l1996;
+ // The static function f1996 sets `T` to `int`.
+ if (!tIsBool) {
+ x1996 = f1996 as dynamic;
+ l1996 = f1996 as dynamic;
+ x1996 = confuse(f1996);
+ l1996 = confuse(f1996);
+ }
+
+ Expect.isTrue(m1996 is F1996);
+ Expect.isTrue(m1996 is List<A> Function<A>(List<A> x) Function());
+ Expect.isTrue(confuse(m1996) is F1996);
+ // In checked mode, verifies the type.
+ x1996 = m1996;
+ l1996 = m1996;
+ x1996 = confuse(m1996);
+ l1996 = confuse(m1996);
+
+ }
+
+
+}
+
+class C97<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function({core.List<core.int> x}) x97;
+ core.List<core.int> Function(int x, [List<Function> x2]) x197;
+ Function(int x1, [Function x2]) x297;
+ List<A> Function<A>() x397;
+ int Function(int x1, [List<Function> x]) Function(int x) x497;
+ int Function([List<T> x1]) Function(int x) x597;
+ Function Function(int x, [Function x1]) Function(int x) x697;
+ Function Function(int y, {core.List<core.int> x}) Function(int x) x797;
+ List<Function> Function([Function x]) Function(int x) x897;
+ List<Function> Function(core.List<core.int> x1) Function(int x) x997;
+ core.List<core.int> Function(int x2, [int x3]) Function(int x) x1097;
+ core.List<core.int> Function(int x1, {List<Function> x}) Function(int x) x1197;
+ List<T> Function(int x) Function(int x) x1297;
+ List<T> Function(int y, [List<Function> x]) Function(int x) x1397;
+ List<T> Function(int x2, [List<T> x3]) Function(int x) x1497;
+ Function({Function x}) Function(int x) x1597;
+ Function(List<T> x) Function(int x) x1697;
+ Function Function<A>() Function(int x) x1797;
+ List<T> Function<A>(A x) Function(int x) x1897;
+ List<A> Function<A>(List<A> x) Function(int x) x1997;
+
+
+ C97({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m97({core.List<core.int> x}) => null;
+ core.List<core.int> m197(int x, [List<Function> x0]) => null;
+ m297(int x0, [Function x1]) => null;
+ List<A> m397<A>() => null;
+ int Function(int x0, [List<Function> x]) m497(int x) => null;
+ int Function([List<T> x0]) m597(int x) => null;
+ Function Function(int x, [Function x0]) m697(int x) => null;
+ Function Function(int y, {core.List<core.int> x}) m797(int x) => null;
+ List<Function> Function([Function x]) m897(int x) => null;
+ List<Function> Function(core.List<core.int> x0) m997(int x) => null;
+ core.List<core.int> Function(int x0, [int x1]) m1097(int x) => null;
+ core.List<core.int> Function(int x0, {List<Function> x}) m1197(int x) => null;
+ List<T> Function(int x) m1297(int x) => null;
+ List<T> Function(int y, [List<Function> x]) m1397(int x) => null;
+ List<T> Function(int x0, [List<T> x1]) m1497(int x) => null;
+ Function({Function x}) m1597(int x) => null;
+ Function(List<T> x) m1697(int x) => null;
+ Function Function<A>() m1797(int x) => null;
+ List<T> Function<A>(A x) m1897(int x) => null;
+ List<A> Function<A>(List<A> x) m1997(int x) => null;
+
+
+ runTests() {
+ testF97();
+ testF197();
+ testF297();
+ testF397();
+ testF497();
+ testF597();
+ testF697();
+ testF797();
+ testF897();
+ testF997();
+ testF1097();
+ testF1197();
+ testF1297();
+ testF1397();
+ testF1497();
+ testF1597();
+ testF1697();
+ testF1797();
+ testF1897();
+ testF1997();
+ }
+
+ void testF97() {
+ // Function Function({core.List<core.int> x})
+ Expect.isTrue(f97 is F97);
+ Expect.isTrue(confuse(f97) is F97);
+ // In checked mode, verifies the type.
+ Function Function({core.List<core.int> x}) l97;
+ // The static function f97 sets `T` to `int`.
+ if (!tIsBool) {
+ x97 = f97 as dynamic;
+ l97 = f97 as dynamic;
+ x97 = confuse(f97);
+ l97 = confuse(f97);
+ }
+
+ Expect.isTrue(m97 is F97);
+ Expect.isTrue(m97 is Function Function({core.List<core.int> x}));
+ Expect.isTrue(confuse(m97) is F97);
+ // In checked mode, verifies the type.
+ x97 = m97;
+ l97 = m97;
+ x97 = confuse(m97);
+ l97 = confuse(m97);
+
+ }
+
+ void testF197() {
+ // core.List<core.int> Function(int x, [List<Function> x2])
+ Expect.isTrue(f197 is F197);
+ Expect.isTrue(confuse(f197) is F197);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x, [List<Function> x2]) l197;
+ // The static function f197 sets `T` to `int`.
+ if (!tIsBool) {
+ x197 = f197 as dynamic;
+ l197 = f197 as dynamic;
+ x197 = confuse(f197);
+ l197 = confuse(f197);
+ }
+
+ Expect.isTrue(m197 is F197);
+ Expect.isTrue(m197 is core.List<core.int> Function(int x, [List<Function> x2]));
+ Expect.isTrue(confuse(m197) is F197);
+ // In checked mode, verifies the type.
+ x197 = m197;
+ l197 = m197;
+ x197 = confuse(m197);
+ l197 = confuse(m197);
+
+ }
+
+ void testF297() {
+ // Function(int x1, [Function x2])
+ Expect.isTrue(f297 is F297);
+ Expect.isTrue(confuse(f297) is F297);
+ // In checked mode, verifies the type.
+ Function(int x1, [Function x2]) l297;
+ // The static function f297 sets `T` to `int`.
+ if (!tIsBool) {
+ x297 = f297 as dynamic;
+ l297 = f297 as dynamic;
+ x297 = confuse(f297);
+ l297 = confuse(f297);
+ }
+
+ Expect.isTrue(m297 is F297);
+ Expect.isTrue(m297 is Function(int x1, [Function x2]));
+ Expect.isTrue(confuse(m297) is F297);
+ // In checked mode, verifies the type.
+ x297 = m297;
+ l297 = m297;
+ x297 = confuse(m297);
+ l297 = confuse(m297);
+
+ }
+
+ void testF397() {
+ // List<A> Function<A>()
+ Expect.isTrue(f397 is F397);
+ Expect.isTrue(confuse(f397) is F397);
+ // In checked mode, verifies the type.
+ List<A> Function<A>() l397;
+ // The static function f397 sets `T` to `int`.
+ if (!tIsBool) {
+ x397 = f397 as dynamic;
+ l397 = f397 as dynamic;
+ x397 = confuse(f397);
+ l397 = confuse(f397);
+ }
+
+ Expect.isTrue(m397 is F397);
+ Expect.isTrue(m397 is List<A> Function<A>());
+ Expect.isTrue(confuse(m397) is F397);
+ // In checked mode, verifies the type.
+ x397 = m397;
+ l397 = m397;
+ x397 = confuse(m397);
+ l397 = confuse(m397);
+
+ }
+
+ void testF497() {
+ // int Function(int x1, [List<Function> x]) Function(int x)
+ Expect.isTrue(f497 is F497);
+ Expect.isTrue(confuse(f497) is F497);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<Function> x]) Function(int x) l497;
+ // The static function f497 sets `T` to `int`.
+ if (!tIsBool) {
+ x497 = f497 as dynamic;
+ l497 = f497 as dynamic;
+ x497 = confuse(f497);
+ l497 = confuse(f497);
+ }
+
+ Expect.isTrue(m497 is F497);
+ Expect.isTrue(m497 is int Function(int x1, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m497) is F497);
+ // In checked mode, verifies the type.
+ x497 = m497;
+ l497 = m497;
+ x497 = confuse(m497);
+ l497 = confuse(m497);
+
+ }
+
+ void testF597() {
+ // int Function([List<T> x1]) Function(int x)
+ Expect.isTrue(f597 is F597);
+ Expect.isTrue(confuse(f597) is F597);
+ // In checked mode, verifies the type.
+ int Function([List<T> x1]) Function(int x) l597;
+ // The static function f597 sets `T` to `int`.
+ if (!tIsBool) {
+ x597 = f597 as dynamic;
+ l597 = f597 as dynamic;
+ x597 = confuse(f597);
+ l597 = confuse(f597);
+ }
+
+ Expect.isTrue(m597 is F597);
+ Expect.isTrue(m597 is int Function([List<T> x1]) Function(int x));
+ Expect.isTrue(confuse(m597) is F597);
+ // In checked mode, verifies the type.
+ x597 = m597;
+ l597 = m597;
+ x597 = confuse(m597);
+ l597 = confuse(m597);
+ if (!tIsBool) {
+ Expect.isTrue(f597 is F597<int>);
+ Expect.isFalse(f597 is F597<bool>);
+ Expect.isTrue(confuse(f597) is F597<int>);
+ Expect.isFalse(confuse(f597) is F597<bool>);
+ Expect.equals(tIsDynamic, m597 is F597<bool>);
+ Expect.equals(tIsDynamic, confuse(m597) is F597<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x597 = (f597 as dynamic); });
+ Expect.throws(() { x597 = confuse(f597); });
+ int Function([List<T> x1]) Function(int x) l597;
+ Expect.throws(() { l597 = (f597 as dynamic); });
+ Expect.throws(() { l597 = confuse(f597); });
+ }
+ int Function([List<T> x1]) Function(int x) l597 = m597;
+ // In checked mode, verifies the type.
+ x597 = m597;
+ x597 = confuse(m597);
+ }
+ }
+
+ void testF697() {
+ // Function Function(int x, [Function x1]) Function(int x)
+ Expect.isTrue(f697 is F697);
+ Expect.isTrue(confuse(f697) is F697);
+ // In checked mode, verifies the type.
+ Function Function(int x, [Function x1]) Function(int x) l697;
+ // The static function f697 sets `T` to `int`.
+ if (!tIsBool) {
+ x697 = f697 as dynamic;
+ l697 = f697 as dynamic;
+ x697 = confuse(f697);
+ l697 = confuse(f697);
+ }
+
+ Expect.isTrue(m697 is F697);
+ Expect.isTrue(m697 is Function Function(int x, [Function x1]) Function(int x));
+ Expect.isTrue(confuse(m697) is F697);
+ // In checked mode, verifies the type.
+ x697 = m697;
+ l697 = m697;
+ x697 = confuse(m697);
+ l697 = confuse(m697);
+
+ }
+
+ void testF797() {
+ // Function Function(int y, {core.List<core.int> x}) Function(int x)
+ Expect.isTrue(f797 is F797);
+ Expect.isTrue(confuse(f797) is F797);
+ // In checked mode, verifies the type.
+ Function Function(int y, {core.List<core.int> x}) Function(int x) l797;
+ // The static function f797 sets `T` to `int`.
+ if (!tIsBool) {
+ x797 = f797 as dynamic;
+ l797 = f797 as dynamic;
+ x797 = confuse(f797);
+ l797 = confuse(f797);
+ }
+
+ Expect.isTrue(m797 is F797);
+ Expect.isTrue(m797 is Function Function(int y, {core.List<core.int> x}) Function(int x));
+ Expect.isTrue(confuse(m797) is F797);
+ // In checked mode, verifies the type.
+ x797 = m797;
+ l797 = m797;
+ x797 = confuse(m797);
+ l797 = confuse(m797);
+
+ }
+
+ void testF897() {
+ // List<Function> Function([Function x]) Function(int x)
+ Expect.isTrue(f897 is F897);
+ Expect.isTrue(confuse(f897) is F897);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x]) Function(int x) l897;
+ // The static function f897 sets `T` to `int`.
+ if (!tIsBool) {
+ x897 = f897 as dynamic;
+ l897 = f897 as dynamic;
+ x897 = confuse(f897);
+ l897 = confuse(f897);
+ }
+
+ Expect.isTrue(m897 is F897);
+ Expect.isTrue(m897 is List<Function> Function([Function x]) Function(int x));
+ Expect.isTrue(confuse(m897) is F897);
+ // In checked mode, verifies the type.
+ x897 = m897;
+ l897 = m897;
+ x897 = confuse(m897);
+ l897 = confuse(m897);
+
+ }
+
+ void testF997() {
+ // List<Function> Function(core.List<core.int> x1) Function(int x)
+ Expect.isTrue(f997 is F997);
+ Expect.isTrue(confuse(f997) is F997);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x1) Function(int x) l997;
+ // The static function f997 sets `T` to `int`.
+ if (!tIsBool) {
+ x997 = f997 as dynamic;
+ l997 = f997 as dynamic;
+ x997 = confuse(f997);
+ l997 = confuse(f997);
+ }
+
+ Expect.isTrue(m997 is F997);
+ Expect.isTrue(m997 is List<Function> Function(core.List<core.int> x1) Function(int x));
+ Expect.isTrue(confuse(m997) is F997);
+ // In checked mode, verifies the type.
+ x997 = m997;
+ l997 = m997;
+ x997 = confuse(m997);
+ l997 = confuse(m997);
+
+ }
+
+ void testF1097() {
+ // core.List<core.int> Function(int x2, [int x3]) Function(int x)
+ Expect.isTrue(f1097 is F1097);
+ Expect.isTrue(confuse(f1097) is F1097);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [int x3]) Function(int x) l1097;
+ // The static function f1097 sets `T` to `int`.
+ if (!tIsBool) {
+ x1097 = f1097 as dynamic;
+ l1097 = f1097 as dynamic;
+ x1097 = confuse(f1097);
+ l1097 = confuse(f1097);
+ }
+
+ Expect.isTrue(m1097 is F1097);
+ Expect.isTrue(m1097 is core.List<core.int> Function(int x2, [int x3]) Function(int x));
+ Expect.isTrue(confuse(m1097) is F1097);
+ // In checked mode, verifies the type.
+ x1097 = m1097;
+ l1097 = m1097;
+ x1097 = confuse(m1097);
+ l1097 = confuse(m1097);
+
+ }
+
+ void testF1197() {
+ // core.List<core.int> Function(int x1, {List<Function> x}) Function(int x)
+ Expect.isTrue(f1197 is F1197);
+ Expect.isTrue(confuse(f1197) is F1197);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {List<Function> x}) Function(int x) l1197;
+ // The static function f1197 sets `T` to `int`.
+ if (!tIsBool) {
+ x1197 = f1197 as dynamic;
+ l1197 = f1197 as dynamic;
+ x1197 = confuse(f1197);
+ l1197 = confuse(f1197);
+ }
+
+ Expect.isTrue(m1197 is F1197);
+ Expect.isTrue(m1197 is core.List<core.int> Function(int x1, {List<Function> x}) Function(int x));
+ Expect.isTrue(confuse(m1197) is F1197);
+ // In checked mode, verifies the type.
+ x1197 = m1197;
+ l1197 = m1197;
+ x1197 = confuse(m1197);
+ l1197 = confuse(m1197);
+
+ }
+
+ void testF1297() {
+ // List<T> Function(int x) Function(int x)
+ Expect.isTrue(f1297 is F1297);
+ Expect.isTrue(confuse(f1297) is F1297);
+ // In checked mode, verifies the type.
+ List<T> Function(int x) Function(int x) l1297;
+ // The static function f1297 sets `T` to `int`.
+ if (!tIsBool) {
+ x1297 = f1297 as dynamic;
+ l1297 = f1297 as dynamic;
+ x1297 = confuse(f1297);
+ l1297 = confuse(f1297);
+ }
+
+ Expect.isTrue(m1297 is F1297);
+ Expect.isTrue(m1297 is List<T> Function(int x) Function(int x));
+ Expect.isTrue(confuse(m1297) is F1297);
+ // In checked mode, verifies the type.
+ x1297 = m1297;
+ l1297 = m1297;
+ x1297 = confuse(m1297);
+ l1297 = confuse(m1297);
+ if (!tIsBool) {
+ Expect.isTrue(f1297 is F1297<int>);
+ Expect.isFalse(f1297 is F1297<bool>);
+ Expect.isTrue(confuse(f1297) is F1297<int>);
+ Expect.isFalse(confuse(f1297) is F1297<bool>);
+ Expect.equals(tIsDynamic, m1297 is F1297<bool>);
+ Expect.equals(tIsDynamic, confuse(m1297) is F1297<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1297 = (f1297 as dynamic); });
+ Expect.throws(() { x1297 = confuse(f1297); });
+ List<T> Function(int x) Function(int x) l1297;
+ Expect.throws(() { l1297 = (f1297 as dynamic); });
+ Expect.throws(() { l1297 = confuse(f1297); });
+ }
+ List<T> Function(int x) Function(int x) l1297 = m1297;
+ // In checked mode, verifies the type.
+ x1297 = m1297;
+ x1297 = confuse(m1297);
+ }
+ }
+
+ void testF1397() {
+ // List<T> Function(int y, [List<Function> x]) Function(int x)
+ Expect.isTrue(f1397 is F1397);
+ Expect.isTrue(confuse(f1397) is F1397);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<Function> x]) Function(int x) l1397;
+ // The static function f1397 sets `T` to `int`.
+ if (!tIsBool) {
+ x1397 = f1397 as dynamic;
+ l1397 = f1397 as dynamic;
+ x1397 = confuse(f1397);
+ l1397 = confuse(f1397);
+ }
+
+ Expect.isTrue(m1397 is F1397);
+ Expect.isTrue(m1397 is List<T> Function(int y, [List<Function> x]) Function(int x));
+ Expect.isTrue(confuse(m1397) is F1397);
+ // In checked mode, verifies the type.
+ x1397 = m1397;
+ l1397 = m1397;
+ x1397 = confuse(m1397);
+ l1397 = confuse(m1397);
+ if (!tIsBool) {
+ Expect.isTrue(f1397 is F1397<int>);
+ Expect.isFalse(f1397 is F1397<bool>);
+ Expect.isTrue(confuse(f1397) is F1397<int>);
+ Expect.isFalse(confuse(f1397) is F1397<bool>);
+ Expect.equals(tIsDynamic, m1397 is F1397<bool>);
+ Expect.equals(tIsDynamic, confuse(m1397) is F1397<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1397 = (f1397 as dynamic); });
+ Expect.throws(() { x1397 = confuse(f1397); });
+ List<T> Function(int y, [List<Function> x]) Function(int x) l1397;
+ Expect.throws(() { l1397 = (f1397 as dynamic); });
+ Expect.throws(() { l1397 = confuse(f1397); });
+ }
+ List<T> Function(int y, [List<Function> x]) Function(int x) l1397 = m1397;
+ // In checked mode, verifies the type.
+ x1397 = m1397;
+ x1397 = confuse(m1397);
+ }
+ }
+
+ void testF1497() {
+ // List<T> Function(int x2, [List<T> x3]) Function(int x)
+ Expect.isTrue(f1497 is F1497);
+ Expect.isTrue(confuse(f1497) is F1497);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [List<T> x3]) Function(int x) l1497;
+ // The static function f1497 sets `T` to `int`.
+ if (!tIsBool) {
+ x1497 = f1497 as dynamic;
+ l1497 = f1497 as dynamic;
+ x1497 = confuse(f1497);
+ l1497 = confuse(f1497);
+ }
+
+ Expect.isTrue(m1497 is F1497);
+ Expect.isTrue(m1497 is List<T> Function(int x2, [List<T> x3]) Function(int x));
+ Expect.isTrue(confuse(m1497) is F1497);
+ // In checked mode, verifies the type.
+ x1497 = m1497;
+ l1497 = m1497;
+ x1497 = confuse(m1497);
+ l1497 = confuse(m1497);
+ if (!tIsBool) {
+ Expect.isTrue(f1497 is F1497<int>);
+ Expect.isFalse(f1497 is F1497<bool>);
+ Expect.isTrue(confuse(f1497) is F1497<int>);
+ Expect.isFalse(confuse(f1497) is F1497<bool>);
+ Expect.equals(tIsDynamic, m1497 is F1497<bool>);
+ Expect.equals(tIsDynamic, confuse(m1497) is F1497<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1497 = (f1497 as dynamic); });
+ Expect.throws(() { x1497 = confuse(f1497); });
+ List<T> Function(int x2, [List<T> x3]) Function(int x) l1497;
+ Expect.throws(() { l1497 = (f1497 as dynamic); });
+ Expect.throws(() { l1497 = confuse(f1497); });
+ }
+ List<T> Function(int x2, [List<T> x3]) Function(int x) l1497 = m1497;
+ // In checked mode, verifies the type.
+ x1497 = m1497;
+ x1497 = confuse(m1497);
+ }
+ }
+
+ void testF1597() {
+ // Function({Function x}) Function(int x)
+ Expect.isTrue(f1597 is F1597);
+ Expect.isTrue(confuse(f1597) is F1597);
+ // In checked mode, verifies the type.
+ Function({Function x}) Function(int x) l1597;
+ // The static function f1597 sets `T` to `int`.
+ if (!tIsBool) {
+ x1597 = f1597 as dynamic;
+ l1597 = f1597 as dynamic;
+ x1597 = confuse(f1597);
+ l1597 = confuse(f1597);
+ }
+
+ Expect.isTrue(m1597 is F1597);
+ Expect.isTrue(m1597 is Function({Function x}) Function(int x));
+ Expect.isTrue(confuse(m1597) is F1597);
+ // In checked mode, verifies the type.
+ x1597 = m1597;
+ l1597 = m1597;
+ x1597 = confuse(m1597);
+ l1597 = confuse(m1597);
+
+ }
+
+ void testF1697() {
+ // Function(List<T> x) Function(int x)
+ Expect.isTrue(f1697 is F1697);
+ Expect.isTrue(confuse(f1697) is F1697);
+ // In checked mode, verifies the type.
+ Function(List<T> x) Function(int x) l1697;
+ // The static function f1697 sets `T` to `int`.
+ if (!tIsBool) {
+ x1697 = f1697 as dynamic;
+ l1697 = f1697 as dynamic;
+ x1697 = confuse(f1697);
+ l1697 = confuse(f1697);
+ }
+
+ Expect.isTrue(m1697 is F1697);
+ Expect.isTrue(m1697 is Function(List<T> x) Function(int x));
+ Expect.isTrue(confuse(m1697) is F1697);
+ // In checked mode, verifies the type.
+ x1697 = m1697;
+ l1697 = m1697;
+ x1697 = confuse(m1697);
+ l1697 = confuse(m1697);
+ if (!tIsBool) {
+ Expect.isTrue(f1697 is F1697<int>);
+ Expect.isFalse(f1697 is F1697<bool>);
+ Expect.isTrue(confuse(f1697) is F1697<int>);
+ Expect.isFalse(confuse(f1697) is F1697<bool>);
+ Expect.equals(tIsDynamic, m1697 is F1697<bool>);
+ Expect.equals(tIsDynamic, confuse(m1697) is F1697<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1697 = (f1697 as dynamic); });
+ Expect.throws(() { x1697 = confuse(f1697); });
+ Function(List<T> x) Function(int x) l1697;
+ Expect.throws(() { l1697 = (f1697 as dynamic); });
+ Expect.throws(() { l1697 = confuse(f1697); });
+ }
+ Function(List<T> x) Function(int x) l1697 = m1697;
+ // In checked mode, verifies the type.
+ x1697 = m1697;
+ x1697 = confuse(m1697);
+ }
+ }
+
+ void testF1797() {
+ // Function Function<A>() Function(int x)
+ Expect.isTrue(f1797 is F1797);
+ Expect.isTrue(confuse(f1797) is F1797);
+ // In checked mode, verifies the type.
+ Function Function<A>() Function(int x) l1797;
+ // The static function f1797 sets `T` to `int`.
+ if (!tIsBool) {
+ x1797 = f1797 as dynamic;
+ l1797 = f1797 as dynamic;
+ x1797 = confuse(f1797);
+ l1797 = confuse(f1797);
+ }
+
+ Expect.isTrue(m1797 is F1797);
+ Expect.isTrue(m1797 is Function Function<A>() Function(int x));
+ Expect.isTrue(confuse(m1797) is F1797);
+ // In checked mode, verifies the type.
+ x1797 = m1797;
+ l1797 = m1797;
+ x1797 = confuse(m1797);
+ l1797 = confuse(m1797);
+
+ }
+
+ void testF1897() {
+ // List<T> Function<A>(A x) Function(int x)
+ Expect.isTrue(f1897 is F1897);
+ Expect.isTrue(confuse(f1897) is F1897);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(A x) Function(int x) l1897;
+ // The static function f1897 sets `T` to `int`.
+ if (!tIsBool) {
+ x1897 = f1897 as dynamic;
+ l1897 = f1897 as dynamic;
+ x1897 = confuse(f1897);
+ l1897 = confuse(f1897);
+ }
+
+ Expect.isTrue(m1897 is F1897);
+ Expect.isTrue(m1897 is List<T> Function<A>(A x) Function(int x));
+ Expect.isTrue(confuse(m1897) is F1897);
+ // In checked mode, verifies the type.
+ x1897 = m1897;
+ l1897 = m1897;
+ x1897 = confuse(m1897);
+ l1897 = confuse(m1897);
+ if (!tIsBool) {
+ Expect.isTrue(f1897 is F1897<int>);
+ Expect.isFalse(f1897 is F1897<bool>);
+ Expect.isTrue(confuse(f1897) is F1897<int>);
+ Expect.isFalse(confuse(f1897) is F1897<bool>);
+ Expect.equals(tIsDynamic, m1897 is F1897<bool>);
+ Expect.equals(tIsDynamic, confuse(m1897) is F1897<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1897 = (f1897 as dynamic); });
+ Expect.throws(() { x1897 = confuse(f1897); });
+ List<T> Function<A>(A x) Function(int x) l1897;
+ Expect.throws(() { l1897 = (f1897 as dynamic); });
+ Expect.throws(() { l1897 = confuse(f1897); });
+ }
+ List<T> Function<A>(A x) Function(int x) l1897 = m1897;
+ // In checked mode, verifies the type.
+ x1897 = m1897;
+ x1897 = confuse(m1897);
+ }
+ }
+
+ void testF1997() {
+ // List<A> Function<A>(List<A> x) Function(int x)
+ Expect.isTrue(f1997 is F1997);
+ Expect.isTrue(confuse(f1997) is F1997);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<A> x) Function(int x) l1997;
+ // The static function f1997 sets `T` to `int`.
+ if (!tIsBool) {
+ x1997 = f1997 as dynamic;
+ l1997 = f1997 as dynamic;
+ x1997 = confuse(f1997);
+ l1997 = confuse(f1997);
+ }
+
+ Expect.isTrue(m1997 is F1997);
+ Expect.isTrue(m1997 is List<A> Function<A>(List<A> x) Function(int x));
+ Expect.isTrue(confuse(m1997) is F1997);
+ // In checked mode, verifies the type.
+ x1997 = m1997;
+ l1997 = m1997;
+ x1997 = confuse(m1997);
+ l1997 = confuse(m1997);
+
+ }
+
+
+}
+
+class C98<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int x0, {core.List<core.int> x}) x98;
+ core.List<core.int> Function({List<Function> x}) x198;
+ Function(int x, [Function x2]) x298;
+ List<A> Function<A>(A x) x398;
+ int Function(int x1, [List<Function> x]) Function<B extends core.int>() x498;
+ int Function([List<T> x1]) Function<B extends core.int>() x598;
+ Function Function(int x, [Function x1]) Function<B extends core.int>() x698;
+ Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>() x798;
+ List<Function> Function([Function x]) Function<B extends core.int>() x898;
+ List<Function> Function(core.List<core.int> x1) Function<B extends core.int>() x998;
+ core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>() x1098;
+ core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>() x1198;
+ List<T> Function(int x) Function<B extends core.int>() x1298;
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>() x1398;
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>() x1498;
+ Function({Function x}) Function<B extends core.int>() x1598;
+ Function(List<T> x) Function<B extends core.int>() x1698;
+ Function Function<A>() Function<B extends core.int>() x1798;
+ List<T> Function<A>(A x) Function<B extends core.int>() x1898;
+ List<A> Function<A>(List<A> x) Function<B extends core.int>() x1998;
+
+
+ C98({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m98(int x0, {core.List<core.int> x}) => null;
+ core.List<core.int> m198({List<Function> x}) => null;
+ m298(int x, [Function x0]) => null;
+ List<A> m398<A>(A x) => null;
+ int Function(int x0, [List<Function> x]) m498<B extends core.int>() => null;
+ int Function([List<T> x0]) m598<B extends core.int>() => null;
+ Function Function(int x, [Function x0]) m698<B extends core.int>() => null;
+ Function Function(int y, {core.List<core.int> x}) m798<B extends core.int>() => null;
+ List<Function> Function([Function x]) m898<B extends core.int>() => null;
+ List<Function> Function(core.List<core.int> x0) m998<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, [int x1]) m1098<B extends core.int>() => null;
+ core.List<core.int> Function(int x0, {List<Function> x}) m1198<B extends core.int>() => null;
+ List<T> Function(int x) m1298<B extends core.int>() => null;
+ List<T> Function(int y, [List<Function> x]) m1398<B extends core.int>() => null;
+ List<T> Function(int x0, [List<T> x1]) m1498<B extends core.int>() => null;
+ Function({Function x}) m1598<B extends core.int>() => null;
+ Function(List<T> x) m1698<B extends core.int>() => null;
+ Function Function<A>() m1798<B extends core.int>() => null;
+ List<T> Function<A>(A x) m1898<B extends core.int>() => null;
+ List<A> Function<A>(List<A> x) m1998<B extends core.int>() => null;
+
+
+ runTests() {
+ testF98();
+ testF198();
+ testF298();
+ testF398();
+ testF498();
+ testF598();
+ testF698();
+ testF798();
+ testF898();
+ testF998();
+ testF1098();
+ testF1198();
+ testF1298();
+ testF1398();
+ testF1498();
+ testF1598();
+ testF1698();
+ testF1798();
+ testF1898();
+ testF1998();
+ }
+
+ void testF98() {
+ // Function Function(int x0, {core.List<core.int> x})
+ Expect.isTrue(f98 is F98);
+ Expect.isTrue(confuse(f98) is F98);
+ // In checked mode, verifies the type.
+ Function Function(int x0, {core.List<core.int> x}) l98;
+ // The static function f98 sets `T` to `int`.
+ if (!tIsBool) {
+ x98 = f98 as dynamic;
+ l98 = f98 as dynamic;
+ x98 = confuse(f98);
+ l98 = confuse(f98);
+ }
+
+ Expect.isTrue(m98 is F98);
+ Expect.isTrue(m98 is Function Function(int x0, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m98) is F98);
+ // In checked mode, verifies the type.
+ x98 = m98;
+ l98 = m98;
+ x98 = confuse(m98);
+ l98 = confuse(m98);
+
+ }
+
+ void testF198() {
+ // core.List<core.int> Function({List<Function> x})
+ Expect.isTrue(f198 is F198);
+ Expect.isTrue(confuse(f198) is F198);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function({List<Function> x}) l198;
+ // The static function f198 sets `T` to `int`.
+ if (!tIsBool) {
+ x198 = f198 as dynamic;
+ l198 = f198 as dynamic;
+ x198 = confuse(f198);
+ l198 = confuse(f198);
+ }
+
+ Expect.isTrue(m198 is F198);
+ Expect.isTrue(m198 is core.List<core.int> Function({List<Function> x}));
+ Expect.isTrue(confuse(m198) is F198);
+ // In checked mode, verifies the type.
+ x198 = m198;
+ l198 = m198;
+ x198 = confuse(m198);
+ l198 = confuse(m198);
+
+ }
+
+ void testF298() {
+ // Function(int x, [Function x2])
+ Expect.isTrue(f298 is F298);
+ Expect.isTrue(confuse(f298) is F298);
+ // In checked mode, verifies the type.
+ Function(int x, [Function x2]) l298;
+ // The static function f298 sets `T` to `int`.
+ if (!tIsBool) {
+ x298 = f298 as dynamic;
+ l298 = f298 as dynamic;
+ x298 = confuse(f298);
+ l298 = confuse(f298);
+ }
+
+ Expect.isTrue(m298 is F298);
+ Expect.isTrue(m298 is Function(int x, [Function x2]));
+ Expect.isTrue(confuse(m298) is F298);
+ // In checked mode, verifies the type.
+ x298 = m298;
+ l298 = m298;
+ x298 = confuse(m298);
+ l298 = confuse(m298);
+
+ }
+
+ void testF398() {
+ // List<A> Function<A>(A x)
+ Expect.isTrue(f398 is F398);
+ Expect.isTrue(confuse(f398) is F398);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(A x) l398;
+ // The static function f398 sets `T` to `int`.
+ if (!tIsBool) {
+ x398 = f398 as dynamic;
+ l398 = f398 as dynamic;
+ x398 = confuse(f398);
+ l398 = confuse(f398);
+ }
+
+ Expect.isTrue(m398 is F398);
+ Expect.isTrue(m398 is List<A> Function<A>(A x));
+ Expect.isTrue(confuse(m398) is F398);
+ // In checked mode, verifies the type.
+ x398 = m398;
+ l398 = m398;
+ x398 = confuse(m398);
+ l398 = confuse(m398);
+
+ }
+
+ void testF498() {
+ // int Function(int x1, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f498 is F498);
+ Expect.isTrue(confuse(f498) is F498);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<Function> x]) Function<B extends core.int>() l498;
+ // The static function f498 sets `T` to `int`.
+ if (!tIsBool) {
+ x498 = f498 as dynamic;
+ l498 = f498 as dynamic;
+ x498 = confuse(f498);
+ l498 = confuse(f498);
+ }
+
+ Expect.isTrue(m498 is F498);
+ Expect.isTrue(m498 is int Function(int x1, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m498) is F498);
+ // In checked mode, verifies the type.
+ x498 = m498;
+ l498 = m498;
+ x498 = confuse(m498);
+ l498 = confuse(m498);
+
+ }
+
+ void testF598() {
+ // int Function([List<T> x1]) Function<B extends core.int>()
+ Expect.isTrue(f598 is F598);
+ Expect.isTrue(confuse(f598) is F598);
+ // In checked mode, verifies the type.
+ int Function([List<T> x1]) Function<B extends core.int>() l598;
+ // The static function f598 sets `T` to `int`.
+ if (!tIsBool) {
+ x598 = f598 as dynamic;
+ l598 = f598 as dynamic;
+ x598 = confuse(f598);
+ l598 = confuse(f598);
+ }
+
+ Expect.isTrue(m598 is F598);
+ Expect.isTrue(m598 is int Function([List<T> x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m598) is F598);
+ // In checked mode, verifies the type.
+ x598 = m598;
+ l598 = m598;
+ x598 = confuse(m598);
+ l598 = confuse(m598);
+ if (!tIsBool) {
+ Expect.isTrue(f598 is F598<int>);
+ Expect.isFalse(f598 is F598<bool>);
+ Expect.isTrue(confuse(f598) is F598<int>);
+ Expect.isFalse(confuse(f598) is F598<bool>);
+ Expect.equals(tIsDynamic, m598 is F598<bool>);
+ Expect.equals(tIsDynamic, confuse(m598) is F598<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x598 = (f598 as dynamic); });
+ Expect.throws(() { x598 = confuse(f598); });
+ int Function([List<T> x1]) Function<B extends core.int>() l598;
+ Expect.throws(() { l598 = (f598 as dynamic); });
+ Expect.throws(() { l598 = confuse(f598); });
+ }
+ int Function([List<T> x1]) Function<B extends core.int>() l598 = m598;
+ // In checked mode, verifies the type.
+ x598 = m598;
+ x598 = confuse(m598);
+ }
+ }
+
+ void testF698() {
+ // Function Function(int x, [Function x1]) Function<B extends core.int>()
+ Expect.isTrue(f698 is F698);
+ Expect.isTrue(confuse(f698) is F698);
+ // In checked mode, verifies the type.
+ Function Function(int x, [Function x1]) Function<B extends core.int>() l698;
+ // The static function f698 sets `T` to `int`.
+ if (!tIsBool) {
+ x698 = f698 as dynamic;
+ l698 = f698 as dynamic;
+ x698 = confuse(f698);
+ l698 = confuse(f698);
+ }
+
+ Expect.isTrue(m698 is F698);
+ Expect.isTrue(m698 is Function Function(int x, [Function x1]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m698) is F698);
+ // In checked mode, verifies the type.
+ x698 = m698;
+ l698 = m698;
+ x698 = confuse(m698);
+ l698 = confuse(m698);
+
+ }
+
+ void testF798() {
+ // Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>()
+ Expect.isTrue(f798 is F798);
+ Expect.isTrue(confuse(f798) is F798);
+ // In checked mode, verifies the type.
+ Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>() l798;
+ // The static function f798 sets `T` to `int`.
+ if (!tIsBool) {
+ x798 = f798 as dynamic;
+ l798 = f798 as dynamic;
+ x798 = confuse(f798);
+ l798 = confuse(f798);
+ }
+
+ Expect.isTrue(m798 is F798);
+ Expect.isTrue(m798 is Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m798) is F798);
+ // In checked mode, verifies the type.
+ x798 = m798;
+ l798 = m798;
+ x798 = confuse(m798);
+ l798 = confuse(m798);
+
+ }
+
+ void testF898() {
+ // List<Function> Function([Function x]) Function<B extends core.int>()
+ Expect.isTrue(f898 is F898);
+ Expect.isTrue(confuse(f898) is F898);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x]) Function<B extends core.int>() l898;
+ // The static function f898 sets `T` to `int`.
+ if (!tIsBool) {
+ x898 = f898 as dynamic;
+ l898 = f898 as dynamic;
+ x898 = confuse(f898);
+ l898 = confuse(f898);
+ }
+
+ Expect.isTrue(m898 is F898);
+ Expect.isTrue(m898 is List<Function> Function([Function x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m898) is F898);
+ // In checked mode, verifies the type.
+ x898 = m898;
+ l898 = m898;
+ x898 = confuse(m898);
+ l898 = confuse(m898);
+
+ }
+
+ void testF998() {
+ // List<Function> Function(core.List<core.int> x1) Function<B extends core.int>()
+ Expect.isTrue(f998 is F998);
+ Expect.isTrue(confuse(f998) is F998);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x1) Function<B extends core.int>() l998;
+ // The static function f998 sets `T` to `int`.
+ if (!tIsBool) {
+ x998 = f998 as dynamic;
+ l998 = f998 as dynamic;
+ x998 = confuse(f998);
+ l998 = confuse(f998);
+ }
+
+ Expect.isTrue(m998 is F998);
+ Expect.isTrue(m998 is List<Function> Function(core.List<core.int> x1) Function<B extends core.int>());
+ Expect.isTrue(confuse(m998) is F998);
+ // In checked mode, verifies the type.
+ x998 = m998;
+ l998 = m998;
+ x998 = confuse(m998);
+ l998 = confuse(m998);
+
+ }
+
+ void testF1098() {
+ // core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>()
+ Expect.isTrue(f1098 is F1098);
+ Expect.isTrue(confuse(f1098) is F1098);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>() l1098;
+ // The static function f1098 sets `T` to `int`.
+ if (!tIsBool) {
+ x1098 = f1098 as dynamic;
+ l1098 = f1098 as dynamic;
+ x1098 = confuse(f1098);
+ l1098 = confuse(f1098);
+ }
+
+ Expect.isTrue(m1098 is F1098);
+ Expect.isTrue(m1098 is core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1098) is F1098);
+ // In checked mode, verifies the type.
+ x1098 = m1098;
+ l1098 = m1098;
+ x1098 = confuse(m1098);
+ l1098 = confuse(m1098);
+
+ }
+
+ void testF1198() {
+ // core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>()
+ Expect.isTrue(f1198 is F1198);
+ Expect.isTrue(confuse(f1198) is F1198);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>() l1198;
+ // The static function f1198 sets `T` to `int`.
+ if (!tIsBool) {
+ x1198 = f1198 as dynamic;
+ l1198 = f1198 as dynamic;
+ x1198 = confuse(f1198);
+ l1198 = confuse(f1198);
+ }
+
+ Expect.isTrue(m1198 is F1198);
+ Expect.isTrue(m1198 is core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1198) is F1198);
+ // In checked mode, verifies the type.
+ x1198 = m1198;
+ l1198 = m1198;
+ x1198 = confuse(m1198);
+ l1198 = confuse(m1198);
+
+ }
+
+ void testF1298() {
+ // List<T> Function(int x) Function<B extends core.int>()
+ Expect.isTrue(f1298 is F1298);
+ Expect.isTrue(confuse(f1298) is F1298);
+ // In checked mode, verifies the type.
+ List<T> Function(int x) Function<B extends core.int>() l1298;
+ // The static function f1298 sets `T` to `int`.
+ if (!tIsBool) {
+ x1298 = f1298 as dynamic;
+ l1298 = f1298 as dynamic;
+ x1298 = confuse(f1298);
+ l1298 = confuse(f1298);
+ }
+
+ Expect.isTrue(m1298 is F1298);
+ Expect.isTrue(m1298 is List<T> Function(int x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1298) is F1298);
+ // In checked mode, verifies the type.
+ x1298 = m1298;
+ l1298 = m1298;
+ x1298 = confuse(m1298);
+ l1298 = confuse(m1298);
+ if (!tIsBool) {
+ Expect.isTrue(f1298 is F1298<int>);
+ Expect.isFalse(f1298 is F1298<bool>);
+ Expect.isTrue(confuse(f1298) is F1298<int>);
+ Expect.isFalse(confuse(f1298) is F1298<bool>);
+ Expect.equals(tIsDynamic, m1298 is F1298<bool>);
+ Expect.equals(tIsDynamic, confuse(m1298) is F1298<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1298 = (f1298 as dynamic); });
+ Expect.throws(() { x1298 = confuse(f1298); });
+ List<T> Function(int x) Function<B extends core.int>() l1298;
+ Expect.throws(() { l1298 = (f1298 as dynamic); });
+ Expect.throws(() { l1298 = confuse(f1298); });
+ }
+ List<T> Function(int x) Function<B extends core.int>() l1298 = m1298;
+ // In checked mode, verifies the type.
+ x1298 = m1298;
+ x1298 = confuse(m1298);
+ }
+ }
+
+ void testF1398() {
+ // List<T> Function(int y, [List<Function> x]) Function<B extends core.int>()
+ Expect.isTrue(f1398 is F1398);
+ Expect.isTrue(confuse(f1398) is F1398);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>() l1398;
+ // The static function f1398 sets `T` to `int`.
+ if (!tIsBool) {
+ x1398 = f1398 as dynamic;
+ l1398 = f1398 as dynamic;
+ x1398 = confuse(f1398);
+ l1398 = confuse(f1398);
+ }
+
+ Expect.isTrue(m1398 is F1398);
+ Expect.isTrue(m1398 is List<T> Function(int y, [List<Function> x]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1398) is F1398);
+ // In checked mode, verifies the type.
+ x1398 = m1398;
+ l1398 = m1398;
+ x1398 = confuse(m1398);
+ l1398 = confuse(m1398);
+ if (!tIsBool) {
+ Expect.isTrue(f1398 is F1398<int>);
+ Expect.isFalse(f1398 is F1398<bool>);
+ Expect.isTrue(confuse(f1398) is F1398<int>);
+ Expect.isFalse(confuse(f1398) is F1398<bool>);
+ Expect.equals(tIsDynamic, m1398 is F1398<bool>);
+ Expect.equals(tIsDynamic, confuse(m1398) is F1398<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1398 = (f1398 as dynamic); });
+ Expect.throws(() { x1398 = confuse(f1398); });
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>() l1398;
+ Expect.throws(() { l1398 = (f1398 as dynamic); });
+ Expect.throws(() { l1398 = confuse(f1398); });
+ }
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>() l1398 = m1398;
+ // In checked mode, verifies the type.
+ x1398 = m1398;
+ x1398 = confuse(m1398);
+ }
+ }
+
+ void testF1498() {
+ // List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>()
+ Expect.isTrue(f1498 is F1498);
+ Expect.isTrue(confuse(f1498) is F1498);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1498;
+ // The static function f1498 sets `T` to `int`.
+ if (!tIsBool) {
+ x1498 = f1498 as dynamic;
+ l1498 = f1498 as dynamic;
+ x1498 = confuse(f1498);
+ l1498 = confuse(f1498);
+ }
+
+ Expect.isTrue(m1498 is F1498);
+ Expect.isTrue(m1498 is List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1498) is F1498);
+ // In checked mode, verifies the type.
+ x1498 = m1498;
+ l1498 = m1498;
+ x1498 = confuse(m1498);
+ l1498 = confuse(m1498);
+ if (!tIsBool) {
+ Expect.isTrue(f1498 is F1498<int>);
+ Expect.isFalse(f1498 is F1498<bool>);
+ Expect.isTrue(confuse(f1498) is F1498<int>);
+ Expect.isFalse(confuse(f1498) is F1498<bool>);
+ Expect.equals(tIsDynamic, m1498 is F1498<bool>);
+ Expect.equals(tIsDynamic, confuse(m1498) is F1498<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1498 = (f1498 as dynamic); });
+ Expect.throws(() { x1498 = confuse(f1498); });
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1498;
+ Expect.throws(() { l1498 = (f1498 as dynamic); });
+ Expect.throws(() { l1498 = confuse(f1498); });
+ }
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>() l1498 = m1498;
+ // In checked mode, verifies the type.
+ x1498 = m1498;
+ x1498 = confuse(m1498);
+ }
+ }
+
+ void testF1598() {
+ // Function({Function x}) Function<B extends core.int>()
+ Expect.isTrue(f1598 is F1598);
+ Expect.isTrue(confuse(f1598) is F1598);
+ // In checked mode, verifies the type.
+ Function({Function x}) Function<B extends core.int>() l1598;
+ // The static function f1598 sets `T` to `int`.
+ if (!tIsBool) {
+ x1598 = f1598 as dynamic;
+ l1598 = f1598 as dynamic;
+ x1598 = confuse(f1598);
+ l1598 = confuse(f1598);
+ }
+
+ Expect.isTrue(m1598 is F1598);
+ Expect.isTrue(m1598 is Function({Function x}) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1598) is F1598);
+ // In checked mode, verifies the type.
+ x1598 = m1598;
+ l1598 = m1598;
+ x1598 = confuse(m1598);
+ l1598 = confuse(m1598);
+
+ }
+
+ void testF1698() {
+ // Function(List<T> x) Function<B extends core.int>()
+ Expect.isTrue(f1698 is F1698);
+ Expect.isTrue(confuse(f1698) is F1698);
+ // In checked mode, verifies the type.
+ Function(List<T> x) Function<B extends core.int>() l1698;
+ // The static function f1698 sets `T` to `int`.
+ if (!tIsBool) {
+ x1698 = f1698 as dynamic;
+ l1698 = f1698 as dynamic;
+ x1698 = confuse(f1698);
+ l1698 = confuse(f1698);
+ }
+
+ Expect.isTrue(m1698 is F1698);
+ Expect.isTrue(m1698 is Function(List<T> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1698) is F1698);
+ // In checked mode, verifies the type.
+ x1698 = m1698;
+ l1698 = m1698;
+ x1698 = confuse(m1698);
+ l1698 = confuse(m1698);
+ if (!tIsBool) {
+ Expect.isTrue(f1698 is F1698<int>);
+ Expect.isFalse(f1698 is F1698<bool>);
+ Expect.isTrue(confuse(f1698) is F1698<int>);
+ Expect.isFalse(confuse(f1698) is F1698<bool>);
+ Expect.equals(tIsDynamic, m1698 is F1698<bool>);
+ Expect.equals(tIsDynamic, confuse(m1698) is F1698<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1698 = (f1698 as dynamic); });
+ Expect.throws(() { x1698 = confuse(f1698); });
+ Function(List<T> x) Function<B extends core.int>() l1698;
+ Expect.throws(() { l1698 = (f1698 as dynamic); });
+ Expect.throws(() { l1698 = confuse(f1698); });
+ }
+ Function(List<T> x) Function<B extends core.int>() l1698 = m1698;
+ // In checked mode, verifies the type.
+ x1698 = m1698;
+ x1698 = confuse(m1698);
+ }
+ }
+
+ void testF1798() {
+ // Function Function<A>() Function<B extends core.int>()
+ Expect.isTrue(f1798 is F1798);
+ Expect.isTrue(confuse(f1798) is F1798);
+ // In checked mode, verifies the type.
+ Function Function<A>() Function<B extends core.int>() l1798;
+ // The static function f1798 sets `T` to `int`.
+ if (!tIsBool) {
+ x1798 = f1798 as dynamic;
+ l1798 = f1798 as dynamic;
+ x1798 = confuse(f1798);
+ l1798 = confuse(f1798);
+ }
+
+ Expect.isTrue(m1798 is F1798);
+ Expect.isTrue(m1798 is Function Function<A>() Function<B extends core.int>());
+ Expect.isTrue(confuse(m1798) is F1798);
+ // In checked mode, verifies the type.
+ x1798 = m1798;
+ l1798 = m1798;
+ x1798 = confuse(m1798);
+ l1798 = confuse(m1798);
+
+ }
+
+ void testF1898() {
+ // List<T> Function<A>(A x) Function<B extends core.int>()
+ Expect.isTrue(f1898 is F1898);
+ Expect.isTrue(confuse(f1898) is F1898);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(A x) Function<B extends core.int>() l1898;
+ // The static function f1898 sets `T` to `int`.
+ if (!tIsBool) {
+ x1898 = f1898 as dynamic;
+ l1898 = f1898 as dynamic;
+ x1898 = confuse(f1898);
+ l1898 = confuse(f1898);
+ }
+
+ Expect.isTrue(m1898 is F1898);
+ Expect.isTrue(m1898 is List<T> Function<A>(A x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1898) is F1898);
+ // In checked mode, verifies the type.
+ x1898 = m1898;
+ l1898 = m1898;
+ x1898 = confuse(m1898);
+ l1898 = confuse(m1898);
+ if (!tIsBool) {
+ Expect.isTrue(f1898 is F1898<int>);
+ Expect.isFalse(f1898 is F1898<bool>);
+ Expect.isTrue(confuse(f1898) is F1898<int>);
+ Expect.isFalse(confuse(f1898) is F1898<bool>);
+ Expect.equals(tIsDynamic, m1898 is F1898<bool>);
+ Expect.equals(tIsDynamic, confuse(m1898) is F1898<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1898 = (f1898 as dynamic); });
+ Expect.throws(() { x1898 = confuse(f1898); });
+ List<T> Function<A>(A x) Function<B extends core.int>() l1898;
+ Expect.throws(() { l1898 = (f1898 as dynamic); });
+ Expect.throws(() { l1898 = confuse(f1898); });
+ }
+ List<T> Function<A>(A x) Function<B extends core.int>() l1898 = m1898;
+ // In checked mode, verifies the type.
+ x1898 = m1898;
+ x1898 = confuse(m1898);
+ }
+ }
+
+ void testF1998() {
+ // List<A> Function<A>(List<A> x) Function<B extends core.int>()
+ Expect.isTrue(f1998 is F1998);
+ Expect.isTrue(confuse(f1998) is F1998);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<A> x) Function<B extends core.int>() l1998;
+ // The static function f1998 sets `T` to `int`.
+ if (!tIsBool) {
+ x1998 = f1998 as dynamic;
+ l1998 = f1998 as dynamic;
+ x1998 = confuse(f1998);
+ l1998 = confuse(f1998);
+ }
+
+ Expect.isTrue(m1998 is F1998);
+ Expect.isTrue(m1998 is List<A> Function<A>(List<A> x) Function<B extends core.int>());
+ Expect.isTrue(confuse(m1998) is F1998);
+ // In checked mode, verifies the type.
+ x1998 = m1998;
+ l1998 = m1998;
+ x1998 = confuse(m1998);
+ l1998 = confuse(m1998);
+
+ }
+
+
+}
+
+class C99<T> {
+ final bool tIsBool;
+ final bool tIsInt;
+ final bool tIsDynamic;
+
+ Function Function(int y, {core.List<core.int> x}) x99;
+ core.List<core.int> Function(int x0, {List<Function> x}) x199;
+ Function({Function x}) x299;
+ List<A> Function<A>(List<A> x) x399;
+ int Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) x499;
+ int Function([List<T> x1]) Function<B extends core.int>(int x) x599;
+ Function Function(int x, [Function x1]) Function<B extends core.int>(int x) x699;
+ Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) x799;
+ List<Function> Function([Function x]) Function<B extends core.int>(int x) x899;
+ List<Function> Function(core.List<core.int> x1) Function<B extends core.int>(int x) x999;
+ core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>(int x) x1099;
+ core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) x1199;
+ List<T> Function(int x) Function<B extends core.int>(int x) x1299;
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) x1399;
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) x1499;
+ Function({Function x}) Function<B extends core.int>(int x) x1599;
+ Function(List<T> x) Function<B extends core.int>(int x) x1699;
+ Function Function<A>() Function<B extends core.int>(int x) x1799;
+ List<T> Function<A>(A x) Function<B extends core.int>(int x) x1899;
+ List<A> Function<A>(List<A> x) Function<B extends core.int>(int x) x1999;
+
+
+ C99({this.tIsBool: false, this.tIsInt: false})
+ : tIsDynamic = !tIsBool && !tIsInt;
+
+ Function m99(int y, {core.List<core.int> x}) => null;
+ core.List<core.int> m199(int x0, {List<Function> x}) => null;
+ m299({Function x}) => null;
+ List<A> m399<A>(List<A> x) => null;
+ int Function(int x0, [List<Function> x]) m499<B extends core.int>(int x) => null;
+ int Function([List<T> x0]) m599<B extends core.int>(int x) => null;
+ Function Function(int x, [Function x0]) m699<B extends core.int>(int x) => null;
+ Function Function(int y, {core.List<core.int> x}) m799<B extends core.int>(int x) => null;
+ List<Function> Function([Function x]) m899<B extends core.int>(int x) => null;
+ List<Function> Function(core.List<core.int> x0) m999<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, [int x1]) m1099<B extends core.int>(int x) => null;
+ core.List<core.int> Function(int x0, {List<Function> x}) m1199<B extends core.int>(int x) => null;
+ List<T> Function(int x) m1299<B extends core.int>(int x) => null;
+ List<T> Function(int y, [List<Function> x]) m1399<B extends core.int>(int x) => null;
+ List<T> Function(int x0, [List<T> x1]) m1499<B extends core.int>(int x) => null;
+ Function({Function x}) m1599<B extends core.int>(int x) => null;
+ Function(List<T> x) m1699<B extends core.int>(int x) => null;
+ Function Function<A>() m1799<B extends core.int>(int x) => null;
+ List<T> Function<A>(A x) m1899<B extends core.int>(int x) => null;
+ List<A> Function<A>(List<A> x) m1999<B extends core.int>(int x) => null;
+
+
+ runTests() {
+ testF99();
+ testF199();
+ testF299();
+ testF399();
+ testF499();
+ testF599();
+ testF699();
+ testF799();
+ testF899();
+ testF999();
+ testF1099();
+ testF1199();
+ testF1299();
+ testF1399();
+ testF1499();
+ testF1599();
+ testF1699();
+ testF1799();
+ testF1899();
+ testF1999();
+ }
+
+ void testF99() {
+ // Function Function(int y, {core.List<core.int> x})
+ Expect.isTrue(f99 is F99);
+ Expect.isTrue(confuse(f99) is F99);
+ // In checked mode, verifies the type.
+ Function Function(int y, {core.List<core.int> x}) l99;
+ // The static function f99 sets `T` to `int`.
+ if (!tIsBool) {
+ x99 = f99 as dynamic;
+ l99 = f99 as dynamic;
+ x99 = confuse(f99);
+ l99 = confuse(f99);
+ }
+
+ Expect.isTrue(m99 is F99);
+ Expect.isTrue(m99 is Function Function(int y, {core.List<core.int> x}));
+ Expect.isTrue(confuse(m99) is F99);
+ // In checked mode, verifies the type.
+ x99 = m99;
+ l99 = m99;
+ x99 = confuse(m99);
+ l99 = confuse(m99);
+
+ }
+
+ void testF199() {
+ // core.List<core.int> Function(int x0, {List<Function> x})
+ Expect.isTrue(f199 is F199);
+ Expect.isTrue(confuse(f199) is F199);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x0, {List<Function> x}) l199;
+ // The static function f199 sets `T` to `int`.
+ if (!tIsBool) {
+ x199 = f199 as dynamic;
+ l199 = f199 as dynamic;
+ x199 = confuse(f199);
+ l199 = confuse(f199);
+ }
+
+ Expect.isTrue(m199 is F199);
+ Expect.isTrue(m199 is core.List<core.int> Function(int x0, {List<Function> x}));
+ Expect.isTrue(confuse(m199) is F199);
+ // In checked mode, verifies the type.
+ x199 = m199;
+ l199 = m199;
+ x199 = confuse(m199);
+ l199 = confuse(m199);
+
+ }
+
+ void testF299() {
+ // Function({Function x})
+ Expect.isTrue(f299 is F299);
+ Expect.isTrue(confuse(f299) is F299);
+ // In checked mode, verifies the type.
+ Function({Function x}) l299;
+ // The static function f299 sets `T` to `int`.
+ if (!tIsBool) {
+ x299 = f299 as dynamic;
+ l299 = f299 as dynamic;
+ x299 = confuse(f299);
+ l299 = confuse(f299);
+ }
+
+ Expect.isTrue(m299 is F299);
+ Expect.isTrue(m299 is Function({Function x}));
+ Expect.isTrue(confuse(m299) is F299);
+ // In checked mode, verifies the type.
+ x299 = m299;
+ l299 = m299;
+ x299 = confuse(m299);
+ l299 = confuse(m299);
+
+ }
+
+ void testF399() {
+ // List<A> Function<A>(List<A> x)
+ Expect.isTrue(f399 is F399);
+ Expect.isTrue(confuse(f399) is F399);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<A> x) l399;
+ // The static function f399 sets `T` to `int`.
+ if (!tIsBool) {
+ x399 = f399 as dynamic;
+ l399 = f399 as dynamic;
+ x399 = confuse(f399);
+ l399 = confuse(f399);
+ }
+
+ Expect.isTrue(m399 is F399);
+ Expect.isTrue(m399 is List<A> Function<A>(List<A> x));
+ Expect.isTrue(confuse(m399) is F399);
+ // In checked mode, verifies the type.
+ x399 = m399;
+ l399 = m399;
+ x399 = confuse(m399);
+ l399 = confuse(m399);
+
+ }
+
+ void testF499() {
+ // int Function(int x1, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f499 is F499);
+ Expect.isTrue(confuse(f499) is F499);
+ // In checked mode, verifies the type.
+ int Function(int x1, [List<Function> x]) Function<B extends core.int>(int x) l499;
+ // The static function f499 sets `T` to `int`.
+ if (!tIsBool) {
+ x499 = f499 as dynamic;
+ l499 = f499 as dynamic;
+ x499 = confuse(f499);
+ l499 = confuse(f499);
+ }
+
+ Expect.isTrue(m499 is F499);
+ Expect.isTrue(m499 is int Function(int x1, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m499) is F499);
+ // In checked mode, verifies the type.
+ x499 = m499;
+ l499 = m499;
+ x499 = confuse(m499);
+ l499 = confuse(m499);
+
+ }
+
+ void testF599() {
+ // int Function([List<T> x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f599 is F599);
+ Expect.isTrue(confuse(f599) is F599);
+ // In checked mode, verifies the type.
+ int Function([List<T> x1]) Function<B extends core.int>(int x) l599;
+ // The static function f599 sets `T` to `int`.
+ if (!tIsBool) {
+ x599 = f599 as dynamic;
+ l599 = f599 as dynamic;
+ x599 = confuse(f599);
+ l599 = confuse(f599);
+ }
+
+ Expect.isTrue(m599 is F599);
+ Expect.isTrue(m599 is int Function([List<T> x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m599) is F599);
+ // In checked mode, verifies the type.
+ x599 = m599;
+ l599 = m599;
+ x599 = confuse(m599);
+ l599 = confuse(m599);
+ if (!tIsBool) {
+ Expect.isTrue(f599 is F599<int>);
+ Expect.isFalse(f599 is F599<bool>);
+ Expect.isTrue(confuse(f599) is F599<int>);
+ Expect.isFalse(confuse(f599) is F599<bool>);
+ Expect.equals(tIsDynamic, m599 is F599<bool>);
+ Expect.equals(tIsDynamic, confuse(m599) is F599<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x599 = (f599 as dynamic); });
+ Expect.throws(() { x599 = confuse(f599); });
+ int Function([List<T> x1]) Function<B extends core.int>(int x) l599;
+ Expect.throws(() { l599 = (f599 as dynamic); });
+ Expect.throws(() { l599 = confuse(f599); });
+ }
+ int Function([List<T> x1]) Function<B extends core.int>(int x) l599 = m599;
+ // In checked mode, verifies the type.
+ x599 = m599;
+ x599 = confuse(m599);
+ }
+ }
+
+ void testF699() {
+ // Function Function(int x, [Function x1]) Function<B extends core.int>(int x)
+ Expect.isTrue(f699 is F699);
+ Expect.isTrue(confuse(f699) is F699);
+ // In checked mode, verifies the type.
+ Function Function(int x, [Function x1]) Function<B extends core.int>(int x) l699;
+ // The static function f699 sets `T` to `int`.
+ if (!tIsBool) {
+ x699 = f699 as dynamic;
+ l699 = f699 as dynamic;
+ x699 = confuse(f699);
+ l699 = confuse(f699);
+ }
+
+ Expect.isTrue(m699 is F699);
+ Expect.isTrue(m699 is Function Function(int x, [Function x1]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m699) is F699);
+ // In checked mode, verifies the type.
+ x699 = m699;
+ l699 = m699;
+ x699 = confuse(m699);
+ l699 = confuse(m699);
+
+ }
+
+ void testF799() {
+ // Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f799 is F799);
+ Expect.isTrue(confuse(f799) is F799);
+ // In checked mode, verifies the type.
+ Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x) l799;
+ // The static function f799 sets `T` to `int`.
+ if (!tIsBool) {
+ x799 = f799 as dynamic;
+ l799 = f799 as dynamic;
+ x799 = confuse(f799);
+ l799 = confuse(f799);
+ }
+
+ Expect.isTrue(m799 is F799);
+ Expect.isTrue(m799 is Function Function(int y, {core.List<core.int> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m799) is F799);
+ // In checked mode, verifies the type.
+ x799 = m799;
+ l799 = m799;
+ x799 = confuse(m799);
+ l799 = confuse(m799);
+
+ }
+
+ void testF899() {
+ // List<Function> Function([Function x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f899 is F899);
+ Expect.isTrue(confuse(f899) is F899);
+ // In checked mode, verifies the type.
+ List<Function> Function([Function x]) Function<B extends core.int>(int x) l899;
+ // The static function f899 sets `T` to `int`.
+ if (!tIsBool) {
+ x899 = f899 as dynamic;
+ l899 = f899 as dynamic;
+ x899 = confuse(f899);
+ l899 = confuse(f899);
+ }
+
+ Expect.isTrue(m899 is F899);
+ Expect.isTrue(m899 is List<Function> Function([Function x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m899) is F899);
+ // In checked mode, verifies the type.
+ x899 = m899;
+ l899 = m899;
+ x899 = confuse(m899);
+ l899 = confuse(m899);
+
+ }
+
+ void testF999() {
+ // List<Function> Function(core.List<core.int> x1) Function<B extends core.int>(int x)
+ Expect.isTrue(f999 is F999);
+ Expect.isTrue(confuse(f999) is F999);
+ // In checked mode, verifies the type.
+ List<Function> Function(core.List<core.int> x1) Function<B extends core.int>(int x) l999;
+ // The static function f999 sets `T` to `int`.
+ if (!tIsBool) {
+ x999 = f999 as dynamic;
+ l999 = f999 as dynamic;
+ x999 = confuse(f999);
+ l999 = confuse(f999);
+ }
+
+ Expect.isTrue(m999 is F999);
+ Expect.isTrue(m999 is List<Function> Function(core.List<core.int> x1) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m999) is F999);
+ // In checked mode, verifies the type.
+ x999 = m999;
+ l999 = m999;
+ x999 = confuse(m999);
+ l999 = confuse(m999);
+
+ }
+
+ void testF1099() {
+ // core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1099 is F1099);
+ Expect.isTrue(confuse(f1099) is F1099);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>(int x) l1099;
+ // The static function f1099 sets `T` to `int`.
+ if (!tIsBool) {
+ x1099 = f1099 as dynamic;
+ l1099 = f1099 as dynamic;
+ x1099 = confuse(f1099);
+ l1099 = confuse(f1099);
+ }
+
+ Expect.isTrue(m1099 is F1099);
+ Expect.isTrue(m1099 is core.List<core.int> Function(int x2, [int x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1099) is F1099);
+ // In checked mode, verifies the type.
+ x1099 = m1099;
+ l1099 = m1099;
+ x1099 = confuse(m1099);
+ l1099 = confuse(m1099);
+
+ }
+
+ void testF1199() {
+ // core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1199 is F1199);
+ Expect.isTrue(confuse(f1199) is F1199);
+ // In checked mode, verifies the type.
+ core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x) l1199;
+ // The static function f1199 sets `T` to `int`.
+ if (!tIsBool) {
+ x1199 = f1199 as dynamic;
+ l1199 = f1199 as dynamic;
+ x1199 = confuse(f1199);
+ l1199 = confuse(f1199);
+ }
+
+ Expect.isTrue(m1199 is F1199);
+ Expect.isTrue(m1199 is core.List<core.int> Function(int x1, {List<Function> x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1199) is F1199);
+ // In checked mode, verifies the type.
+ x1199 = m1199;
+ l1199 = m1199;
+ x1199 = confuse(m1199);
+ l1199 = confuse(m1199);
+
+ }
+
+ void testF1299() {
+ // List<T> Function(int x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1299 is F1299);
+ Expect.isTrue(confuse(f1299) is F1299);
+ // In checked mode, verifies the type.
+ List<T> Function(int x) Function<B extends core.int>(int x) l1299;
+ // The static function f1299 sets `T` to `int`.
+ if (!tIsBool) {
+ x1299 = f1299 as dynamic;
+ l1299 = f1299 as dynamic;
+ x1299 = confuse(f1299);
+ l1299 = confuse(f1299);
+ }
+
+ Expect.isTrue(m1299 is F1299);
+ Expect.isTrue(m1299 is List<T> Function(int x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1299) is F1299);
+ // In checked mode, verifies the type.
+ x1299 = m1299;
+ l1299 = m1299;
+ x1299 = confuse(m1299);
+ l1299 = confuse(m1299);
+ if (!tIsBool) {
+ Expect.isTrue(f1299 is F1299<int>);
+ Expect.isFalse(f1299 is F1299<bool>);
+ Expect.isTrue(confuse(f1299) is F1299<int>);
+ Expect.isFalse(confuse(f1299) is F1299<bool>);
+ Expect.equals(tIsDynamic, m1299 is F1299<bool>);
+ Expect.equals(tIsDynamic, confuse(m1299) is F1299<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1299 = (f1299 as dynamic); });
+ Expect.throws(() { x1299 = confuse(f1299); });
+ List<T> Function(int x) Function<B extends core.int>(int x) l1299;
+ Expect.throws(() { l1299 = (f1299 as dynamic); });
+ Expect.throws(() { l1299 = confuse(f1299); });
+ }
+ List<T> Function(int x) Function<B extends core.int>(int x) l1299 = m1299;
+ // In checked mode, verifies the type.
+ x1299 = m1299;
+ x1299 = confuse(m1299);
+ }
+ }
+
+ void testF1399() {
+ // List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1399 is F1399);
+ Expect.isTrue(confuse(f1399) is F1399);
+ // In checked mode, verifies the type.
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l1399;
+ // The static function f1399 sets `T` to `int`.
+ if (!tIsBool) {
+ x1399 = f1399 as dynamic;
+ l1399 = f1399 as dynamic;
+ x1399 = confuse(f1399);
+ l1399 = confuse(f1399);
+ }
+
+ Expect.isTrue(m1399 is F1399);
+ Expect.isTrue(m1399 is List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1399) is F1399);
+ // In checked mode, verifies the type.
+ x1399 = m1399;
+ l1399 = m1399;
+ x1399 = confuse(m1399);
+ l1399 = confuse(m1399);
+ if (!tIsBool) {
+ Expect.isTrue(f1399 is F1399<int>);
+ Expect.isFalse(f1399 is F1399<bool>);
+ Expect.isTrue(confuse(f1399) is F1399<int>);
+ Expect.isFalse(confuse(f1399) is F1399<bool>);
+ Expect.equals(tIsDynamic, m1399 is F1399<bool>);
+ Expect.equals(tIsDynamic, confuse(m1399) is F1399<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1399 = (f1399 as dynamic); });
+ Expect.throws(() { x1399 = confuse(f1399); });
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l1399;
+ Expect.throws(() { l1399 = (f1399 as dynamic); });
+ Expect.throws(() { l1399 = confuse(f1399); });
+ }
+ List<T> Function(int y, [List<Function> x]) Function<B extends core.int>(int x) l1399 = m1399;
+ // In checked mode, verifies the type.
+ x1399 = m1399;
+ x1399 = confuse(m1399);
+ }
+ }
+
+ void testF1499() {
+ // List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x)
+ Expect.isTrue(f1499 is F1499);
+ Expect.isTrue(confuse(f1499) is F1499);
+ // In checked mode, verifies the type.
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1499;
+ // The static function f1499 sets `T` to `int`.
+ if (!tIsBool) {
+ x1499 = f1499 as dynamic;
+ l1499 = f1499 as dynamic;
+ x1499 = confuse(f1499);
+ l1499 = confuse(f1499);
+ }
+
+ Expect.isTrue(m1499 is F1499);
+ Expect.isTrue(m1499 is List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1499) is F1499);
+ // In checked mode, verifies the type.
+ x1499 = m1499;
+ l1499 = m1499;
+ x1499 = confuse(m1499);
+ l1499 = confuse(m1499);
+ if (!tIsBool) {
+ Expect.isTrue(f1499 is F1499<int>);
+ Expect.isFalse(f1499 is F1499<bool>);
+ Expect.isTrue(confuse(f1499) is F1499<int>);
+ Expect.isFalse(confuse(f1499) is F1499<bool>);
+ Expect.equals(tIsDynamic, m1499 is F1499<bool>);
+ Expect.equals(tIsDynamic, confuse(m1499) is F1499<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1499 = (f1499 as dynamic); });
+ Expect.throws(() { x1499 = confuse(f1499); });
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1499;
+ Expect.throws(() { l1499 = (f1499 as dynamic); });
+ Expect.throws(() { l1499 = confuse(f1499); });
+ }
+ List<T> Function(int x2, [List<T> x3]) Function<B extends core.int>(int x) l1499 = m1499;
+ // In checked mode, verifies the type.
+ x1499 = m1499;
+ x1499 = confuse(m1499);
+ }
+ }
+
+ void testF1599() {
+ // Function({Function x}) Function<B extends core.int>(int x)
+ Expect.isTrue(f1599 is F1599);
+ Expect.isTrue(confuse(f1599) is F1599);
+ // In checked mode, verifies the type.
+ Function({Function x}) Function<B extends core.int>(int x) l1599;
+ // The static function f1599 sets `T` to `int`.
+ if (!tIsBool) {
+ x1599 = f1599 as dynamic;
+ l1599 = f1599 as dynamic;
+ x1599 = confuse(f1599);
+ l1599 = confuse(f1599);
+ }
+
+ Expect.isTrue(m1599 is F1599);
+ Expect.isTrue(m1599 is Function({Function x}) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1599) is F1599);
+ // In checked mode, verifies the type.
+ x1599 = m1599;
+ l1599 = m1599;
+ x1599 = confuse(m1599);
+ l1599 = confuse(m1599);
+
+ }
+
+ void testF1699() {
+ // Function(List<T> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1699 is F1699);
+ Expect.isTrue(confuse(f1699) is F1699);
+ // In checked mode, verifies the type.
+ Function(List<T> x) Function<B extends core.int>(int x) l1699;
+ // The static function f1699 sets `T` to `int`.
+ if (!tIsBool) {
+ x1699 = f1699 as dynamic;
+ l1699 = f1699 as dynamic;
+ x1699 = confuse(f1699);
+ l1699 = confuse(f1699);
+ }
+
+ Expect.isTrue(m1699 is F1699);
+ Expect.isTrue(m1699 is Function(List<T> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1699) is F1699);
+ // In checked mode, verifies the type.
+ x1699 = m1699;
+ l1699 = m1699;
+ x1699 = confuse(m1699);
+ l1699 = confuse(m1699);
+ if (!tIsBool) {
+ Expect.isTrue(f1699 is F1699<int>);
+ Expect.isFalse(f1699 is F1699<bool>);
+ Expect.isTrue(confuse(f1699) is F1699<int>);
+ Expect.isFalse(confuse(f1699) is F1699<bool>);
+ Expect.equals(tIsDynamic, m1699 is F1699<bool>);
+ Expect.equals(tIsDynamic, confuse(m1699) is F1699<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1699 = (f1699 as dynamic); });
+ Expect.throws(() { x1699 = confuse(f1699); });
+ Function(List<T> x) Function<B extends core.int>(int x) l1699;
+ Expect.throws(() { l1699 = (f1699 as dynamic); });
+ Expect.throws(() { l1699 = confuse(f1699); });
+ }
+ Function(List<T> x) Function<B extends core.int>(int x) l1699 = m1699;
+ // In checked mode, verifies the type.
+ x1699 = m1699;
+ x1699 = confuse(m1699);
+ }
+ }
+
+ void testF1799() {
+ // Function Function<A>() Function<B extends core.int>(int x)
+ Expect.isTrue(f1799 is F1799);
+ Expect.isTrue(confuse(f1799) is F1799);
+ // In checked mode, verifies the type.
+ Function Function<A>() Function<B extends core.int>(int x) l1799;
+ // The static function f1799 sets `T` to `int`.
+ if (!tIsBool) {
+ x1799 = f1799 as dynamic;
+ l1799 = f1799 as dynamic;
+ x1799 = confuse(f1799);
+ l1799 = confuse(f1799);
+ }
+
+ Expect.isTrue(m1799 is F1799);
+ Expect.isTrue(m1799 is Function Function<A>() Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1799) is F1799);
+ // In checked mode, verifies the type.
+ x1799 = m1799;
+ l1799 = m1799;
+ x1799 = confuse(m1799);
+ l1799 = confuse(m1799);
+
+ }
+
+ void testF1899() {
+ // List<T> Function<A>(A x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1899 is F1899);
+ Expect.isTrue(confuse(f1899) is F1899);
+ // In checked mode, verifies the type.
+ List<T> Function<A>(A x) Function<B extends core.int>(int x) l1899;
+ // The static function f1899 sets `T` to `int`.
+ if (!tIsBool) {
+ x1899 = f1899 as dynamic;
+ l1899 = f1899 as dynamic;
+ x1899 = confuse(f1899);
+ l1899 = confuse(f1899);
+ }
+
+ Expect.isTrue(m1899 is F1899);
+ Expect.isTrue(m1899 is List<T> Function<A>(A x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1899) is F1899);
+ // In checked mode, verifies the type.
+ x1899 = m1899;
+ l1899 = m1899;
+ x1899 = confuse(m1899);
+ l1899 = confuse(m1899);
+ if (!tIsBool) {
+ Expect.isTrue(f1899 is F1899<int>);
+ Expect.isFalse(f1899 is F1899<bool>);
+ Expect.isTrue(confuse(f1899) is F1899<int>);
+ Expect.isFalse(confuse(f1899) is F1899<bool>);
+ Expect.equals(tIsDynamic, m1899 is F1899<bool>);
+ Expect.equals(tIsDynamic, confuse(m1899) is F1899<bool>);
+ } else {
+ if (inCheckedMode) {
+ Expect.throws(() { x1899 = (f1899 as dynamic); });
+ Expect.throws(() { x1899 = confuse(f1899); });
+ List<T> Function<A>(A x) Function<B extends core.int>(int x) l1899;
+ Expect.throws(() { l1899 = (f1899 as dynamic); });
+ Expect.throws(() { l1899 = confuse(f1899); });
+ }
+ List<T> Function<A>(A x) Function<B extends core.int>(int x) l1899 = m1899;
+ // In checked mode, verifies the type.
+ x1899 = m1899;
+ x1899 = confuse(m1899);
+ }
+ }
+
+ void testF1999() {
+ // List<A> Function<A>(List<A> x) Function<B extends core.int>(int x)
+ Expect.isTrue(f1999 is F1999);
+ Expect.isTrue(confuse(f1999) is F1999);
+ // In checked mode, verifies the type.
+ List<A> Function<A>(List<A> x) Function<B extends core.int>(int x) l1999;
+ // The static function f1999 sets `T` to `int`.
+ if (!tIsBool) {
+ x1999 = f1999 as dynamic;
+ l1999 = f1999 as dynamic;
+ x1999 = confuse(f1999);
+ l1999 = confuse(f1999);
+ }
+
+ Expect.isTrue(m1999 is F1999);
+ Expect.isTrue(m1999 is List<A> Function<A>(List<A> x) Function<B extends core.int>(int x));
+ Expect.isTrue(confuse(m1999) is F1999);
+ // In checked mode, verifies the type.
+ x1999 = m1999;
+ l1999 = m1999;
+ x1999 = confuse(m1999);
+ l1999 = confuse(m1999);
+
+ }
+
+
+}
+
+void runTests() {
+ new C0().runTests();
+ new C0<int>(tIsInt: true).runTests();
+ new C0<bool>(tIsBool: true).runTests();
+ new C1().runTests();
+ new C1<int>(tIsInt: true).runTests();
+ new C1<bool>(tIsBool: true).runTests();
+ new C2().runTests();
+ new C2<int>(tIsInt: true).runTests();
+ new C2<bool>(tIsBool: true).runTests();
+ new C3().runTests();
+ new C3<int>(tIsInt: true).runTests();
+ new C3<bool>(tIsBool: true).runTests();
+ new C4().runTests();
+ new C4<int>(tIsInt: true).runTests();
+ new C4<bool>(tIsBool: true).runTests();
+ new C5().runTests();
+ new C5<int>(tIsInt: true).runTests();
+ new C5<bool>(tIsBool: true).runTests();
+ new C6().runTests();
+ new C6<int>(tIsInt: true).runTests();
+ new C6<bool>(tIsBool: true).runTests();
+ new C7().runTests();
+ new C7<int>(tIsInt: true).runTests();
+ new C7<bool>(tIsBool: true).runTests();
+ new C8().runTests();
+ new C8<int>(tIsInt: true).runTests();
+ new C8<bool>(tIsBool: true).runTests();
+ new C9().runTests();
+ new C9<int>(tIsInt: true).runTests();
+ new C9<bool>(tIsBool: true).runTests();
+ new C10().runTests();
+ new C10<int>(tIsInt: true).runTests();
+ new C10<bool>(tIsBool: true).runTests();
+ new C11().runTests();
+ new C11<int>(tIsInt: true).runTests();
+ new C11<bool>(tIsBool: true).runTests();
+ new C12().runTests();
+ new C12<int>(tIsInt: true).runTests();
+ new C12<bool>(tIsBool: true).runTests();
+ new C13().runTests();
+ new C13<int>(tIsInt: true).runTests();
+ new C13<bool>(tIsBool: true).runTests();
+ new C14().runTests();
+ new C14<int>(tIsInt: true).runTests();
+ new C14<bool>(tIsBool: true).runTests();
+ new C15().runTests();
+ new C15<int>(tIsInt: true).runTests();
+ new C15<bool>(tIsBool: true).runTests();
+ new C16().runTests();
+ new C16<int>(tIsInt: true).runTests();
+ new C16<bool>(tIsBool: true).runTests();
+ new C17().runTests();
+ new C17<int>(tIsInt: true).runTests();
+ new C17<bool>(tIsBool: true).runTests();
+ new C18().runTests();
+ new C18<int>(tIsInt: true).runTests();
+ new C18<bool>(tIsBool: true).runTests();
+ new C19().runTests();
+ new C19<int>(tIsInt: true).runTests();
+ new C19<bool>(tIsBool: true).runTests();
+ new C20().runTests();
+ new C20<int>(tIsInt: true).runTests();
+ new C20<bool>(tIsBool: true).runTests();
+ new C21().runTests();
+ new C21<int>(tIsInt: true).runTests();
+ new C21<bool>(tIsBool: true).runTests();
+ new C22().runTests();
+ new C22<int>(tIsInt: true).runTests();
+ new C22<bool>(tIsBool: true).runTests();
+ new C23().runTests();
+ new C23<int>(tIsInt: true).runTests();
+ new C23<bool>(tIsBool: true).runTests();
+ new C24().runTests();
+ new C24<int>(tIsInt: true).runTests();
+ new C24<bool>(tIsBool: true).runTests();
+ new C25().runTests();
+ new C25<int>(tIsInt: true).runTests();
+ new C25<bool>(tIsBool: true).runTests();
+ new C26().runTests();
+ new C26<int>(tIsInt: true).runTests();
+ new C26<bool>(tIsBool: true).runTests();
+ new C27().runTests();
+ new C27<int>(tIsInt: true).runTests();
+ new C27<bool>(tIsBool: true).runTests();
+ new C28().runTests();
+ new C28<int>(tIsInt: true).runTests();
+ new C28<bool>(tIsBool: true).runTests();
+ new C29().runTests();
+ new C29<int>(tIsInt: true).runTests();
+ new C29<bool>(tIsBool: true).runTests();
+ new C30().runTests();
+ new C30<int>(tIsInt: true).runTests();
+ new C30<bool>(tIsBool: true).runTests();
+ new C31().runTests();
+ new C31<int>(tIsInt: true).runTests();
+ new C31<bool>(tIsBool: true).runTests();
+ new C32().runTests();
+ new C32<int>(tIsInt: true).runTests();
+ new C32<bool>(tIsBool: true).runTests();
+ new C33().runTests();
+ new C33<int>(tIsInt: true).runTests();
+ new C33<bool>(tIsBool: true).runTests();
+ new C34().runTests();
+ new C34<int>(tIsInt: true).runTests();
+ new C34<bool>(tIsBool: true).runTests();
+ new C35().runTests();
+ new C35<int>(tIsInt: true).runTests();
+ new C35<bool>(tIsBool: true).runTests();
+ new C36().runTests();
+ new C36<int>(tIsInt: true).runTests();
+ new C36<bool>(tIsBool: true).runTests();
+ new C37().runTests();
+ new C37<int>(tIsInt: true).runTests();
+ new C37<bool>(tIsBool: true).runTests();
+ new C38().runTests();
+ new C38<int>(tIsInt: true).runTests();
+ new C38<bool>(tIsBool: true).runTests();
+ new C39().runTests();
+ new C39<int>(tIsInt: true).runTests();
+ new C39<bool>(tIsBool: true).runTests();
+ new C40().runTests();
+ new C40<int>(tIsInt: true).runTests();
+ new C40<bool>(tIsBool: true).runTests();
+ new C41().runTests();
+ new C41<int>(tIsInt: true).runTests();
+ new C41<bool>(tIsBool: true).runTests();
+ new C42().runTests();
+ new C42<int>(tIsInt: true).runTests();
+ new C42<bool>(tIsBool: true).runTests();
+ new C43().runTests();
+ new C43<int>(tIsInt: true).runTests();
+ new C43<bool>(tIsBool: true).runTests();
+ new C44().runTests();
+ new C44<int>(tIsInt: true).runTests();
+ new C44<bool>(tIsBool: true).runTests();
+ new C45().runTests();
+ new C45<int>(tIsInt: true).runTests();
+ new C45<bool>(tIsBool: true).runTests();
+ new C46().runTests();
+ new C46<int>(tIsInt: true).runTests();
+ new C46<bool>(tIsBool: true).runTests();
+ new C47().runTests();
+ new C47<int>(tIsInt: true).runTests();
+ new C47<bool>(tIsBool: true).runTests();
+ new C48().runTests();
+ new C48<int>(tIsInt: true).runTests();
+ new C48<bool>(tIsBool: true).runTests();
+ new C49().runTests();
+ new C49<int>(tIsInt: true).runTests();
+ new C49<bool>(tIsBool: true).runTests();
+ new C50().runTests();
+ new C50<int>(tIsInt: true).runTests();
+ new C50<bool>(tIsBool: true).runTests();
+ new C51().runTests();
+ new C51<int>(tIsInt: true).runTests();
+ new C51<bool>(tIsBool: true).runTests();
+ new C52().runTests();
+ new C52<int>(tIsInt: true).runTests();
+ new C52<bool>(tIsBool: true).runTests();
+ new C53().runTests();
+ new C53<int>(tIsInt: true).runTests();
+ new C53<bool>(tIsBool: true).runTests();
+ new C54().runTests();
+ new C54<int>(tIsInt: true).runTests();
+ new C54<bool>(tIsBool: true).runTests();
+ new C55().runTests();
+ new C55<int>(tIsInt: true).runTests();
+ new C55<bool>(tIsBool: true).runTests();
+ new C56().runTests();
+ new C56<int>(tIsInt: true).runTests();
+ new C56<bool>(tIsBool: true).runTests();
+ new C57().runTests();
+ new C57<int>(tIsInt: true).runTests();
+ new C57<bool>(tIsBool: true).runTests();
+ new C58().runTests();
+ new C58<int>(tIsInt: true).runTests();
+ new C58<bool>(tIsBool: true).runTests();
+ new C59().runTests();
+ new C59<int>(tIsInt: true).runTests();
+ new C59<bool>(tIsBool: true).runTests();
+ new C60().runTests();
+ new C60<int>(tIsInt: true).runTests();
+ new C60<bool>(tIsBool: true).runTests();
+ new C61().runTests();
+ new C61<int>(tIsInt: true).runTests();
+ new C61<bool>(tIsBool: true).runTests();
+ new C62().runTests();
+ new C62<int>(tIsInt: true).runTests();
+ new C62<bool>(tIsBool: true).runTests();
+ new C63().runTests();
+ new C63<int>(tIsInt: true).runTests();
+ new C63<bool>(tIsBool: true).runTests();
+ new C64().runTests();
+ new C64<int>(tIsInt: true).runTests();
+ new C64<bool>(tIsBool: true).runTests();
+ new C65().runTests();
+ new C65<int>(tIsInt: true).runTests();
+ new C65<bool>(tIsBool: true).runTests();
+ new C66().runTests();
+ new C66<int>(tIsInt: true).runTests();
+ new C66<bool>(tIsBool: true).runTests();
+ new C67().runTests();
+ new C67<int>(tIsInt: true).runTests();
+ new C67<bool>(tIsBool: true).runTests();
+ new C68().runTests();
+ new C68<int>(tIsInt: true).runTests();
+ new C68<bool>(tIsBool: true).runTests();
+ new C69().runTests();
+ new C69<int>(tIsInt: true).runTests();
+ new C69<bool>(tIsBool: true).runTests();
+ new C70().runTests();
+ new C70<int>(tIsInt: true).runTests();
+ new C70<bool>(tIsBool: true).runTests();
+ new C71().runTests();
+ new C71<int>(tIsInt: true).runTests();
+ new C71<bool>(tIsBool: true).runTests();
+ new C72().runTests();
+ new C72<int>(tIsInt: true).runTests();
+ new C72<bool>(tIsBool: true).runTests();
+ new C73().runTests();
+ new C73<int>(tIsInt: true).runTests();
+ new C73<bool>(tIsBool: true).runTests();
+ new C74().runTests();
+ new C74<int>(tIsInt: true).runTests();
+ new C74<bool>(tIsBool: true).runTests();
+ new C75().runTests();
+ new C75<int>(tIsInt: true).runTests();
+ new C75<bool>(tIsBool: true).runTests();
+ new C76().runTests();
+ new C76<int>(tIsInt: true).runTests();
+ new C76<bool>(tIsBool: true).runTests();
+ new C77().runTests();
+ new C77<int>(tIsInt: true).runTests();
+ new C77<bool>(tIsBool: true).runTests();
+ new C78().runTests();
+ new C78<int>(tIsInt: true).runTests();
+ new C78<bool>(tIsBool: true).runTests();
+ new C79().runTests();
+ new C79<int>(tIsInt: true).runTests();
+ new C79<bool>(tIsBool: true).runTests();
+ new C80().runTests();
+ new C80<int>(tIsInt: true).runTests();
+ new C80<bool>(tIsBool: true).runTests();
+ new C81().runTests();
+ new C81<int>(tIsInt: true).runTests();
+ new C81<bool>(tIsBool: true).runTests();
+ new C82().runTests();
+ new C82<int>(tIsInt: true).runTests();
+ new C82<bool>(tIsBool: true).runTests();
+ new C83().runTests();
+ new C83<int>(tIsInt: true).runTests();
+ new C83<bool>(tIsBool: true).runTests();
+ new C84().runTests();
+ new C84<int>(tIsInt: true).runTests();
+ new C84<bool>(tIsBool: true).runTests();
+ new C85().runTests();
+ new C85<int>(tIsInt: true).runTests();
+ new C85<bool>(tIsBool: true).runTests();
+ new C86().runTests();
+ new C86<int>(tIsInt: true).runTests();
+ new C86<bool>(tIsBool: true).runTests();
+ new C87().runTests();
+ new C87<int>(tIsInt: true).runTests();
+ new C87<bool>(tIsBool: true).runTests();
+ new C88().runTests();
+ new C88<int>(tIsInt: true).runTests();
+ new C88<bool>(tIsBool: true).runTests();
+ new C89().runTests();
+ new C89<int>(tIsInt: true).runTests();
+ new C89<bool>(tIsBool: true).runTests();
+ new C90().runTests();
+ new C90<int>(tIsInt: true).runTests();
+ new C90<bool>(tIsBool: true).runTests();
+ new C91().runTests();
+ new C91<int>(tIsInt: true).runTests();
+ new C91<bool>(tIsBool: true).runTests();
+ new C92().runTests();
+ new C92<int>(tIsInt: true).runTests();
+ new C92<bool>(tIsBool: true).runTests();
+ new C93().runTests();
+ new C93<int>(tIsInt: true).runTests();
+ new C93<bool>(tIsBool: true).runTests();
+ new C94().runTests();
+ new C94<int>(tIsInt: true).runTests();
+ new C94<bool>(tIsBool: true).runTests();
+ new C95().runTests();
+ new C95<int>(tIsInt: true).runTests();
+ new C95<bool>(tIsBool: true).runTests();
+ new C96().runTests();
+ new C96<int>(tIsInt: true).runTests();
+ new C96<bool>(tIsBool: true).runTests();
+ new C97().runTests();
+ new C97<int>(tIsInt: true).runTests();
+ new C97<bool>(tIsBool: true).runTests();
+ new C98().runTests();
+ new C98<int>(tIsInt: true).runTests();
+ new C98<bool>(tIsBool: true).runTests();
+ new C99().runTests();
+ new C99<int>(tIsInt: true).runTests();
+ new C99<bool>(tIsBool: true).runTests();
+}
diff --git a/tests/language/generic_function_typedef2_test.dart b/tests/language/generic_function_typedef2_test.dart
new file mode 100644
index 0000000..a5698bd
--- /dev/null
+++ b/tests/language/generic_function_typedef2_test.dart
@@ -0,0 +1,42 @@
+// Copyright (c) 2012, 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.
+// Dart test for a function type test that cannot be eliminated at compile time.
+
+import "package:expect/expect.dart";
+
+class A {}
+
+typedef int F();
+
+typedef G = F; /// 00: compile-time error
+typedef H = int; /// 01: compile-time error
+typedef I = A; /// 02: compile-time error
+typedef J = List<int>; /// 03: compile-time error
+typedef K = Function(Function<A>(A
+ <int> /// 04: static type warning
+ ));
+typedef L = Function({
+ /* /// 05: compile-time error
+ bool
+ */ /// 05: compile-time error
+ x});
+
+typedef M = Function({
+ /* /// 06: compile-time error
+ bool
+ */ /// 06: compile-time error
+ int});
+
+foo({bool int}) {}
+main() {
+ bool b = true;
+ Expect.isFalse(b is G); /// 00: continued
+ Expect.isFalse(b is H); /// 01: continued
+ Expect.isFalse(b is I); /// 02: continued
+ Expect.isFalse(b is J); /// 03: continued
+ Expect.isFalse(b is K); /// 04: continued
+ Expect.isFalse(b is L);
+ Expect.isFalse(b is M);
+ Expect.isTrue(foo is M);
+}
diff --git a/tests/language/generic_function_typedef_test.dart b/tests/language/generic_function_typedef_test.dart
new file mode 100644
index 0000000..eb8fb18
--- /dev/null
+++ b/tests/language/generic_function_typedef_test.dart
@@ -0,0 +1,24 @@
+// Copyright (c) 2012, 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.
+// Dart test for a function type test that cannot be eliminated at compile time.
+
+import "package:expect/expect.dart";
+
+class A {
+}
+
+typedef F<T> = Function<S>(List<S> list, Function<A>(A), T);
+
+foo(List<dynamic> x, bar(String y), int z) {}
+foo2(List<int> x, bar(String y), int z) {}
+
+main() {
+ Expect.isTrue(foo is F);
+ Expect.isTrue(foo is F<int>);
+ Expect.isFalse(foo is F<bool>);
+
+ Expect.isTrue(foo2 is F);
+ Expect.isTrue(foo2 is F<int>);
+ Expect.isFalse(foo2 is F<bool>);
+}
diff --git a/tests/language/language.status b/tests/language/language.status
index 83da9ad..4c42b55 100644
--- a/tests/language/language.status
+++ b/tests/language/language.status
@@ -53,9 +53,10 @@
async_star_regression_2238_test: CompileTimeError, RuntimeError # drt only runtime-errs.
-# Doesn't yet implement `covariant` keyword.
-covariant_test/none: Fail # Issue 28166
-covariant_override_test: Fail # Issue 28166
+generic_function_typedef_test: Fail # Issue 27966
+generic_function_typedef2_test/none: Fail # Issue 27966
+generic_function_typedef2_test/04: Fail # Issue 27966
+generalized_function_type_test: Fail # Issue 27966
[ ($compiler == none || $compiler == precompiler || $compiler == app_jit) && $checked ]
# These generic functions tests pass for the wrong reason in checked mode,
@@ -160,7 +161,7 @@
[ $compiler == precompiler && $runtime == dart_precompiled ]
vm/regress_27671_test: Skip # Unsupported
-[ $noopt || $runtime == dart_precompiled ]
+[ $runtime == dart_precompiled ]
# Stacktraces in precompilation omit inlined frames.
full_stacktrace1_test: Pass, RuntimeError
full_stacktrace2_test: Pass, RuntimeError
@@ -172,7 +173,7 @@
vm/regress_28325_test: RuntimeError # Missing source position in AOT.
-[ $noopt || $runtime == dart_precompiled || $mode == product ]
+[ $runtime == dart_precompiled || $mode == product ]
# Imports dart:mirrors
const_evaluation_test: SkipByDesign
deferred_constraints_constants_test: SkipByDesign
@@ -196,18 +197,6 @@
vm/reflect_core_vm_test: SkipByDesign
regress_28255_test: SkipByDesign
-[ $noopt ]
-# Deferred loading happens eagerly. Issue #27587
-regress_23408_test: Fail
-deferred_inheritance_constraints_test/redirecting_constructor: Fail
-deferred_global_test: Fail
-deferred_load_constants_test/02: Fail
-deferred_load_constants_test/03: Fail
-deferred_load_constants_test/05: Fail
-regress_22443_test: Fail
-deferred_not_loaded_check_test: Fail
-vm/regress_27201_test: Fail
-
[ $mode == product || $compiler == app_jit || $compiler == precompiler ]
# Deferred loading happens eagerly. Issue #27587
regress_23408_test: Fail
@@ -223,15 +212,13 @@
deferred_global_test: Fail
vm/regress_27201_test: Fail
-[ $compiler == precompiler || $compiler == app_jit ]
-ct_const2_test: Skip # Incompatible flag: --compile_all
-hello_dart_test: Skip # Incompatible flag: --compile_all
-
[ $compiler == precompiler ]
implicit_closure_test: Skip # Incompatible flag: --use_slow_path
deopt_inlined_function_lazy_test: Skip # Incompatible flag: --deoptimize-alot
-[ $noopt || $compiler == precompiler || $compiler == app_jit ]
+[ $compiler == precompiler || $compiler == app_jit ]
+ct_const2_test: Skip # Incompatible flag: --compile_all
+hello_dart_test: Skip # Incompatible flag: --compile_all
vm/type_vm_test: RuntimeError # Expects line and column numbers
vm/type_cast_vm_test: RuntimeError # Expects line and column numbers
@@ -261,11 +248,11 @@
library_env_test/has_html_support: RuntimeError, OK
library_env_test/has_no_io_support: RuntimeError, OK
-[ ($compiler == none || $compiler == app_jit) && $noopt == false && $mode != product ]
+[ ($compiler == none || $compiler == app_jit) && $mode != product ]
# The following tests are supposed to fail.
library_env_test/has_no_mirror_support: RuntimeError, OK
-[ $noopt || $runtime == dart_precompiled || $mode == product ]
+[ $runtime == dart_precompiled || $mode == product ]
# The following tests are supposed to fail.
library_env_test/has_mirror_support: RuntimeError, OK
diff --git a/tests/language/language_analyzer2.status b/tests/language/language_analyzer2.status
index bb12210..9925bfba6 100644
--- a/tests/language/language_analyzer2.status
+++ b/tests/language/language_analyzer2.status
@@ -8,12 +8,38 @@
regress_27617_test/1: MissingCompileTimeError
# Doesn't yet implement `covariant` keyword.
-covariant_test/none: CompileTimeError # Issue 28167
+covariant_test/06: MissingCompileTimeError # Issue 28167
+covariant_test/06b: MissingCompileTimeError # Issue 28167
+covariant_test/07: MissingCompileTimeError # Issue 28167
+covariant_test/08: MissingCompileTimeError # Issue 28167
+covariant_test/11: MissingCompileTimeError # Issue 28167
+covariant_test/15: MissingCompileTimeError # Issue 28167
+covariant_test/26: MissingCompileTimeError # Issue 28167
+covariant_test/26b: MissingCompileTimeError # Issue 28167
+covariant_test/27: MissingCompileTimeError # Issue 28167
+covariant_test/28: MissingCompileTimeError # Issue 28167
+covariant_test/31: MissingCompileTimeError # Issue 28167
+covariant_test/35: MissingCompileTimeError # Issue 28167
+covariant_test/40: CompileTimeError # Issue 28167
+covariant_test/40b: CompileTimeError # Issue 28167
+covariant_test/42: CompileTimeError # Issue 28167
+covariant_test/46: MissingCompileTimeError # Issue 28167
+covariant_test/46b: MissingCompileTimeError # Issue 28167
+covariant_test/47: MissingCompileTimeError # Issue 28167
+covariant_test/48: StaticWarning
+covariant_test/51: MissingCompileTimeError # Issue 28167
+covariant_test/52: CompileTimeError # Issue 28167
+covariant_test/54: CompileTimeError # Issue 28167
+covariant_test/55: MissingCompileTimeError # Issue 28167
+covariant_test/56: CompileTimeError # Issue 28167
covariant_override_test: CompileTimeError # Issue 28167
# Runtime negative test. No static errors or warnings.
closure_call_wrong_argument_count_negative_test: skip
+# No longer support the old use of typedef to define a mixin
+mixin_illegal_syntax_test/00: Crash
+
deep_nesting1_negative_test: Crash # Issue 25558
deep_nesting2_negative_test: Crash # Issue 25558
@@ -55,6 +81,10 @@
null_is_bottom_type_test/14: StaticWarning # Issue 28027
null_is_bottom_type_test/15: StaticWarning # Issue 28027
+generic_function_typedef_test: Crash # Issue 27969
+generic_function_typedef2_test: Crash # Issue 27969
+generalized_function_type_test: Crash # Issue 27969
+
# Please add new failing tests before this line.
# Section below is for invalid tests.
#
diff --git a/tests/language/language_dart2js.status b/tests/language/language_dart2js.status
index f97480a..fb1f295 100644
--- a/tests/language/language_dart2js.status
+++ b/tests/language/language_dart2js.status
@@ -39,6 +39,12 @@
duplicate_part_test/01: MissingCompileTimeError # Issue 27517
bad_typedef_test/00: Crash # Issue 28214
+generic_function_typedef2_test/00: Crash # Issue 28214
+generic_function_typedef2_test/01: Crash # Issue 28214
+generic_function_typedef2_test/02: Crash # Issue 28214
+generic_function_typedef2_test/03: Crash # Issue 28214
+generic_function_typedef2_test/05: Crash # Issue 28214
+generic_function_typedef2_test/06: Crash # Issue 28214
covariant_test/02: MissingCompileTimeError, OK # Accepts `covariant` for statics/top-level.
covariant_test/08: MissingCompileTimeError, OK # Accepts `covariant` for statics/top-level.
diff --git a/tests/language/language_kernel.status b/tests/language/language_kernel.status
index 144c004..4dd9ab3 100644
--- a/tests/language/language_kernel.status
+++ b/tests/language/language_kernel.status
@@ -48,8 +48,36 @@
vm/reflect_core_vm_test: DartkCompileTimeError
vm/regress_27201_test: DartkCompileTimeError
vm/regress_28325_test: RuntimeError # Issue 28055.
-covariant_test/none: CompileTimeError # Issue 28166
+covariant_test/06: MissingCompileTimeError # 28166
+covariant_test/06b: MissingCompileTimeError # 28166
+covariant_test/07: MissingCompileTimeError # 28166
+covariant_test/08: MissingCompileTimeError # 28166
+covariant_test/11: MissingCompileTimeError # 28166
+covariant_test/15: MissingCompileTimeError # 28166
+covariant_test/26: MissingCompileTimeError # 28166
+covariant_test/26b: MissingCompileTimeError # 28166
+covariant_test/27: MissingCompileTimeError # 28166
+covariant_test/28: MissingCompileTimeError # 28166
+covariant_test/31: MissingCompileTimeError # 28166
+covariant_test/35: MissingCompileTimeError # 28166
+covariant_test/40: DartkCompileTimeError # 28166
+covariant_test/40b: DartkCompileTimeError # 28166
+covariant_test/42: DartkCompileTimeError # 28166
+covariant_test/46: MissingCompileTimeError # 28166
+covariant_test/46b: MissingCompileTimeError # 28166
+covariant_test/47: MissingCompileTimeError # 28166
+covariant_test/51: MissingCompileTimeError # 28166
+covariant_test/52: DartkCompileTimeError # 28166
+covariant_test/54: DartkCompileTimeError # 28166
+covariant_test/55: MissingCompileTimeError # 28166
+covariant_test/56: DartkCompileTimeError # 28166
covariant_override_test: DartkCrash # Issue 28166
+generalized_function_type_test: DartkCrash # Issue 27966
+generic_function_typedef2_test: DartkCrash # Issue 27966
+generic_function_typedef_test: DartkCrash # Issue 27966
+
+# dartk: temporary failure
+mixin_illegal_syntax_test/00: DartkCrash
# dartk: JIT failures
[ $compiler == dartk && $runtime == vm ]
@@ -64,7 +92,6 @@
[ $compiler == dartkp && $runtime == dart_precompiled ]
config_import_corelib_test: RuntimeError
-
###############################################################################
# VM Entries
###############################################################################
diff --git a/tests/language/regress_27700_test.dart b/tests/language/regress_27700_test.dart
new file mode 100644
index 0000000..4366962
--- /dev/null
+++ b/tests/language/regress_27700_test.dart
@@ -0,0 +1,10 @@
+// Copyright (c) 2017, 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.
+
+// Regression test for issue 27700.
+
+main(){
+ var x = new List(0);
+ var z = "$x";
+}
\ No newline at end of file
diff --git a/tests/lib/lib.status b/tests/lib/lib.status
index 9598983..6ea31a2 100644
--- a/tests/lib/lib.status
+++ b/tests/lib/lib.status
@@ -412,13 +412,10 @@
[ $compiler != dart2js ]
async/dart2js_uncaught_error_test: Skip # JS-integration only test
-[ $noopt && $arch == simarm64 ]
-async/slow_consumer2_test: Pass, RuntimeError # Issue 25726
-
-[ $noopt || $compiler == precompiler || $mode == product ]
+[ $compiler == precompiler || $mode == product ]
mirrors/*: SkipByDesign
-[ $noopt || $compiler == precompiler ]
+[ $compiler == precompiler ]
convert/chunked_conversion_utf88_test: Pass, Timeout
convert/utf85_test: Pass, Timeout
diff --git a/tests/standalone/io/http_client_request_test.dart b/tests/standalone/io/http_client_request_test.dart
index 9015b9f..cd2a7be 100644
--- a/tests/standalone/io/http_client_request_test.dart
+++ b/tests/standalone/io/http_client_request_test.dart
@@ -108,25 +108,8 @@
}
-void testBadHeaders() {
- asyncStart();
- testClientRequest((request) {
- var value = "a";
- for (int i = 0; i < 8 * 1024; i++) {
- value += 'a';
- }
- request.headers.set('name', value);
- request.done.catchError((error) {
- asyncEnd();
- }, test: (e) => e is HttpException);
- return request.close();
- });
-}
-
-
void main() {
testResponseDone();
testBadResponseAdd();
testBadResponseClose();
- testBadHeaders();
}
diff --git a/tests/standalone/io/http_server_response_test.dart b/tests/standalone/io/http_server_response_test.dart
index c3c0afb..a6c06af 100644
--- a/tests/standalone/io/http_server_response_test.dart
+++ b/tests/standalone/io/http_server_response_test.dart
@@ -281,20 +281,6 @@
}
-void testBadHeaders() {
- testServerRequest((server, request) {
- var value = "a";
- for (int i = 0; i < 8 * 1024; i++) {
- value += 'a';
- }
- request.response.headers.set('name', value);
- request.response.close().catchError((error) {
- server.close();
- }, test: (e) => e is HttpException);
- });
-}
-
-
void testWriteCharCode() {
testServerRequest((server, request) {
// Test that default is latin-1 (only 2 bytes).
@@ -315,6 +301,5 @@
testBadResponseAdd();
testBadResponseClose();
testIgnoreRequestData();
- testBadHeaders();
testWriteCharCode();
}
diff --git a/tests/standalone/standalone.status b/tests/standalone/standalone.status
index 76e42fb..f76dc04 100644
--- a/tests/standalone/standalone.status
+++ b/tests/standalone/standalone.status
@@ -8,6 +8,7 @@
# prefix.
io/raw_socket_test: Pass, RuntimeError # Issue 28288
+io/http_close_test: Pass, RuntimeError # Issue 28380
packages_file_test: Skip # Issue 26715
packages_file_test/none: Skip # contains no tests.
@@ -21,7 +22,7 @@
issue14236_test: Pass # Do not remove this line. It serves as a marker for Issue 14516 comment #4.
-[ ($runtime != vm && $runtime != dart_precompiled) && ($runtime != drt || $compiler != none)) ]
+[ ($runtime != vm && $runtime != dart_precompiled) && ($runtime != drt || $compiler != none) ]
no_assert_test: Fail, OK # This is testing a vm flag.
env_test: Skip # This is testing a vm command line parsing scenario.
@@ -222,11 +223,9 @@
no_allow_absolute_addresses_test: SkipByDesign # Not supported.
link_natives_lazily_test: SkipByDesign # Not supported.
-[ $noopt || $compiler == precompiler ]
+[ $compiler == precompiler ]
# Stacktraces in precompilation omit inlined frames.
assert_test: Pass, RuntimeError
-
-[ $noopt || $compiler == precompiler ]
map_insert_remove_oom_test: Skip # Heap limit too low. Increasing iteration count to make a higher limit a meaningful test makes it too slow for simarm[64] bots.
io/web_socket_test: Pass, RuntimeError # Issue 24674
@@ -281,6 +280,10 @@
io/platform_test: RuntimeError # Expects to be running from 'dart' instead of 'dart_precompiled_runtime'
io/directory_list_sync_test: Timeout, Skip # Expects to find the test directory relative to the script.
+[ $runtime == vm && $system == windows && $mode == release ]
+io/http_server_close_response_after_error_test: Pass, Timeout # Issue 28370: timeout.
+io/regress_7191_test: Pass, Timeout # Issue 28374: timeout.
+
[ $runtime == dart_precompiled || $mode == product ]
io/skipping_dart2js_compilations_test: CompileTimeError # Imports dart:mirrors
io/test_harness_analyzer_test: CompileTimeError # Imports dart:mirrors
@@ -379,3 +382,12 @@
io/directory_error_test: Fail # Issue 28350
io/directory_fuzz_test: Fail # Issue 28350
io/directory_list_nonexistent_test: Fail # Issue 28350
+
+io/stdout_bad_argument_test: Fail # Issue 28353
+io/file_blocking_lock_test: Fail # Issue 28353
+
+io/process_sync_test: RuntimeError
+io/signals_test: RuntimeError
+io/regress_7191_test: RuntimeError
+io/named_pipe_script_test: RuntimeError
+io/http_server_close_response_after_error_test: RuntimeError
diff --git a/tools/VERSION b/tools/VERSION
index 9b9676a..93e6780 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 1
MINOR 22
PATCH 0
-PRERELEASE 7
+PRERELEASE 8
PRERELEASE_PATCH 0
diff --git a/tools/testing/dart/compiler_configuration.dart b/tools/testing/dart/compiler_configuration.dart
index b777fb7..f78b916 100644
--- a/tools/testing/dart/compiler_configuration.dart
+++ b/tools/testing/dart/compiler_configuration.dart
@@ -565,7 +565,12 @@
CommandBuilder commandBuilder,
List arguments,
Map<String, String> environmentOverrides) {
- var exec = "$buildDir/dart_bootstrap";
+ var exec;
+ if (isAndroid && arch == 'arm') {
+ exec = "$buildDir/clang_x86/dart_bootstrap";
+ } else {
+ exec = "$buildDir/dart_bootstrap";
+ }
var args = new List();
args.add("--snapshot-kind=app-aot");
if (useBlobs) {
diff --git a/tools/testing/dart/runtime_configuration.dart b/tools/testing/dart/runtime_configuration.dart
index 87fd0f5..5fb1007 100644
--- a/tools/testing/dart/runtime_configuration.dart
+++ b/tools/testing/dart/runtime_configuration.dart
@@ -234,9 +234,7 @@
type != 'application/dart-snapshot') {
throw "Dart VM cannot run files of type '$type'.";
}
- String executable = suite.configuration['noopt']
- ? suite.dartVmNooptBinaryFileName
- : suite.dartVmBinaryFileName;
+ String executable = suite.dartVmBinaryFileName;
return <Command>[
commandBuilder.getVmCommand(executable, arguments, environmentOverrides)
];
diff --git a/tools/testing/dart/test_configurations.dart b/tools/testing/dart/test_configurations.dart
index 1f73fe5..ee68349 100644
--- a/tools/testing/dart/test_configurations.dart
+++ b/tools/testing/dart/test_configurations.dart
@@ -107,7 +107,6 @@
.toList();
if (conf['checked']) settings.add('checked');
if (conf['strong']) settings.add('strong');
- if (conf['noopt']) settings.add('noopt');
output_words.add(settings.join('_'));
}
print(output_words.join(' '));
diff --git a/tools/testing/dart/test_options.dart b/tools/testing/dart/test_options.dart
index b9ad0f4..e83c670 100644
--- a/tools/testing/dart/test_options.dart
+++ b/tools/testing/dart/test_options.dart
@@ -207,9 +207,6 @@
false,
type: 'bool'),
new _TestOptionSpecification(
- 'noopt', 'Run an in-place precompilation', ['--noopt'], [], false,
- type: 'bool'),
- new _TestOptionSpecification(
'fast_startup',
'Pass the --fast-startup flag to dart2js',
['--fast-startup'],
diff --git a/tools/testing/dart/test_suite.dart b/tools/testing/dart/test_suite.dart
index 289aaf3..4aa99f4 100644
--- a/tools/testing/dart/test_suite.dart
+++ b/tools/testing/dart/test_suite.dart
@@ -216,21 +216,6 @@
return flutterExecutable;
}
- String get dartVmNooptBinaryFileName {
- // Controlled by user with the option "--dart".
- String dartExecutable = configuration['dart'];
-
- if (dartExecutable == '') {
- String suffix = executableBinarySuffix;
- dartExecutable = useSdk
- ? '$buildDir/dart-sdk/bin/dart_noopt$suffix'
- : '$buildDir/dart_noopt$suffix';
- }
-
- TestUtils.ensureExists(dartExecutable, configuration);
- return dartExecutable;
- }
-
String get dartPrecompiledBinaryFileName {
// Controlled by user with the option "--dart_precompiled".
String dartExecutable = configuration['dart_precompiled'];
diff --git a/utils/application_snapshot.gni b/utils/application_snapshot.gni
index 8899703e..ffc0653 100644
--- a/utils/application_snapshot.gni
+++ b/utils/application_snapshot.gni
@@ -49,3 +49,48 @@
] + training_args
}
}
+
+# TODO(28368): Revert to application snapshot after spawnUri issue is fixed.
+template("script_snapshot") {
+ assert(defined(invoker.main_dart), "Must specify 'main_dart'")
+ assert(defined(invoker.training_args), "Must specify 'training_args'")
+ main_dart = invoker.main_dart
+ training_args = invoker.training_args
+ name = target_name
+ if (defined(invoker.name)) {
+ name = invoker.name
+ }
+ extra_deps = []
+ if (defined(invoker.deps)) {
+ extra_deps += invoker.deps
+ }
+ extra_inputs = []
+ if (defined(invoker.inputs)) {
+ extra_inputs += invoker.inputs
+ }
+ compiled_action(target_name) {
+ tool = get_path_info("$_dart_root/runtime/bin:dart", "abspath")
+ deps = extra_deps + [ "$_dart_root/pkg:pkg_files_stamp" ]
+
+ inputs = extra_inputs + [
+ "$_dart_root/sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart",
+ "$root_gen_dir/pkg_files.stamp",
+ ]
+
+ output = "$root_gen_dir/$name.dart.snapshot"
+ outputs = [
+ output,
+ ]
+
+ dot_packages = rebase_path("$_dart_root/.packages")
+ abs_output = rebase_path(output)
+ main_file = rebase_path(main_dart)
+
+ args = [
+ "--packages=$dot_packages",
+ "--snapshot=$abs_output",
+ "--snapshot-kind=script",
+ main_file,
+ ] + training_args
+ }
+}
diff --git a/utils/pub/BUILD.gn b/utils/pub/BUILD.gn
index 33cea34..ab4da0a 100644
--- a/utils/pub/BUILD.gn
+++ b/utils/pub/BUILD.gn
@@ -4,7 +4,7 @@
import("../application_snapshot.gni")
-application_snapshot("pub") {
+script_snapshot("pub") {
main_dart = "../../third_party/pkg/pub/bin/pub.dart"
training_args = [ "--help" ]
deps = [
