Version 1.22.0-dev.9.0
Merge 6a4d70ef3a156f5a5a236757ff81a12d9da033fa into dev
diff --git a/DEPS b/DEPS
index caf046e..17aaded 100644
--- a/DEPS
+++ b/DEPS
@@ -75,7 +75,7 @@
"isolate_tag": "@0.2.3",
"jinja2_rev": "@2222b31554f03e62600cd7e383376a7c187967a1",
"json_rpc_2_tag": "@2.0.2",
- "linter_rev": "@393695e77bf95213130935e969e86140cb322667",
+ "linter_rev": "@89f93362c5b48ef5192d77e9a28cf9590542669b",
"logging_tag": "@0.11.3+1",
"markdown_tag": "@0.11.0",
"matcher_tag": "@0.12.0+2",
diff --git a/build/config/gcc/BUILD.gn b/build/config/gcc/BUILD.gn
index 47bcc0b..110f1cc 100644
--- a/build/config/gcc/BUILD.gn
+++ b/build/config/gcc/BUILD.gn
@@ -31,6 +31,7 @@
# Want to pass "\$". GN will re-escape as required for ninja.
"-Wl,-rpath=\$ORIGIN/",
"-Wl,-rpath-link=",
+ "-Wl,-z,origin",
# Newer binutils don't set DT_RPATH unless you disable "new" dtags
# and the new DT_RUNPATH doesn't work without --no-as-needed flag.
diff --git a/pkg/analysis_server/lib/src/analysis_server.dart b/pkg/analysis_server/lib/src/analysis_server.dart
index 869bd81..3a9d6b3 100644
--- a/pkg/analysis_server/lib/src/analysis_server.dart
+++ b/pkg/analysis_server/lib/src/analysis_server.dart
@@ -1833,9 +1833,9 @@
resourceProvider,
analysisServer.byteStore,
analysisServer.fileContentOverlay,
+ folder.path,
sourceFactory,
analysisOptions);
- analysisDriver.name = folder.path;
analysisDriver.status.listen((status) {
// TODO(scheglov) send server status
});
diff --git a/pkg/analysis_server/lib/src/server/driver.dart b/pkg/analysis_server/lib/src/server/driver.dart
index ea6074e..072fa75 100644
--- a/pkg/analysis_server/lib/src/server/driver.dart
+++ b/pkg/analysis_server/lib/src/server/driver.dart
@@ -242,10 +242,9 @@
"incremental-resolution-validation";
/**
- * The name of the option used to disable using the new analysis driver.
+ * The name of the option used to enable using the new analysis driver.
*/
- static const String DISABLE_NEW_ANALYSIS_DRIVER =
- 'disable-new-analysis-driver';
+ static const String ENABLE_NEW_ANALYSIS_DRIVER = 'enable-new-analysis-driver';
/**
* The name of the option used to enable using pub summary manager.
@@ -394,7 +393,7 @@
analysisServerOptions.enableIncrementalResolutionValidation =
results[INCREMENTAL_RESOLUTION_VALIDATION];
analysisServerOptions.enableNewAnalysisDriver =
- !results[DISABLE_NEW_ANALYSIS_DRIVER];
+ results[ENABLE_NEW_ANALYSIS_DRIVER];
analysisServerOptions.enablePubSummaryManager =
results[ENABLE_PUB_SUMMARY_MANAGER];
analysisServerOptions.finerGrainedInvalidation =
@@ -544,8 +543,8 @@
help: "enable validation of incremental resolution results (slow)",
defaultsTo: false,
negatable: false);
- parser.addFlag(DISABLE_NEW_ANALYSIS_DRIVER,
- help: "disable using new analysis driver",
+ parser.addFlag(ENABLE_NEW_ANALYSIS_DRIVER,
+ help: "enable using new analysis driver",
defaultsTo: false,
negatable: false);
parser.addFlag(ENABLE_PUB_SUMMARY_MANAGER,
diff --git a/pkg/analysis_server/lib/src/services/correction/assist_internal.dart b/pkg/analysis_server/lib/src/services/correction/assist_internal.dart
index 27cc2cf..c92920d 100644
--- a/pkg/analysis_server/lib/src/services/correction/assist_internal.dart
+++ b/pkg/analysis_server/lib/src/services/correction/assist_internal.dart
@@ -338,7 +338,7 @@
DartType type = initializer.bestType;
// prepare type source
String typeSource;
- if (type is InterfaceType || type is FunctionType) {
+ if (type is InterfaceType && !type.isDartCoreNull || type is FunctionType) {
_configureTargetLocation(node);
Set<Source> librariesToImport = new Set<Source>();
typeSource = utils.getTypeSource(type, librariesToImport);
diff --git a/pkg/analysis_server/lib/src/services/correction/fix_internal.dart b/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
index 325f723..c29be04 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
@@ -2402,8 +2402,11 @@
void _appendParameterForArgument(
SourceBuilder sb, Set<String> excluded, int index, Expression argument) {
- // append type name
DartType type = argument.bestType;
+ if (type == null || type.isBottom || type.isDartCoreNull) {
+ type = DynamicTypeImpl.instance;
+ }
+ // append type name
String typeSource = utils.getTypeSource(type, librariesToImport);
if (typeSource != 'dynamic') {
sb.startPosition('TYPE$index');
diff --git a/pkg/analysis_server/lib/src/services/correction/util.dart b/pkg/analysis_server/lib/src/services/correction/util.dart
index 82217a2..cbed44a 100644
--- a/pkg/analysis_server/lib/src/services/correction/util.dart
+++ b/pkg/analysis_server/lib/src/services/correction/util.dart
@@ -1129,8 +1129,8 @@
parametersBuffer.write(')');
return getTypeSource(type.returnType, librariesToImport);
}
- // BottomType
- if (type.isBottom) {
+ // <Bottom>, Null
+ if (type.isBottom || type.isDartCoreNull) {
return 'dynamic';
}
// prepare element
diff --git a/pkg/analysis_server/test/abstract_context.dart b/pkg/analysis_server/test/abstract_context.dart
index 6d804be..b0750f2 100644
--- a/pkg/analysis_server/test/abstract_context.dart
+++ b/pkg/analysis_server/test/abstract_context.dart
@@ -154,6 +154,7 @@
provider,
new MemoryByteStore(),
_fileContentOverlay,
+ 'test',
sourceFactory,
new AnalysisOptionsImpl());
scheduler.start();
diff --git a/pkg/analysis_server/test/completion_test.dart b/pkg/analysis_server/test/completion_test.dart
index 46a33fc..154f29b 100644
--- a/pkg/analysis_server/test/completion_test.dart
+++ b/pkg/analysis_server/test/completion_test.dart
@@ -863,8 +863,7 @@
'testCommentSnippets083b',
'''
main() { null.!1 }''',
- <String>["1+toString"],
- failingTests: '1');
+ <String>["1+toString"]);
buildTests(
'testCommentSnippets085',
@@ -2648,8 +2647,7 @@
}''',
<String>["1+true", "1+truefalse", "1-falsetrue"]);
- buildTests('test020', '''var x = null.!1''', <String>["1+toString"],
- failingTests: '1');
+ buildTests('test020', '''var x = null.!1''', <String>["1+toString"]);
buildTests('test021', '''var x = .!1''', <String>["1-toString"]);
diff --git a/pkg/analysis_server/test/context_manager_test.dart b/pkg/analysis_server/test/context_manager_test.dart
index c539149..4f51e86 100644
--- a/pkg/analysis_server/test/context_manager_test.dart
+++ b/pkg/analysis_server/test/context_manager_test.dart
@@ -2712,9 +2712,9 @@
resourceProvider,
new MemoryByteStore(),
new FileContentOverlay(),
+ path,
sourceFactory,
analysisOptions);
- currentDriver.name = path;
driverMap[path] = currentDriver;
currentDriver.exceptions.listen((ExceptionResult result) {
AnalysisEngine.instance.logger
diff --git a/pkg/analysis_server/test/integration/integration_tests.dart b/pkg/analysis_server/test/integration/integration_tests.dart
index 9a3b906..b278c96 100644
--- a/pkg/analysis_server/test/integration/integration_tests.dart
+++ b/pkg/analysis_server/test/integration/integration_tests.dart
@@ -698,8 +698,8 @@
if (useAnalysisHighlight2) {
arguments.add('--useAnalysisHighlight2');
}
- if (!enableNewAnalysisDriver) {
- arguments.add('--disable-new-analysis-driver');
+ if (enableNewAnalysisDriver) {
+ arguments.add('--enable-new-analysis-driver');
}
// print('Launching $serverPath');
// print('$dartBinary ${arguments.join(' ')}');
diff --git a/pkg/analysis_server/test/services/correction/assist_test.dart b/pkg/analysis_server/test/services/correction/assist_test.dart
index 29ce28a..30ba490 100644
--- a/pkg/analysis_server/test/services/correction/assist_test.dart
+++ b/pkg/analysis_server/test/services/correction/assist_test.dart
@@ -358,6 +358,15 @@
''');
}
+ test_addTypeAnnotation_local_BAD_bottom() async {
+ await resolveTestUnit('''
+main() {
+ var v = throw 42;
+}
+''');
+ await assertNoAssistAt('var ', DartAssistKind.ADD_TYPE_ANNOTATION);
+ }
+
test_addTypeAnnotation_local_BAD_hasTypeAnnotation() async {
await resolveTestUnit('''
main() {
diff --git a/pkg/analysis_server/test/services/correction/fix_test.dart b/pkg/analysis_server/test/services/correction/fix_test.dart
index ff17fe1..753c685 100644
--- a/pkg/analysis_server/test/services/correction/fix_test.dart
+++ b/pkg/analysis_server/test/services/correction/fix_test.dart
@@ -4116,6 +4116,24 @@
''');
}
+ test_undefinedFunction_create_bottomArgument() async {
+ await resolveTestUnit('''
+main() {
+ test(throw 42);
+}
+''');
+ await assertHasFix(
+ DartFixKind.CREATE_FUNCTION,
+ '''
+main() {
+ test(throw 42);
+}
+
+void test(arg0) {
+}
+''');
+ }
+
test_undefinedFunction_create_duplicateArgumentNames() async {
await resolveTestUnit('''
class C {
diff --git a/pkg/analysis_server/test/services/search/search_engine2_test.dart b/pkg/analysis_server/test/services/search/search_engine2_test.dart
index 5d8ac40..e4ebc37 100644
--- a/pkg/analysis_server/test/services/search/search_engine2_test.dart
+++ b/pkg/analysis_server/test/services/search/search_engine2_test.dart
@@ -240,6 +240,7 @@
provider,
byteStore,
contentOverlay,
+ 'test',
new SourceFactory(
[new DartUriResolver(sdk), new ResourceUriResolver(provider)],
null,
diff --git a/pkg/analysis_server/test/stress/utilities/server.dart b/pkg/analysis_server/test/stress/utilities/server.dart
index 88a44ce..cc96aca 100644
--- a/pkg/analysis_server/test/stress/utilities/server.dart
+++ b/pkg/analysis_server/test/stress/utilities/server.dart
@@ -689,8 +689,8 @@
if (useAnalysisHighlight2) {
arguments.add('--useAnalysisHighlight2');
}
- if (!enableNewAnalysisDriver) {
- arguments.add('--disable-new-analysis-driver');
+ if (enableNewAnalysisDriver) {
+ arguments.add('--enable-new-analysis-driver');
}
// stdout.writeln('Launching $serverPath');
// stdout.writeln('$dartBinary ${arguments.join(' ')}');
diff --git a/pkg/analyzer/lib/dart/ast/ast.dart b/pkg/analyzer/lib/dart/ast/ast.dart
index ba966a3..38e477f 100644
--- a/pkg/analyzer/lib/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/dart/ast/ast.dart
@@ -2760,6 +2760,11 @@
*/
abstract class FieldDeclaration extends ClassMember {
/**
+ * The 'covariant' keyword, or `null` if the keyword was not used.
+ */
+ Token get covariantKeyword;
+
+ /**
* Return the fields being declared.
*/
VariableDeclarationList get fields;
@@ -2991,6 +2996,11 @@
*/
abstract class FormalParameter extends AstNode {
/**
+ * The 'covariant' keyword, or `null` if the keyword was not used.
+ */
+ Token get covariantKeyword;
+
+ /**
* Return the element representing this parameter, or `null` if this parameter
* has not been resolved.
*/
@@ -5052,6 +5062,63 @@
}
/**
+ * A named type, which can optionally include type arguments.
+ *
+ * namedType ::=
+ * [Identifier] typeArguments?
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+abstract class NamedType extends TypeAnnotation {
+ /**
+ * Return `true` if this type is a deferred type.
+ *
+ * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
+ * </i>p.T</i> where <i>p</i> is a deferred prefix.
+ */
+ bool get isDeferred;
+
+ /**
+ * Return the name of the type.
+ */
+ Identifier get name;
+
+ /**
+ * Set the name of the type to the given [identifier].
+ */
+ void set name(Identifier identifier);
+
+ /**
+ * Return the question mark marking this as a nullable type, or `null` if
+ * the type is non-nullable.
+ */
+ Token get question;
+
+ /**
+ * Return the question mark marking this as a nullable type to the given
+ * [question].
+ */
+ void set question(Token question);
+
+ /**
+ * Set the type being named to the given [type].
+ */
+ void set type(DartType type);
+
+ /**
+ * Return the type arguments associated with the type, or `null` if there are
+ * no type arguments.
+ */
+ TypeArgumentList get typeArguments;
+
+ /**
+ * Set the type arguments associated with the type to the given
+ * [typeArguments].
+ */
+ void set typeArguments(TypeArgumentList typeArguments);
+}
+
+/**
* A node that represents a directive that impacts the namespace of a library.
*
* directive ::=
@@ -6553,54 +6620,7 @@
*
* Clients may not extend, implement or mix-in this class.
*/
-abstract class TypeName extends TypeAnnotation {
- /**
- * Return `true` if this type is a deferred type.
- *
- * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
- * </i>p.T</i> where <i>p</i> is a deferred prefix.
- */
- bool get isDeferred;
-
- /**
- * Return the name of the type.
- */
- Identifier get name;
-
- /**
- * Set the name of the type to the given [identifier].
- */
- void set name(Identifier identifier);
-
- /**
- * Return the question mark marking this as a nullable type, or `null` if
- * the type is non-nullable.
- */
- Token get question;
-
- /**
- * Return the question mark marking this as a nullable type to the given
- * [question].
- */
- void set question(Token question);
-
- /**
- * Set the type being named to the given [type].
- */
- void set type(DartType type);
-
- /**
- * Return the type arguments associated with the type, or `null` if there are
- * no type arguments.
- */
- TypeArgumentList get typeArguments;
-
- /**
- * Set the type arguments associated with the type to the given
- * [typeArguments].
- */
- void set typeArguments(TypeArgumentList typeArguments);
-}
+abstract class TypeName extends NamedType {}
/**
* A type parameter.
diff --git a/pkg/analyzer/lib/dart/element/element.dart b/pkg/analyzer/lib/dart/element/element.dart
index 5edb586..f7dbe75 100644
--- a/pkg/analyzer/lib/dart/element/element.dart
+++ b/pkg/analyzer/lib/dart/element/element.dart
@@ -1574,6 +1574,15 @@
@override
MethodDeclaration computeNode();
+
+ /**
+ * Gets the reified type of a tear-off of this method.
+ *
+ * If any of the parameters in the method are covariant, they are replaced
+ * with Object in the returned type. If no covariant parameters are present,
+ * returns `this`.
+ */
+ FunctionType getReifiedType(DartType objectType);
}
/**
diff --git a/pkg/analyzer/lib/dart/element/type.dart b/pkg/analyzer/lib/dart/element/type.dart
index 2ff00f0..fe07765 100644
--- a/pkg/analyzer/lib/dart/element/type.dart
+++ b/pkg/analyzer/lib/dart/element/type.dart
@@ -70,6 +70,12 @@
bool get isDartCoreFunction;
/**
+ * Return `true` if this type represents the type 'Null' defined in the
+ * dart:core library.
+ */
+ bool get isDartCoreNull;
+
+ /**
* Return `true` if this type represents the type 'dynamic'.
*/
bool get isDynamic;
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index c24183c..0d16a92 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -78,7 +78,7 @@
/**
* The name of the driver, e.g. the name of the folder.
*/
- String name;
+ final String name;
/**
* The scheduler that schedules analysis work in this, and possibly other
@@ -239,12 +239,19 @@
this._resourceProvider,
this._byteStore,
this._contentOverlay,
+ this.name,
SourceFactory sourceFactory,
this._analysisOptions)
: _sourceFactory = sourceFactory.clone() {
_testView = new AnalysisDriverTestView(this);
_fillSalt();
_sdkBundle = sourceFactory.dartSdk.getLinkedBundle();
+ if (_sdkBundle == null) {
+ Type sdkType = sourceFactory.dartSdk.runtimeType;
+ String message = 'DartSdk ($sdkType) for $name does not have summary.';
+ AnalysisEngine.instance.logger.logError(message);
+ throw new StateError(message);
+ }
_fsState = new FileSystemState(
_logger,
_byteStore,
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index 862b16c..d157276 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -3446,6 +3446,9 @@
new ChildEntities()..add(_parameter)..add(separator)..add(_defaultValue);
@override
+ Token get covariantKeyword => null;
+
+ @override
Expression get defaultValue => _defaultValue;
@override
@@ -4319,6 +4322,11 @@
*/
class FieldDeclarationImpl extends ClassMemberImpl implements FieldDeclaration {
/**
+ * The 'covariant' keyword, or `null` if the keyword was not used.
+ */
+ Token covariantKeyword;
+
+ /**
* The token representing the 'static' keyword, or `null` if the fields are
* not static.
*/
@@ -4368,7 +4376,9 @@
@override
Token get firstTokenAfterCommentAndMetadata {
- if (staticKeyword != null) {
+ if (covariantKeyword != null) {
+ return covariantKeyword;
+ } else if (staticKeyword != null) {
return staticKeyword;
}
return _fieldList.beginToken;
@@ -4461,7 +4471,12 @@
@override
Token get beginToken {
- if (keyword != null) {
+ NodeList<Annotation> metadata = this.metadata;
+ if (!metadata.isEmpty) {
+ return metadata.beginToken;
+ } else if (covariantKeyword != null) {
+ return covariantKeyword;
+ } else if (keyword != null) {
return keyword;
} else if (_type != null) {
return _type.beginToken;
@@ -5571,7 +5586,12 @@
@override
Token get beginToken {
- if (_returnType != null) {
+ NodeList<Annotation> metadata = this.metadata;
+ if (!metadata.isEmpty) {
+ return metadata.beginToken;
+ } else if (covariantKeyword != null) {
+ return covariantKeyword;
+ } else if (_returnType != null) {
return _returnType.beginToken;
}
return identifier.beginToken;
@@ -8102,6 +8122,11 @@
NodeList<Annotation> _metadata;
/**
+ * The 'covariant' keyword, or `null` if the keyword was not used.
+ */
+ Token covariantKeyword;
+
+ /**
* The name of the parameter being declared.
*/
SimpleIdentifier _identifier;
@@ -8169,6 +8194,9 @@
} else {
result.addAll(sortedCommentAndAnnotations);
}
+ if (covariantKeyword != null) {
+ result.add(covariantKeyword);
+ }
return result;
}
@@ -9219,6 +9247,8 @@
NodeList<Annotation> metadata = this.metadata;
if (!metadata.isEmpty) {
return metadata.beginToken;
+ } else if (covariantKeyword != null) {
+ return covariantKeyword;
} else if (keyword != null) {
return keyword;
} else if (_type != null) {
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 607946a..408d4e5 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -6238,6 +6238,33 @@
@override
MethodDeclaration computeNode() =>
getNodeMatching((node) => node is MethodDeclaration);
+
+ @override
+ FunctionType getReifiedType(DartType objectType) {
+ // Collect the covariant parameters. Do this first so we don't allocate
+ // anything in the common case where there are none.
+ Set<String> covariantNames;
+ for (ParameterElement parameter in parameters) {
+ if (parameter.isCovariant) {
+ covariantNames ??= new Set();
+ covariantNames.add(parameter.name);
+ }
+ }
+
+ if (covariantNames == null) return type;
+
+ List<ParameterElement> covariantParameters = parameters.map((parameter) {
+ if (!covariantNames.contains(parameter.name)) {
+ return parameter;
+ }
+
+ return new ParameterElementImpl.synthetic(
+ parameter.name, objectType, parameter.parameterKind);
+ }).toList();
+
+ return new FunctionElementImpl.synthetic(covariantParameters, returnType)
+ .type;
+ }
}
/**
diff --git a/pkg/analyzer/lib/src/dart/element/handle.dart b/pkg/analyzer/lib/src/dart/element/handle.dart
index a157455..f8ae4a9 100644
--- a/pkg/analyzer/lib/src/dart/element/handle.dart
+++ b/pkg/analyzer/lib/src/dart/element/handle.dart
@@ -409,7 +409,7 @@
object is Element && object.location == _location;
@override
- /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/> visitor) =>
+ /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
actualElement.accept(visitor);
@override
@@ -875,6 +875,10 @@
@override
MethodDeclaration computeNode() => actualElement.computeNode();
+
+ @override
+ FunctionType getReifiedType(DartType objectType) =>
+ actualElement.getReifiedType(objectType);
}
/**
diff --git a/pkg/analyzer/lib/src/dart/element/member.dart b/pkg/analyzer/lib/src/dart/element/member.dart
index d27b814..22e24ca 100644
--- a/pkg/analyzer/lib/src/dart/element/member.dart
+++ b/pkg/analyzer/lib/src/dart/element/member.dart
@@ -603,6 +603,10 @@
MethodDeclaration computeNode() => baseElement.computeNode();
@override
+ FunctionType getReifiedType(DartType objectType) =>
+ baseElement.getReifiedType(objectType);
+
+ @override
String toString() {
MethodElement baseElement = this.baseElement;
List<ParameterElement> parameters = this.parameters;
diff --git a/pkg/analyzer/lib/src/dart/element/type.dart b/pkg/analyzer/lib/src/dart/element/type.dart
index 968c18f..c1feff9 100644
--- a/pkg/analyzer/lib/src/dart/element/type.dart
+++ b/pkg/analyzer/lib/src/dart/element/type.dart
@@ -1396,6 +1396,15 @@
}
@override
+ bool get isDartCoreNull {
+ ClassElement element = this.element;
+ if (element == null) {
+ return false;
+ }
+ return element.name == "Null" && element.library.isDartCore;
+ }
+
+ @override
bool get isObject => element.supertype == null;
@override
@@ -1589,6 +1598,12 @@
bool isMoreSpecificThan(DartType type,
[bool withDynamic = false, Set<Element> visitedElements]) {
//
+ // T is Null and S is not Bottom.
+ //
+ if (isDartCoreNull && !type.isBottom) {
+ return true;
+ }
+
// S is dynamic.
// The test to determine whether S is dynamic is done here because dynamic
// is not an instance of InterfaceType.
@@ -2371,6 +2386,9 @@
bool get isDartCoreFunction => false;
@override
+ bool get isDartCoreNull => false;
+
+ @override
bool get isDynamic => false;
@override
@@ -2551,10 +2569,10 @@
: super(element, element.name);
@override
- ElementLocation get definition => element.location;
+ DartType get bound => element.bound ?? DynamicTypeImpl.instance;
@override
- DartType get bound => element.bound ?? DynamicTypeImpl.instance;
+ ElementLocation get definition => element.location;
@override
TypeParameterElement get element => super.element as TypeParameterElement;
diff --git a/pkg/analyzer/lib/src/generated/element_resolver.dart b/pkg/analyzer/lib/src/generated/element_resolver.dart
index 962e6f6..4b1fd5c 100644
--- a/pkg/analyzer/lib/src/generated/element_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/element_resolver.dart
@@ -1316,7 +1316,7 @@
return null;
}
return StaticTypeWarningCode.UNDEFINED_FUNCTION;
- } else if (!targetType.isDynamic && !targetType.isBottom) {
+ } else if (!targetType.isDynamic && target is! NullLiteral) {
// Proxy-conditional warning, based on state of
// targetType.getElement()
return StaticTypeWarningCode.UNDEFINED_METHOD;
@@ -1561,7 +1561,7 @@
DartType _getStaticTypeOrFunctionType(Expression expression) {
if (expression is NullLiteral) {
- return _resolver.typeProvider.bottomType;
+ return _resolver.typeProvider.nullType;
}
return _resolveTypeParameter(expression.staticType);
}
@@ -2498,7 +2498,7 @@
* [member] in the given [type] and not finding any member.
*/
bool _shouldReportMissingMember(DartType type, Element member) {
- return member == null && type != null && !type.isDynamic && !type.isBottom;
+ return member == null && type != null && !type.isDynamic && !type.isDartCoreNull;
}
/**
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index 1b99f57..befeccf 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -2281,9 +2281,22 @@
}
// RETURN_WITHOUT_VALUE
if (returnExpression == null) {
- if (_inGenerator ||
- _typeSystem.isAssignableTo(
- _computeReturnTypeForMethod(null), expectedReturnType)) {
+ if (_inGenerator) {
+ return;
+ } else if (_inAsync) {
+ if (expectedReturnType.isDynamic) {
+ return;
+ }
+ if (expectedReturnType is InterfaceType &&
+ expectedReturnType.isDartAsyncFuture) {
+ DartType futureArgument = expectedReturnType.typeArguments[0];
+ if (futureArgument.isDynamic ||
+ futureArgument.isDartCoreNull ||
+ futureArgument.isObject) {
+ return;
+ }
+ }
+ } else if (expectedReturnType.isDynamic || expectedReturnType.isVoid) {
return;
}
_hasReturnWithoutValue = true;
@@ -5476,7 +5489,8 @@
if (expectedReturnType.isVoid) {
if (staticReturnType.isVoid ||
staticReturnType.isDynamic ||
- staticReturnType.isBottom) {
+ staticReturnType.isBottom ||
+ staticReturnType.isDartCoreNull) {
return;
}
_errorReporter.reportTypeErrorForNode(
@@ -6427,7 +6441,7 @@
}
bool _isFunctionType(DartType type) {
- if (type.isDynamic || type.isBottom) {
+ if (type.isDynamic || type.isDartCoreNull) {
return true;
} else if (type is FunctionType || type.isDartCoreFunction) {
return true;
diff --git a/pkg/analyzer/lib/src/generated/parser.dart b/pkg/analyzer/lib/src/generated/parser.dart
index e878afd..e470237 100644
--- a/pkg/analyzer/lib/src/generated/parser.dart
+++ b/pkg/analyzer/lib/src/generated/parser.dart
@@ -62,9 +62,9 @@
final Token keyword;
/**
- * The type, of `null` if no type was specified.
+ * The type, or `null` if no type was specified.
*/
- final TypeName type;
+ final TypeAnnotation type;
/**
* Initialize a newly created holder with the given [keyword] and [type].
@@ -243,6 +243,12 @@
bool _inInitializer = false;
/**
+ * A flag indicating whether the parser is to parse generic function type
+ * syntax.
+ */
+ bool parseGenericFunctionTypes = false;
+
+ /**
* A flag indicating whether the parser is to parse generic method syntax.
*/
@deprecated
@@ -1435,7 +1441,7 @@
modifiers.externalKeyword, modifiers.staticKeyword, null);
}
}
- TypeName type = _parseTypeNameAfterIdentifier();
+ TypeAnnotation type = _parseTypeAnnotationAfterIdentifier();
keyword = _currentToken.keyword;
next = _peek();
isFollowedByIdentifier = _tokenMatchesIdentifier(next);
@@ -2109,7 +2115,7 @@
null, _validateModifiersForTopLevelVariable(modifiers), null),
_expect(TokenType.SEMICOLON));
}
- TypeName returnType = parseReturnType();
+ TypeAnnotation returnType = parseReturnType(false);
keyword = _currentToken.keyword;
next = _peek();
if ((keyword == Keyword.GET || keyword == Keyword.SET) &&
@@ -2757,12 +2763,12 @@
FinalConstVarOrType parseFinalConstVarOrType(bool optional,
{bool inFunctionType: false}) {
Token keywordToken = null;
- TypeName type = null;
+ TypeAnnotation type = null;
Keyword keyword = _currentToken.keyword;
if (keyword == Keyword.FINAL || keyword == Keyword.CONST) {
keywordToken = getAndAdvance();
if (_isTypedIdentifier(_currentToken)) {
- type = parseTypeName(false);
+ type = parseTypeAnnotation(false);
} else {
// Support `final/*=T*/ x;`
type = _parseOptionalTypeNameComment();
@@ -2776,9 +2782,9 @@
keywordToken = null;
}
} else if (_isTypedIdentifier(_currentToken)) {
- type = parseReturnType();
+ type = parseReturnType(false);
} else if (inFunctionType && _matchesIdentifier()) {
- type = parseTypeAnnotation();
+ type = parseTypeAnnotation(false);
} else if (!optional) {
_reportErrorForCurrentToken(
ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
@@ -2967,7 +2973,7 @@
ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH);
}
Token keyword = variableList.keyword;
- TypeName type = variableList.type;
+ TypeAnnotation type = variableList.type;
if (keyword != null || type != null) {
loopVariable = astFactory.declaredIdentifier(
commentAndMetadata.comment,
@@ -3179,7 +3185,7 @@
FunctionDeclaration parseFunctionDeclaration(
CommentAndMetadata commentAndMetadata,
Token externalKeyword,
- TypeName returnType) {
+ TypeAnnotation returnType) {
Token keywordToken = null;
bool isGetter = false;
Keyword keyword = _currentToken.keyword;
@@ -3328,7 +3334,7 @@
typeParameters = parseTypeParameterList();
}
Token equals = _expect(TokenType.EQ);
- TypeAnnotation functionType = parseTypeAnnotation();
+ TypeAnnotation functionType = parseTypeAnnotation(false);
Token semicolon = _expect(TokenType.SEMICOLON);
if (functionType is! GenericFunctionType) {
// TODO(brianwilkerson) Generate an error and recover (better than this).
@@ -3370,7 +3376,7 @@
* 'external'? 'static'? returnType? 'get' identifier
*/
MethodDeclaration parseGetter(CommentAndMetadata commentAndMetadata,
- Token externalKeyword, Token staticKeyword, TypeName returnType) {
+ Token externalKeyword, Token staticKeyword, TypeAnnotation returnType) {
Token propertyKeyword = getAndAdvance();
SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
if (_matches(TokenType.OPEN_PAREN) &&
@@ -3554,7 +3560,7 @@
CommentAndMetadata commentAndMetadata,
Token staticKeyword,
Token keyword,
- TypeName type) {
+ TypeAnnotation type) {
VariableDeclarationList fieldList =
parseVariableDeclarationListAfterType(null, keyword, type);
return astFactory.fieldDeclaration(
@@ -4155,9 +4161,10 @@
// parameter with no parameter list.
//_reportErrorForToken(ParserErrorCode.MISSING_PARAMETERS, typeParameters.endToken);
}
- TypeName type = holder.type;
+ TypeAnnotation type = holder.type;
if (type != null) {
- if (_tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
+ if (type is TypeName &&
+ _tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
_reportErrorForToken(
ParserErrorCode.VOID_PARAMETER, type.name.beginToken);
} else if (holder.keyword != null &&
@@ -4173,7 +4180,7 @@
commentAndMetadata.comment,
commentAndMetadata.metadata,
holder.keyword,
- holder.type,
+ type,
thisKeyword,
period,
identifier,
@@ -4184,7 +4191,7 @@
commentAndMetadata.comment,
commentAndMetadata.metadata,
holder.keyword,
- holder.type,
+ type,
astFactory.simpleIdentifier(identifier.token, isDeclaration: true));
}
@@ -4490,15 +4497,15 @@
if (keyword == Keyword.AS) {
Token asOperator = getAndAdvance();
return astFactory.asExpression(
- expression, asOperator, parseTypeName(true));
+ expression, asOperator, parseTypeAnnotation(true));
} else if (keyword == Keyword.IS) {
Token isOperator = getAndAdvance();
Token notOperator = null;
if (_matches(TokenType.BANG)) {
notOperator = getAndAdvance();
}
- return astFactory.isExpression(
- expression, isOperator, notOperator, parseTypeName(true));
+ TypeAnnotation type = parseTypeAnnotation(true);
+ return astFactory.isExpression(expression, isOperator, notOperator, type);
} else if (_currentToken.type.isRelationalOperator) {
Token operator = getAndAdvance();
return astFactory.binaryExpression(
@@ -4543,12 +4550,12 @@
* 'void'
* | type
*/
- TypeName parseReturnType() {
+ TypeAnnotation parseReturnType(bool inExpression) {
if (_currentToken.keyword == Keyword.VOID) {
return astFactory.typeName(
astFactory.simpleIdentifier(getAndAdvance()), null);
} else {
- return parseTypeName(false);
+ return parseTypeAnnotation(inExpression);
}
}
@@ -4569,7 +4576,7 @@
* 'external'? 'static'? returnType? 'set' identifier formalParameterList
*/
MethodDeclaration parseSetter(CommentAndMetadata commentAndMetadata,
- Token externalKeyword, Token staticKeyword, TypeName returnType) {
+ Token externalKeyword, Token staticKeyword, TypeAnnotation returnType) {
Token propertyKeyword = getAndAdvance();
SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
FormalParameterList parameters = parseFormalParameterList();
@@ -4904,7 +4911,7 @@
TypeName exceptionType = null;
if (_matchesString(_ON)) {
onKeyword = getAndAdvance();
- exceptionType = parseTypeName(false);
+ exceptionType = parseTypeAnnotation(false);
}
Token catchKeyword = null;
Token leftParenthesis = null;
@@ -4991,16 +4998,25 @@
* typeWithoutFunction
* | functionType
*/
- TypeAnnotation parseTypeAnnotation() {
- if (_matchesString('Function')) {
- // Generic function type with no return type.
- return parseGenericFunctionTypeAfterReturnType(null);
+ TypeAnnotation parseTypeAnnotation(bool inExpression) {
+ if (parseGenericFunctionTypes) {
+ TypeAnnotation type = null;
+ if (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
+ // Generic function type with no return type.
+ type = parseGenericFunctionTypeAfterReturnType(null);
+ } else if (_currentToken.keyword == Keyword.VOID &&
+ _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
+ type = astFactory.typeName(
+ astFactory.simpleIdentifier(getAndAdvance()), null);
+ } else {
+ type = parseTypeName(inExpression);
+ }
+ while (_atGenericFunctionTypeAfterReturnType(_currentToken)) {
+ type = parseGenericFunctionTypeAfterReturnType(type);
+ }
+ return type;
}
- TypeAnnotation type = parseReturnType();
- while (_matchesString('Function')) {
- type = parseGenericFunctionTypeAfterReturnType(type);
- }
- return type;
+ return parseTypeName(inExpression);
}
/**
@@ -5017,9 +5033,11 @@
*/
TypeArgumentList parseTypeArgumentList() {
Token leftBracket = getAndAdvance();
- List<TypeName> arguments = <TypeName>[parseTypeName(false)];
+ List<TypeAnnotation> arguments = <TypeAnnotation>[
+ parseTypeAnnotation(false)
+ ];
while (_optional(TokenType.COMMA)) {
- arguments.add(parseTypeName(false));
+ arguments.add(parseTypeAnnotation(false));
}
Token rightBracket = _expectGt();
return astFactory.typeArgumentList(leftBracket, arguments, rightBracket);
@@ -5056,7 +5074,7 @@
}
if (_matchesKeyword(Keyword.EXTENDS)) {
Token keyword = getAndAdvance();
- TypeName bound = parseTypeName(false);
+ TypeAnnotation bound = parseTypeAnnotation(false);
return astFactory.typeParameter(commentAndMetadata.comment,
commentAndMetadata.metadata, name, keyword, bound);
}
@@ -5214,7 +5232,9 @@
* finalConstVarOrType variableDeclaration (',' variableDeclaration)*
*/
VariableDeclarationList parseVariableDeclarationListAfterType(
- CommentAndMetadata commentAndMetadata, Token keyword, TypeName type) {
+ CommentAndMetadata commentAndMetadata,
+ Token keyword,
+ TypeAnnotation type) {
if (type != null &&
keyword != null &&
_tokenMatchesKeyword(keyword, Keyword.VAR)) {
@@ -5317,6 +5337,39 @@
}
/**
+ * Parse a formal parameter list, starting at the [startToken], without
+ * actually creating a formal parameter list or changing the current token.
+ * Return the token following the parameter list that was parsed, or `null`
+ * if the given token is not the first token in a valid parameter list.
+ *
+ * This method must be kept in sync with [parseFormalParameterList].
+ */
+ Token skipFormalParameterList(Token startToken) {
+ if (!_tokenMatches(startToken, TokenType.OPEN_PAREN)) {
+ return null;
+ }
+ return (startToken as BeginToken).endToken;
+ }
+
+ /**
+ * Parse the portion of a generic function type after the return type,
+ * starting at the [startToken], without actually creating a generic function
+ * type or changing the current token. Return the token following the generic
+ * function type that was parsed, or `null` if the given token is not the
+ * first token in a valid generic function type.
+ *
+ * This method must be kept in sync with
+ * [parseGenericFunctionTypeAfterReturnType].
+ */
+ Token skipGenericFunctionTypeAfterReturnType(Token startToken) {
+ Token next = startToken.next; // Skip 'Function'
+ if (_tokenMatches(next, TokenType.LT)) {
+ next = skipTypeParameterList(next);
+ }
+ return skipFormalParameterList(next);
+ }
+
+ /**
* Parse a prefixed identifier, starting at the [startToken], without actually
* creating a prefixed identifier or changing the current token. Return the
* token following the prefixed identifier that was parsed, or `null` if the
@@ -5364,7 +5417,7 @@
if (_tokenMatchesKeyword(startToken, Keyword.VOID)) {
return startToken.next;
} else {
- return skipTypeName(startToken);
+ return skipTypeAnnotation(startToken);
}
}
@@ -5416,6 +5469,33 @@
}
/**
+ * Parse a type annotation, starting at the [startToken], without actually
+ * creating a type annotation or changing the current token. Return the token
+ * following the type annotation that was parsed, or `null` if the given token
+ * is not the first token in a valid type annotation.
+ *
+ * This method must be kept in sync with [parseTypeAnnotation].
+ */
+ Token skipTypeAnnotation(Token startToken) {
+ if (parseGenericFunctionTypes) {
+ Token next = null;
+ if (_atGenericFunctionTypeAfterReturnType(startToken)) {
+ next = skipGenericFunctionTypeAfterReturnType(startToken);
+ } else if (_currentToken.keyword == Keyword.VOID &&
+ _atGenericFunctionTypeAfterReturnType(_currentToken.next)) {
+ next = next.next;
+ } else {
+ next = skipTypeName(startToken);
+ }
+ while (next != null && _tokenMatchesString(next, 'Function')) {
+ next = skipGenericFunctionTypeAfterReturnType(next);
+ }
+ return next;
+ }
+ return skipTypeName(startToken);
+ }
+
+ /**
* Parse a list of type arguments, starting at the [startToken], without
* actually creating a type argument list or changing the current token.
* Return the token following the type argument list that was parsed, or
@@ -5485,6 +5565,36 @@
}
/**
+ * Parse a type parameter list, starting at the [startToken], without actually
+ * creating a type parameter list or changing the current token. Return the
+ * token following the type parameter list that was parsed, or `null` if the
+ * given token is not the first token in a valid type parameter list.
+ *
+ * This method must be kept in sync with [parseTypeParameterList].
+ */
+ Token skipTypeParameterList(Token startToken) {
+ if (!_tokenMatches(startToken, TokenType.LT)) {
+ return null;
+ }
+ int depth = 1;
+ Token previous = startToken;
+ Token next = startToken.next;
+ while (next != previous) {
+ if (_tokenMatches(startToken, TokenType.LT)) {
+ depth++;
+ } else if (_tokenMatches(next, TokenType.GT)) {
+ depth--;
+ if (depth == 0) {
+ return next;
+ }
+ }
+ previous = next;
+ next = next.next;
+ }
+ return null;
+ }
+
+ /**
* Advance to the next token in the token stream.
*/
void _advance() {
@@ -5514,6 +5624,22 @@
}
/**
+ * Return `true` if we are positioned at the keyword 'Function' in a generic
+ * function type alias.
+ */
+ bool _atGenericFunctionTypeAfterReturnType(Token startToken) {
+ if (_tokenMatchesString(startToken, 'Function')) {
+ Token next = startToken.next;
+ if (next != null &&
+ (_tokenMatches(next, TokenType.OPEN_PAREN) ||
+ _tokenMatches(next, TokenType.LT))) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
* Clone all token starting from the given [token] up to the end of the token
* stream, and return the first token in the new token stream.
*/
@@ -6649,7 +6775,7 @@
* functionSignature functionBody
*/
Statement _parseFunctionDeclarationStatementAfterReturnType(
- CommentAndMetadata commentAndMetadata, TypeName returnType) {
+ CommentAndMetadata commentAndMetadata, TypeAnnotation returnType) {
FunctionDeclaration declaration =
parseFunctionDeclaration(commentAndMetadata, null, returnType);
Token propertyKeyword = declaration.propertyKeyword;
@@ -6678,9 +6804,9 @@
*/
FunctionTypeAlias _parseFunctionTypeAlias(
CommentAndMetadata commentAndMetadata, Token keyword) {
- TypeName returnType = null;
+ TypeAnnotation returnType = null;
if (hasReturnTypeInTypeAlias) {
- returnType = parseReturnType();
+ returnType = parseReturnType(false);
}
SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
TypeParameterList typeParameters = null;
@@ -6813,7 +6939,7 @@
CommentAndMetadata commentAndMetadata,
Token externalKeyword,
Token staticKeyword,
- TypeName returnType,
+ TypeAnnotation returnType,
SimpleIdentifier name,
TypeParameterList typeParameters,
FormalParameterList parameters) {
@@ -6860,7 +6986,7 @@
CommentAndMetadata commentAndMetadata,
Token externalKeyword,
Token staticKeyword,
- TypeName returnType) {
+ TypeAnnotation returnType) {
SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
FormalParameterList parameters;
@@ -6922,7 +7048,7 @@
MethodDeclaration _parseOperatorAfterKeyword(
CommentAndMetadata commentAndMetadata,
Token externalKeyword,
- TypeName returnType,
+ TypeAnnotation returnType,
Token operatorKeyword) {
if (!_currentToken.isUserDefinableOperator) {
_reportErrorForCurrentToken(
@@ -6965,7 +7091,7 @@
* Parse a return type if one is given, otherwise return `null` without
* advancing. Return the return type that was parsed.
*/
- TypeName _parseOptionalReturnType() {
+ TypeAnnotation _parseOptionalReturnType() {
TypeName typeComment = _parseOptionalTypeNameComment();
if (typeComment != null) {
return typeComment;
@@ -6989,7 +7115,7 @@
// type.
return null;
}
- return parseReturnType();
+ return parseReturnType(false);
}
Token next2 = next.next;
Token next3 = next2.next;
@@ -6997,7 +7123,7 @@
_tokenMatchesIdentifier(next2) &&
(_tokenMatchesIdentifier(next3) ||
_tokenMatches(next3, TokenType.LT))) {
- return parseReturnType();
+ return parseReturnType(false);
}
}
return null;
@@ -7234,6 +7360,23 @@
: astFactory.adjacentStrings(strings);
}
+ /**
+ * Parse a type annotation, possibly superseded by a type name in a comment.
+ * Return the type name that was parsed.
+ *
+ * This method assumes that the current token is an identifier.
+ *
+ * type ::=
+ * qualified typeArguments?
+ */
+ TypeAnnotation _parseTypeAnnotationAfterIdentifier() {
+ TypeAnnotation type = parseTypeAnnotation(false);
+ // If this is followed by a generic method type comment, allow the comment
+ // type to replace the real type name.
+ TypeName typeFromComment = _parseOptionalTypeNameComment();
+ return typeFromComment ?? type;
+ }
+
TypeName _parseTypeName(bool inExpression) {
Identifier typeName;
if (_matchesIdentifier()) {
@@ -7256,25 +7399,6 @@
}
/**
- * Parse a type name. Return the type name that was parsed.
- *
- * This method assumes that the current token is an identifier.
- *
- * type ::=
- * qualified typeArguments?
- */
- TypeName _parseTypeNameAfterIdentifier() {
- Identifier typeName = _parsePrefixedIdentifierUnchecked();
- TypeArgumentList typeArguments = _parseOptionalTypeArguments();
- // If this is followed by a generic method type comment, allow the comment
- // type to replace the real type name.
- // TODO(jmesserly): this feels like a big hammer. Can we restrict it to
- // only work inside generic methods?
- TypeName typeFromComment = _parseOptionalTypeNameComment();
- return typeFromComment ?? astFactory.typeName(typeName, typeArguments);
- }
-
- /**
* Parse a string literal representing a URI. Return the string literal that
* was parsed.
*/
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 43146a2..60c2700 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -900,11 +900,21 @@
if (returnTypeType == null || returnTypeType.isVoid) {
return;
}
- // For async, give no hint if Future<Null> is assignable to the return
- // type.
- if (body.isAsynchronous &&
- _typeSystem.isAssignableTo(_futureNullType, returnTypeType)) {
- return;
+ // For async, give no hint if the return type does not matter, i.e.
+ // dynamic, Future<Null> or Future<dynamic>.
+ if (body.isAsynchronous) {
+ if (returnTypeType.isDynamic) {
+ return;
+ }
+ if (returnTypeType is InterfaceType &&
+ returnTypeType.isDartAsyncFuture) {
+ DartType futureArgument = returnTypeType.typeArguments[0];
+ if (futureArgument.isDynamic ||
+ futureArgument.isDartCoreNull ||
+ futureArgument.isObject) {
+ return;
+ }
+ }
}
// Check the block for a return statement, if not, create the hint
if (!ExitDetector.exits(body)) {
@@ -4179,7 +4189,7 @@
if (_returnStack.isNotEmpty && _inferredReturn.isNotEmpty) {
DartType context = _returnStack.removeLast() ?? DynamicTypeImpl.instance;
DartType inferred = _inferredReturn.removeLast();
- if (inferred.isBottom) {
+ if (inferred.isBottom || inferred.isDartCoreNull) {
return;
}
@@ -5322,7 +5332,9 @@
return null;
}
- if (potentialType == null || potentialType.isBottom) {
+ if (potentialType == null ||
+ potentialType.isBottom ||
+ potentialType.isDartCoreNull) {
return null;
}
DartType currentType = _overrideManager.getBestType(element);
@@ -5380,7 +5392,11 @@
void recordPropagatedTypeIfBetter(Expression expression, DartType type,
[bool hasOldPropagatedType = false]) {
// Ensure that propagated type invalid.
- if (strongMode || type == null || type.isDynamic || type.isBottom) {
+ if (strongMode ||
+ type == null ||
+ type.isBottom ||
+ type.isDynamic ||
+ type.isDartCoreNull) {
if (!hasOldPropagatedType) {
expression.propagatedType = null;
}
diff --git a/pkg/analyzer/lib/src/generated/source.dart b/pkg/analyzer/lib/src/generated/source.dart
index 83a4783..262bfe3 100644
--- a/pkg/analyzer/lib/src/generated/source.dart
+++ b/pkg/analyzer/lib/src/generated/source.dart
@@ -174,6 +174,12 @@
return _sdk.mapDartUri(uri.toString());
}
+ @override
+ Uri restoreAbsolute(Source source) {
+ Source dartSource = _sdk.fromFileUri(source.uri);
+ return dartSource?.uri;
+ }
+
/**
* Return `true` if the given URI is a `dart-ext:` URI.
*
diff --git a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
index b3ec3eb..8d9f708 100644
--- a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
+++ b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
@@ -981,8 +981,7 @@
*/
@override
Object visitNullLiteral(NullLiteral node) {
- // TODO(jmesserly): in strong mode, should we just use the context type?
- _recordStaticType(node, _typeProvider.bottomType);
+ _recordStaticType(node, _typeProvider.nullType);
return null;
}
@@ -2079,7 +2078,8 @@
// * ExpressionFunctionBody, when the surrounding context had a better type.
// * BlockFunctionBody, if we inferred a type from yield/return.
// * we also normalize bottom to dynamic here.
- if (_strongMode && (computedType.isBottom || computedType.isDynamic)) {
+ if (_strongMode &&
+ (computedType.isDartCoreNull || computedType.isDynamic)) {
DartType contextType = InferenceContext.getContext(body);
if (contextType is FutureUnionType) {
// TODO(jmesserly): can we do something better here?
@@ -2107,14 +2107,17 @@
*/
void _inferLocalVariableType(
VariableDeclaration node, Expression initializer) {
- if (initializer != null &&
- (node.parent as VariableDeclarationList).type == null &&
- (resolutionMap.staticTypeForExpression(initializer) != null) &&
- (!resolutionMap.staticTypeForExpression(initializer).isBottom)) {
- VariableElement element = node.element;
- if (element is LocalVariableElementImpl) {
- element.type = initializer.staticType;
- node.name.staticType = initializer.staticType;
+ if (initializer != null) {
+ AstNode parent = node.parent;
+ if (parent is VariableDeclarationList && parent.type == null) {
+ DartType type = resolutionMap.staticTypeForExpression(initializer);
+ if (type != null && !type.isBottom && !type.isDartCoreNull) {
+ VariableElement element = node.element;
+ if (element is LocalVariableElementImpl) {
+ element.type = initializer.staticType;
+ node.name.staticType = initializer.staticType;
+ }
+ }
}
}
}
@@ -2269,7 +2272,11 @@
* @param type the propagated type of the node
*/
void _recordPropagatedType(Expression expression, DartType type) {
- if (!_strongMode && type != null && !type.isDynamic && !type.isBottom) {
+ if (!_strongMode &&
+ type != null &&
+ !type.isBottom &&
+ !type.isDynamic &&
+ !type.isDartCoreNull) {
expression.propagatedType = type;
}
}
@@ -2293,8 +2300,8 @@
if (propagatedReturnType == null) {
return;
}
- // Ignore 'bottom' type.
- if (propagatedReturnType.isBottom) {
+ // Ignore 'Bottom' and 'Null' types.
+ if (propagatedReturnType.isBottom || propagatedReturnType.isDartCoreNull) {
return;
}
// Record only if we inferred more specific type.
@@ -2410,7 +2417,7 @@
if (expression != null) {
type = expression.bestType;
} else {
- type = BottomTypeImpl.instance;
+ type = _typeProvider.nullType;
}
// merge types
if (result == null) {
diff --git a/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart b/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
index c2a3a43..8460484 100644
--- a/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
+++ b/pkg/analyzer/lib/src/generated/testing/test_type_provider.dart
@@ -576,6 +576,7 @@
//
objectType;
boolType;
+ nullType;
stringType;
//
// Add the methods.
diff --git a/pkg/analyzer/lib/src/generated/type_system.dart b/pkg/analyzer/lib/src/generated/type_system.dart
index ed117af..93dda91 100644
--- a/pkg/analyzer/lib/src/generated/type_system.dart
+++ b/pkg/analyzer/lib/src/generated/type_system.dart
@@ -24,7 +24,7 @@
show JenkinsSmiHash;
bool _isBottom(DartType t, {bool dynamicIsBottom: false}) {
- return (t.isDynamic && dynamicIsBottom) || t.isBottom;
+ return (t.isDynamic && dynamicIsBottom) || t.isBottom || t.isDartCoreNull;
}
bool _isTop(DartType t, {bool dynamicIsBottom: false}) {
diff --git a/pkg/analyzer/lib/src/summary/link.dart b/pkg/analyzer/lib/src/summary/link.dart
index e261675..a685504 100644
--- a/pkg/analyzer/lib/src/summary/link.dart
+++ b/pkg/analyzer/lib/src/summary/link.dart
@@ -247,7 +247,7 @@
}
DartType _dynamicIfNull(DartType type) {
- if (type == null || type.isBottom || type.isVoid) {
+ if (type == null || type.isBottom || type.isDartCoreNull || type.isVoid) {
return DynamicTypeImpl.instance;
}
return type;
@@ -2006,7 +2006,7 @@
stack.add(typeProvider.symbolType);
break;
case UnlinkedExprOperation.pushNull:
- stack.add(BottomTypeImpl.instance);
+ stack.add(typeProvider.nullType);
break;
case UnlinkedExprOperation.pushReference:
_doPushReference();
diff --git a/pkg/analyzer/lib/src/summary/package_bundle_reader.dart b/pkg/analyzer/lib/src/summary/package_bundle_reader.dart
index 24f19d8..bdccb1e 100644
--- a/pkg/analyzer/lib/src/summary/package_bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary/package_bundle_reader.dart
@@ -18,7 +18,7 @@
import 'package:analyzer/task/dart.dart';
import 'package:analyzer/task/general.dart';
import 'package:analyzer/task/model.dart';
-import 'package:path/path.dart' as pathos;
+import 'package:front_end/src/base/source.dart';
/**
* The [ResultProvider] that provides results from input package summaries.
@@ -66,44 +66,24 @@
* are served from its summary. This source uses its URI as [fullName] and has
* empty contents.
*/
-class InSummarySource extends Source {
- final Uri uri;
-
+class InSummarySource extends BasicSource {
/**
* The summary file where this source was defined.
*/
final String summaryPath;
- InSummarySource(this.uri, this.summaryPath);
+ InSummarySource(Uri uri, this.summaryPath) : super(uri);
@override
TimestampedData<String> get contents => new TimestampedData<String>(0, '');
@override
- String get encoding => uri.toString();
-
- @override
- String get fullName => encoding;
-
- @override
- int get hashCode => uri.hashCode;
-
- @override
- bool get isInSystemLibrary => uri.scheme == DartUriResolver.DART_SCHEME;
-
- @override
int get modificationStamp => 0;
@override
- String get shortName => pathos.basename(fullName);
-
- @override
UriKind get uriKind => UriKind.PACKAGE_URI;
@override
- bool operator ==(Object object) => object is Source && object.uri == uri;
-
- @override
bool exists() => true;
@override
diff --git a/pkg/analyzer/lib/src/task/dart.dart b/pkg/analyzer/lib/src/task/dart.dart
index d842d2f..05528d7 100644
--- a/pkg/analyzer/lib/src/task/dart.dart
+++ b/pkg/analyzer/lib/src/task/dart.dart
@@ -3745,7 +3745,7 @@
// Record the type of the variable.
//
DartType newType = initializer.staticType;
- if (newType == null || newType.isBottom) {
+ if (newType == null || newType.isBottom || newType.isDartCoreNull) {
newType = typeProvider.dynamicType;
}
setFieldType(variable, newType);
diff --git a/pkg/analyzer/lib/src/task/strong_mode.dart b/pkg/analyzer/lib/src/task/strong_mode.dart
index c5b6bad..866d17b 100644
--- a/pkg/analyzer/lib/src/task/strong_mode.dart
+++ b/pkg/analyzer/lib/src/task/strong_mode.dart
@@ -368,7 +368,7 @@
newType = fieldElement.initializer.returnType;
}
}
- if (newType == null || newType.isBottom) {
+ if (newType == null || newType.isBottom || newType.isDartCoreNull) {
newType = typeProvider.dynamicType;
}
setFieldType(fieldElement, newType);
diff --git a/pkg/analyzer/test/generated/all_the_rest_test.dart b/pkg/analyzer/test/generated/all_the_rest_test.dart
index 5a0a1ba..5f11129 100644
--- a/pkg/analyzer/test/generated/all_the_rest_test.dart
+++ b/pkg/analyzer/test/generated/all_the_rest_test.dart
@@ -38,6 +38,7 @@
import 'package:source_span/source_span.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'package:typed_mock/typed_mock.dart' show TypedMock, when;
import 'parser_test.dart';
import 'resolver_test_case.dart';
@@ -67,32 +68,6 @@
});
}
-/**
- * Create a tiny mock SDK for use in URI resolution tests.
- */
-DartSdk _createSdk() {
- MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
- String sdkFolderName =
- resourceProvider.pathContext.separator == '/' ? '/sdk' : r'C:\sdk';
- Folder sdkFolder = resourceProvider.newFolder(sdkFolderName);
- expect(sdkFolder, isNotNull);
- resourceProvider.newFile(
- resourceProvider.pathContext.join(sdkFolderName, 'lib', '_internal',
- 'sdk_library_metadata', 'lib', 'libraries.dart'),
- '''
-const Map<String, LibraryInfo> libraries = const {
- "core": const LibraryInfo("core/core.dart")
-};
-''');
- resourceProvider.newFile(
- resourceProvider.pathContext
- .join(sdkFolderName, 'lib', 'core', 'core.dart'),
- '''
-library dart.core;
-''');
- return new FolderBasedDartSdk(resourceProvider, sdkFolder);
-}
-
@reflectiveTest
class ContentCacheTest {
test_setContents() async {
@@ -140,9 +115,16 @@
}
@reflectiveTest
-class DartUriResolverTest {
+class DartUriResolverTest extends _SimpleDartSdkTest {
+ DartUriResolver resolver;
+
+ @override
+ setUp() {
+ super.setUp();
+ resolver = new DartUriResolver(sdk);
+ }
+
void test_creation() {
- DartSdk sdk = _createSdk();
expect(new DartUriResolver(sdk), isNotNull);
}
@@ -152,27 +134,42 @@
expect(DartUriResolver.isDartUri(uri), isFalse);
}
- void test_resolve_dart() {
- DartSdk sdk = _createSdk();
- UriResolver resolver = new DartUriResolver(sdk);
- Source result = resolver.resolveAbsolute(Uri.parse("dart:core"));
- expect(result, isNotNull);
+ void test_resolve_dart_library() {
+ Source source = resolver.resolveAbsolute(Uri.parse('dart:core'));
+ expect(source, isNotNull);
}
void test_resolve_dart_nonExistingLibrary() {
- DartSdk sdk = _createSdk();
- UriResolver resolver = new DartUriResolver(sdk);
Source result = resolver.resolveAbsolute(Uri.parse("dart:cor"));
expect(result, isNull);
}
+ void test_resolve_dart_part() {
+ Source source = resolver.resolveAbsolute(Uri.parse('dart:core/int.dart'));
+ expect(source, isNotNull);
+ }
+
void test_resolve_nonDart() {
- DartSdk sdk = _createSdk();
- UriResolver resolver = new DartUriResolver(sdk);
Source result =
resolver.resolveAbsolute(Uri.parse("package:some/file.dart"));
expect(result, isNull);
}
+
+ void test_restoreAbsolute_library() {
+ Source source = new _SourceMock();
+ Uri fileUri = resourceProvider.pathContext.toUri(coreCorePath);
+ when(source.uri).thenReturn(fileUri);
+ Uri dartUri = resolver.restoreAbsolute(source);
+ expect(dartUri.toString(), 'dart:core');
+ }
+
+ void test_restoreAbsolute_part() {
+ Source source = new _SourceMock();
+ Uri fileUri = resourceProvider.pathContext.toUri(coreIntPath);
+ when(source.uri).thenReturn(fileUri);
+ Uri dartUri = resolver.restoreAbsolute(source);
+ expect(dartUri.toString(), 'dart:core/int.dart');
+ }
}
@deprecated
@@ -2053,7 +2050,7 @@
}
test_isInSystemLibrary_contagious() async {
- DartSdk sdk = _createSdk();
+ DartSdk sdk = (new _SimpleDartSdkTest()..setUp()).sdk;
UriResolver resolver = new DartUriResolver(sdk);
SourceFactory factory = new SourceFactory([resolver]);
// resolve dart:core
@@ -2279,3 +2276,39 @@
expect(UriKind.PACKAGE_URI.encoding, 0x70);
}
}
+
+class _SimpleDartSdkTest {
+ MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
+ String coreCorePath;
+ String coreIntPath;
+ DartSdk sdk;
+
+ void setUp() {
+ Folder sdkFolder =
+ resourceProvider.newFolder(resourceProvider.convertPath('/sdk'));
+ resourceProvider.newFile(
+ resourceProvider.convertPath(
+ '/sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart'),
+ '''
+const Map<String, LibraryInfo> libraries = const {
+ "core": const LibraryInfo("core/core.dart")
+};
+''');
+ coreCorePath = resourceProvider.convertPath('/sdk/lib/core/core.dart');
+ resourceProvider.newFile(
+ coreCorePath,
+ '''
+library dart.core;
+part 'int.dart';
+''');
+ coreIntPath = resourceProvider.convertPath('/sdk/lib/core/int.dart');
+ resourceProvider.newFile(
+ coreIntPath,
+ '''
+part of dart.core;
+''');
+ sdk = new FolderBasedDartSdk(resourceProvider, sdkFolder);
+ }
+}
+
+class _SourceMock extends TypedMock implements Source {}
diff --git a/pkg/analyzer/test/generated/non_error_resolver_test.dart b/pkg/analyzer/test/generated/non_error_resolver_test.dart
index 1fae0c2..525e99f 100644
--- a/pkg/analyzer/test/generated/non_error_resolver_test.dart
+++ b/pkg/analyzer/test/generated/non_error_resolver_test.dart
@@ -702,16 +702,6 @@
verify([source]);
}
- test_async_future_object_without_return() async {
- Source source = addSource('''
-import 'dart:async';
-Future<Object> f() async {}
-''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- }
-
test_async_future_with_return() async {
Source source = addSource('''
import 'dart:async';
@@ -5003,6 +4993,18 @@
verify([source]);
}
+ test_returnOfInvalidType_async_future_int_mismatches_future_null() async {
+ Source source = addSource(r'''
+import 'dart:async';
+Future<Null> f() async {
+ return 5;
+}
+''');
+ await computeAnalysisResult(source);
+ assertNoErrors(source);
+ verify([source]);
+ }
+
test_returnOfInvalidType_dynamic() async {
Source source = addSource(r'''
class TypeError {}
@@ -5081,6 +5083,7 @@
void f3() { return null; }
void f4() { return g1(); }
void f5() { return g2(); }
+void f6() => throw 42;
g1() {}
void g2() {}
''');
diff --git a/pkg/analyzer/test/generated/non_hint_code_test.dart b/pkg/analyzer/test/generated/non_hint_code_test.dart
index 9954b62..c2539e5 100644
--- a/pkg/analyzer/test/generated/non_hint_code_test.dart
+++ b/pkg/analyzer/test/generated/non_hint_code_test.dart
@@ -20,6 +20,16 @@
@reflectiveTest
class NonHintCodeTest extends ResolverTestCase {
+ test_async_future_object_without_return() async {
+ Source source = addSource('''
+import 'dart:async';
+Future<Object> f() async {}
+''');
+ await computeAnalysisResult(source);
+ assertNoErrors(source);
+ verify([source]);
+ }
+
test_deadCode_afterTryCatch() async {
Source source = addSource('''
main() {
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 41ae0f4..1979480 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -1134,10 +1134,22 @@
.parseStatement("do {} (x);", [ParserErrorCode.EXPECTED_TOKEN]);
}
+ void test_expectedTypeName_as() {
+ parseExpression("x as", [ParserErrorCode.EXPECTED_TYPE_NAME]);
+ }
+
+ void test_expectedTypeName_as_void() {
+ parseExpression("x as void)", [ParserErrorCode.EXPECTED_TYPE_NAME]);
+ }
+
void test_expectedTypeName_is() {
parseExpression("x is", [ParserErrorCode.EXPECTED_TYPE_NAME]);
}
+ void test_expectedTypeName_is_void() {
+ parseExpression("x is void)", [ParserErrorCode.EXPECTED_TYPE_NAME]);
+ }
+
void test_exportDirectiveAfterPartDirective() {
ParserTestCase.parseCompilationUnit("part 'a.dart'; export 'b.dart';",
[ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE]);
@@ -5993,6 +6005,25 @@
expect(variable.name, isNotNull);
}
+ @failingTest
+ void test_parseClassMember_getter_functionType() {
+ createParser('int Function(int) get g {}');
+ ClassMember member = parser.parseClassMember('C');
+ expectNotNullIfNoErrors(member);
+ listener.assertNoErrors();
+ expect(member, new isInstanceOf<MethodDeclaration>());
+ MethodDeclaration method = member;
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNotNull);
+ expect(method.returnType, isNotNull);
+ expect(method.name, isNotNull);
+ expect(method.operatorKeyword, isNull);
+ expect(method.body, isNotNull);
+ expect(method.parameters, isNull);
+ }
+
void test_parseClassMember_getter_void() {
createParser('void get g {}');
ClassMember member = parser.parseClassMember('C');
@@ -6304,6 +6335,27 @@
expect(method.body, isNotNull);
}
+ @failingTest
+ void test_parseClassMember_method_returnType_functionType() {
+ createParser('int Function(String) m() {}');
+ ClassMember member = parser.parseClassMember('C');
+ expectNotNullIfNoErrors(member);
+ listener.assertNoErrors();
+ expect(member, new isInstanceOf<MethodDeclaration>());
+ MethodDeclaration method = member;
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNull);
+ expect(method.returnType, isNotNull);
+ expect(method.name, isNotNull);
+ expect(method.name.name, 'm');
+ expect(method.operatorKeyword, isNull);
+ expect(method.typeParameters, isNull);
+ expect(method.parameters, isNotNull);
+ expect(method.body, isNotNull);
+ }
+
void test_parseClassMember_method_returnType_parameterized() {
createParser('p.A m() {}');
ClassMember member = parser.parseClassMember('C');
@@ -6399,6 +6451,30 @@
expect(method.body, isNotNull);
}
+ @failingTest
+ void test_parseClassMember_operator_functionType() {
+ createParser('int Function() operator +(int Function() f) {}');
+ ClassMember member = parser.parseClassMember('C');
+ expectNotNullIfNoErrors(member);
+ listener.assertNoErrors();
+ expect(member, new isInstanceOf<MethodDeclaration>());
+ MethodDeclaration method = member;
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNull);
+ expect(method.returnType, new isInstanceOf<GenericFunctionType>());
+ expect(method.name, isNotNull);
+ expect(method.operatorKeyword, isNotNull);
+ expect(method.typeParameters, isNull);
+ expect(method.parameters, isNotNull);
+ NodeList<FormalParameter> parameters = method.parameters.parameters;
+ expect(parameters, hasLength(1));
+ expect((parameters[0] as SimpleFormalParameter).type,
+ new isInstanceOf<GenericFunctionType>());
+ expect(method.body, isNotNull);
+ }
+
void test_parseClassMember_operator_index() {
createParser('int operator [](int i) {}');
ClassMember member = parser.parseClassMember('C');
@@ -8686,6 +8762,21 @@
expect(defaultParameter.kind, kind);
}
+ @failingTest
+ void test_parseFormalParameter_nonFinal_withType_function() {
+ ParameterKind kind = ParameterKind.REQUIRED;
+ createParser('String Function(int) a');
+ FormalParameter parameter = parser.parseFormalParameter(kind);
+ expectNotNullIfNoErrors(parameter);
+ listener.assertNoErrors();
+ expect(parameter, new isInstanceOf<SimpleFormalParameter>());
+ SimpleFormalParameter simpleParameter = parameter;
+ expect(simpleParameter.identifier, isNotNull);
+ expect(simpleParameter.keyword, isNull);
+ expect(simpleParameter.type, new isInstanceOf<GenericFunctionType>());
+ expect(simpleParameter.kind, kind);
+ }
+
void test_parseFormalParameter_nonFinal_withType_named() {
ParameterKind kind = ParameterKind.NAMED;
createParser('A a : null');
@@ -8914,6 +9005,18 @@
expect(list.rightParenthesis, isNotNull);
}
+ void test_parseFormalParameterList_normal_single_Function() {
+ createParser('(Function f)');
+ FormalParameterList list = parser.parseFormalParameterList();
+ expectNotNullIfNoErrors(list);
+ listener.assertNoErrors();
+ expect(list.leftParenthesis, isNotNull);
+ expect(list.leftDelimiter, isNull);
+ expect(list.parameters, hasLength(1));
+ expect(list.rightDelimiter, isNull);
+ expect(list.rightParenthesis, isNotNull);
+ }
+
void test_parseFormalParameterList_normal_single_trailing_comma() {
createParser('(A a,)');
FormalParameterList list = parser.parseFormalParameterList();
@@ -9640,6 +9743,7 @@
expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
}
+ @failingTest
void test_parseGenericTypeAlias_noTypeParameters() {
createParser('F = int Function(int);');
GenericTypeAlias alias =
@@ -9654,6 +9758,7 @@
expect(alias.semicolon, isNotNull);
}
+ @failingTest
void test_parseGenericTypeAlias_typeParameters() {
createParser('F<T> = T Function(T);');
GenericTypeAlias alias =
@@ -11687,8 +11792,9 @@
expect(invocation.period, isNull);
}
- void test_parseRelationalExpression_as() {
- createParser('x as Y');
+ @failingTest
+ void test_parseRelationalExpression_as_functionType_noReturnType() {
+ createParser('x as Function(int)');
Expression expression = parser.parseRelationalExpression();
expectNotNullIfNoErrors(expression);
listener.assertNoErrors();
@@ -11696,7 +11802,32 @@
AsExpression asExpression = expression;
expect(asExpression.expression, isNotNull);
expect(asExpression.asOperator, isNotNull);
- expect(asExpression.type, isNotNull);
+ expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
+ }
+
+ @failingTest
+ void test_parseRelationalExpression_as_functionType_returnType() {
+ createParser('x as String Function(int)');
+ Expression expression = parser.parseRelationalExpression();
+ expectNotNullIfNoErrors(expression);
+ listener.assertNoErrors();
+ expect(expression, new isInstanceOf<AsExpression>());
+ AsExpression asExpression = expression;
+ expect(asExpression.expression, isNotNull);
+ expect(asExpression.asOperator, isNotNull);
+ expect(asExpression.type, new isInstanceOf<GenericFunctionType>());
+ }
+
+ void test_parseRelationalExpression_as_generic() {
+ createParser('x as C<D>');
+ Expression expression = parser.parseRelationalExpression();
+ expectNotNullIfNoErrors(expression);
+ listener.assertNoErrors();
+ expect(expression, new isInstanceOf<AsExpression>());
+ AsExpression asExpression = expression;
+ expect(asExpression.expression, isNotNull);
+ expect(asExpression.asOperator, isNotNull);
+ expect(asExpression.type, new isInstanceOf<TypeName>());
}
void test_parseRelationalExpression_as_nullable() {
@@ -11709,7 +11840,31 @@
AsExpression asExpression = expression;
expect(asExpression.expression, isNotNull);
expect(asExpression.asOperator, isNotNull);
- expect(asExpression.type, isNotNull);
+ expect(asExpression.type, new isInstanceOf<TypeName>());
+ }
+
+ void test_parseRelationalExpression_as_simple() {
+ createParser('x as Y');
+ Expression expression = parser.parseRelationalExpression();
+ expectNotNullIfNoErrors(expression);
+ listener.assertNoErrors();
+ expect(expression, new isInstanceOf<AsExpression>());
+ AsExpression asExpression = expression;
+ expect(asExpression.expression, isNotNull);
+ expect(asExpression.asOperator, isNotNull);
+ expect(asExpression.type, new isInstanceOf<TypeName>());
+ }
+
+ void test_parseRelationalExpression_as_simple_function() {
+ createParser('x as Function');
+ Expression expression = parser.parseRelationalExpression();
+ expectNotNullIfNoErrors(expression);
+ listener.assertNoErrors();
+ expect(expression, new isInstanceOf<AsExpression>());
+ AsExpression asExpression = expression;
+ expect(asExpression.expression, isNotNull);
+ expect(asExpression.asOperator, isNotNull);
+ expect(asExpression.type, new isInstanceOf<TypeName>());
}
void test_parseRelationalExpression_is() {
@@ -11806,9 +11961,20 @@
expect(statement.semicolon, isNotNull);
}
- void test_parseReturnType_nonVoid() {
+ @failingTest
+ void test_parseReturnType_function() {
+ createParser('A<B> Function<B>(B)');
+ GenericFunctionType type = parser.parseReturnType(false);
+ expectNotNullIfNoErrors(type);
+ listener.assertNoErrors();
+ expect(type.returnType, isNotNull);
+ expect(type.typeParameters, isNotNull);
+ expect(type.parameters, isNotNull);
+ }
+
+ void test_parseReturnType_named() {
createParser('A<B>');
- TypeName typeName = parser.parseReturnType();
+ TypeName typeName = parser.parseReturnType(false);
expectNotNullIfNoErrors(typeName);
listener.assertNoErrors();
expect(typeName.name, isNotNull);
@@ -11817,7 +11983,7 @@
void test_parseReturnType_void() {
createParser('void');
- TypeName typeName = parser.parseReturnType();
+ TypeName typeName = parser.parseReturnType(false);
expectNotNullIfNoErrors(typeName);
listener.assertNoErrors();
expect(typeName.name, isNotNull);
@@ -12722,6 +12888,7 @@
expect(typeAlias.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_noParameters() {
createParser('typedef F = bool Function();');
GenericTypeAlias typeAlias =
@@ -12739,6 +12906,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_noReturnType() {
createParser('typedef F = Function();');
GenericTypeAlias typeAlias =
@@ -12756,6 +12924,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_parameterizedReturnType() {
createParser('typedef F = A<B> Function();');
GenericTypeAlias typeAlias =
@@ -12773,6 +12942,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_parameters() {
createParser('typedef F = bool Function(Object value);');
GenericTypeAlias typeAlias =
@@ -12790,6 +12960,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_typeParameters() {
createParser('typedef F = bool Function<E>();');
GenericTypeAlias typeAlias =
@@ -12807,6 +12978,7 @@
expect(functionType.typeParameters, isNotNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_typeParameters_noParameters() {
createParser('typedef F<T> = bool Function();');
GenericTypeAlias typeAlias =
@@ -12824,6 +12996,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_typeParameters_noReturnType() {
createParser('typedef F<T> = Function();');
GenericTypeAlias typeAlias =
@@ -12841,6 +13014,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void
test_parseTypeAlias_genericFunction_typeParameters_parameterizedReturnType() {
createParser('typedef F<T> = A<B> Function();');
@@ -12859,6 +13033,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_typeParameters_parameters() {
createParser('typedef F<T> = bool Function(Object value);');
GenericTypeAlias typeAlias =
@@ -12876,6 +13051,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_typeParameters_typeParameters() {
createParser('typedef F<T> = bool Function<E>();');
GenericTypeAlias typeAlias =
@@ -12893,6 +13069,7 @@
expect(functionType.typeParameters, isNotNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_typeParameters_voidReturnType() {
createParser('typedef F<T> = void Function();');
GenericTypeAlias typeAlias =
@@ -12910,6 +13087,7 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAlias_genericFunction_voidReturnType() {
createParser('typedef F = void Function();');
GenericTypeAlias typeAlias =
@@ -12927,9 +13105,10 @@
expect(functionType.typeParameters, isNull);
}
+ @failingTest
void test_parseTypeAnnotation_function_noReturnType_noParameters() {
createParser('Function() v');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNull);
@@ -12940,9 +13119,10 @@
expect(parameterList.parameters, hasLength(0));
}
+ @failingTest
void test_parseTypeAnnotation_function_noReturnType_parameters() {
createParser('Function(int, int) v');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNull);
@@ -12966,9 +13146,10 @@
expect((parameter.type as TypeName).name.name, 'int');
}
+ @failingTest
void test_parseTypeAnnotation_function_noReturnType_typeParameters() {
createParser('Function<S, T>()');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNull);
@@ -12981,10 +13162,11 @@
expect(parameterList.parameters, hasLength(0));
}
+ @failingTest
void
test_parseTypeAnnotation_function_noReturnType_typeParameters_parameters() {
createParser('Function<T>(String, {T t})');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNull);
@@ -12997,16 +13179,25 @@
expect(parameterList.parameters, hasLength(2));
}
- void test_parseTypeAnnotation_function_returnType_function() {
- createParser('A Function(B, C) Function(D) v');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ void test_parseTypeAnnotation_function_returnType_classFunction() {
+ createParser('Function v');
+ TypeName functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
}
+ @failingTest
+ void test_parseTypeAnnotation_function_returnType_function() {
+ createParser('A Function(B, C) Function(D) v');
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+ expectNotNullIfNoErrors(functionType);
+ listener.assertNoErrors();
+ }
+
+ @failingTest
void test_parseTypeAnnotation_function_returnType_noParameters() {
createParser('List<int> Function()');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNotNull);
@@ -13017,9 +13208,10 @@
expect(parameterList.parameters, hasLength(0));
}
+ @failingTest
void test_parseTypeAnnotation_function_returnType_parameters() {
createParser('List<int> Function(String s, int i)');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNotNull);
@@ -13045,16 +13237,18 @@
expect((parameter.type as TypeName).name.name, 'int');
}
+ @failingTest
void test_parseTypeAnnotation_function_returnType_simple() {
createParser('A Function(B, C) v');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
}
+ @failingTest
void test_parseTypeAnnotation_function_returnType_typeParameters() {
createParser('List<T> Function<T>()');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNotNull);
@@ -13067,10 +13261,11 @@
expect(parameterList.parameters, hasLength(0));
}
+ @failingTest
void
test_parseTypeAnnotation_function_returnType_typeParameters_parameters() {
createParser('List<T> Function<T>(String s, [T])');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
expect(functionType.returnType, isNotNull);
@@ -13083,16 +13278,17 @@
expect(parameterList.parameters, hasLength(2));
}
+ @failingTest
void test_parseTypeAnnotation_function_returnType_withArguments() {
createParser('A<B> Function(C) v');
- GenericFunctionType functionType = parser.parseTypeAnnotation();
+ GenericFunctionType functionType = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(functionType);
listener.assertNoErrors();
}
void test_parseTypeAnnotation_named() {
createParser('A<B> v');
- TypeName typeName = parser.parseTypeAnnotation();
+ TypeName typeName = parser.parseTypeAnnotation(false);
expectNotNullIfNoErrors(typeName);
listener.assertNoErrors();
}
@@ -13233,12 +13429,34 @@
expect(typeName.question, isNotNull);
}
- void test_parseTypeParameter_bounded() {
- createParser('A extends B');
+ @failingTest
+ void test_parseTypeParameter_bounded_functionType_noReturn() {
+ createParser('A extends Function(int)');
TypeParameter parameter = parser.parseTypeParameter();
expectNotNullIfNoErrors(parameter);
listener.assertNoErrors();
- expect(parameter.bound, isNotNull);
+ expect(parameter.bound, new isInstanceOf<GenericFunctionType>());
+ expect(parameter.extendsKeyword, isNotNull);
+ expect(parameter.name, isNotNull);
+ }
+
+ @failingTest
+ void test_parseTypeParameter_bounded_functionType_return() {
+ createParser('A extends String Function(int)');
+ TypeParameter parameter = parser.parseTypeParameter();
+ expectNotNullIfNoErrors(parameter);
+ listener.assertNoErrors();
+ expect(parameter.bound, new isInstanceOf<GenericFunctionType>());
+ expect(parameter.extendsKeyword, isNotNull);
+ expect(parameter.name, isNotNull);
+ }
+
+ void test_parseTypeParameter_bounded_generic() {
+ createParser('A extends B<C>');
+ TypeParameter parameter = parser.parseTypeParameter();
+ expectNotNullIfNoErrors(parameter);
+ listener.assertNoErrors();
+ expect(parameter.bound, new isInstanceOf<TypeName>());
expect(parameter.extendsKeyword, isNotNull);
expect(parameter.name, isNotNull);
}
@@ -13249,7 +13467,7 @@
TypeParameter parameter = parser.parseTypeParameter();
expectNotNullIfNoErrors(parameter);
listener.assertNoErrors();
- expect(parameter.bound, isNotNull);
+ expect(parameter.bound, new isInstanceOf<TypeName>());
expect(parameter.extendsKeyword, isNotNull);
expect(parameter.name, isNotNull);
TypeName bound = parameter.bound;
@@ -13257,6 +13475,16 @@
expect(bound.question, isNotNull);
}
+ void test_parseTypeParameter_bounded_simple() {
+ createParser('A extends B');
+ TypeParameter parameter = parser.parseTypeParameter();
+ expectNotNullIfNoErrors(parameter);
+ listener.assertNoErrors();
+ expect(parameter.bound, new isInstanceOf<TypeName>());
+ expect(parameter.extendsKeyword, isNotNull);
+ expect(parameter.name, isNotNull);
+ }
+
void test_parseTypeParameter_simple() {
createParser('A');
TypeParameter parameter = parser.parseTypeParameter();
diff --git a/pkg/analyzer/test/generated/resolver_test.dart b/pkg/analyzer/test/generated/resolver_test.dart
index 2f7c644..0cd462c 100644
--- a/pkg/analyzer/test/generated/resolver_test.dart
+++ b/pkg/analyzer/test/generated/resolver_test.dart
@@ -1204,6 +1204,22 @@
}
}
+ test_assignment_throwExpression() async {
+ Source source = addSource(r'''
+f() {
+ var v = 1;
+ v = throw 2;
+ return v;
+}''');
+ CompilationUnit unit = await _computeResolvedUnit(source, noErrors: false);
+ FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
+ BlockFunctionBody body =
+ function.functionExpression.body as BlockFunctionBody;
+ ReturnStatement statement = body.block.statements[2] as ReturnStatement;
+ SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
+ expect(variableName.propagatedType, same(typeProvider.intType));
+ }
+
test_CanvasElement_getContext() async {
String code = r'''
import 'dart:html';
@@ -1595,6 +1611,21 @@
}
}
+ test_initializer_throwExpression() async {
+ Source source = addSource(r'''
+f() {
+ var v = throw 2;
+ return v;
+}''');
+ CompilationUnit unit = await _computeResolvedUnit(source, noErrors: false);
+ FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
+ BlockFunctionBody body =
+ function.functionExpression.body as BlockFunctionBody;
+ var statement = body.block.statements[0] as VariableDeclarationStatement;
+ SimpleIdentifier variableName = statement.variables.variables[0].name;
+ expect(variableName.propagatedType, isNull);
+ }
+
test_invocation_target_prefixed() async {
addNamedSource(
'/helper.dart',
diff --git a/pkg/analyzer/test/generated/resolver_test_case.dart b/pkg/analyzer/test/generated/resolver_test_case.dart
index 1cd8849..a57434c 100644
--- a/pkg/analyzer/test/generated/resolver_test_case.dart
+++ b/pkg/analyzer/test/generated/resolver_test_case.dart
@@ -686,8 +686,15 @@
PerformanceLog log = new PerformanceLog(_logBuffer);
AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
- driver = new AnalysisDriver(scheduler, log, resourceProvider,
- new MemoryByteStore(), fileContentOverlay, sourceFactory, options);
+ driver = new AnalysisDriver(
+ scheduler,
+ log,
+ resourceProvider,
+ new MemoryByteStore(),
+ fileContentOverlay,
+ 'test',
+ sourceFactory,
+ options);
scheduler.start();
} else {
if (packages != null) {
@@ -735,6 +742,9 @@
Source source, LibraryElement library) =>
analysisContext2.resolveCompilationUnit(source, library);
+ Future<CompilationUnit> resolveSource(String sourceText) =>
+ resolveSource2('/test.dart', sourceText);
+
Future<CompilationUnit> resolveSource2(
String fileName, String sourceText) async {
Source source = addNamedSource(fileName, sourceText);
@@ -742,9 +752,6 @@
return analysisResult.unit;
}
- Future<CompilationUnit> resolveSource(String sourceText) =>
- resolveSource2('/test.dart', sourceText);
-
Future<Source> resolveSources(List<String> sourceTexts) async {
for (int i = 0; i < sourceTexts.length; i++) {
Source source = addNamedSource('/lib${i + 1}.dart', sourceTexts[i]);
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
index 7fb624b..fc24a96 100644
--- a/pkg/analyzer/test/generated/static_type_analyzer_test.dart
+++ b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
@@ -1164,7 +1164,7 @@
void test_visitNullLiteral() {
// null
Expression node = AstTestFactory.nullLiteral();
- expect(_analyze(node), same(_typeProvider.bottomType));
+ expect(_analyze(node), same(_typeProvider.nullType));
_listener.assertNoErrors();
}
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 4290c02..1825c3c 100644
--- a/pkg/analyzer/test/generated/static_type_warning_code_test.dart
+++ b/pkg/analyzer/test/generated/static_type_warning_code_test.dart
@@ -1066,17 +1066,6 @@
[StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
}
- test_returnOfInvalidType_async_future_int_mismatches_future_null() async {
- await assertErrorsInCode(
- '''
-import 'dart:async';
-Future<Null> f() async {
- return 5;
-}
-''',
- [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
- }
-
test_returnOfInvalidType_async_future_int_mismatches_future_string() async {
await assertErrorsInCode(
'''
@@ -1928,6 +1917,19 @@
[StaticTypeWarningCode.UNDEFINED_METHOD]);
}
+ test_undefinedMethod_ofNull() async {
+ // TODO(scheglov) Track https://github.com/dart-lang/sdk/issues/28430 to
+ // decide whether a warning should be reported here.
+ await assertErrorsInCode(
+ r'''
+Null f(int x) => null;
+main() {
+ f(42).abs();
+}
+''',
+ [StaticTypeWarningCode.UNDEFINED_METHOD]);
+ }
+
test_undefinedMethod_private() async {
addNamedSource(
"/lib.dart",
diff --git a/pkg/analyzer/test/src/dart/analysis/base.dart b/pkg/analyzer/test/src/dart/analysis/base.dart
index 341d4f6..eb55621 100644
--- a/pkg/analyzer/test/src/dart/analysis/base.dart
+++ b/pkg/analyzer/test/src/dart/analysis/base.dart
@@ -110,6 +110,7 @@
provider,
byteStore,
contentOverlay,
+ 'test',
new SourceFactory([
new DartUriResolver(sdk),
new PackageMapUriResolver(provider, <String, List<Folder>>{
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
index cc79745..1e6e79c 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
@@ -72,6 +72,7 @@
provider,
byteStore,
contentOverlay,
+ 'test',
new SourceFactory(
[new DartUriResolver(sdk), new ResourceUriResolver(provider)],
null,
diff --git a/pkg/analyzer/test/src/task/dart_test.dart b/pkg/analyzer/test/src/task/dart_test.dart
index 64901f9..75d799de 100644
--- a/pkg/analyzer/test/src/task/dart_test.dart
+++ b/pkg/analyzer/test/src/task/dart_test.dart
@@ -5318,19 +5318,19 @@
InterfaceType intType = context.typeProvider.intType;
InterfaceType stringType = context.typeProvider.stringType;
- DartType bottomType = context.typeProvider.bottomType;
+ DartType nullType = context.typeProvider.nullType;
DartType dynamicType = context.typeProvider.dynamicType;
assertVariableDeclarationTypes(
- AstFinder.getTopLevelVariable(unit, "x"), dynamicType, bottomType);
+ AstFinder.getTopLevelVariable(unit, "x"), dynamicType, nullType);
assertVariableDeclarationTypes(
AstFinder.getTopLevelVariable(unit, "y"), intType, intType);
assertVariableDeclarationTypes(
- AstFinder.getFieldInClass(unit, "A", "x"), dynamicType, bottomType);
+ AstFinder.getFieldInClass(unit, "A", "x"), dynamicType, nullType);
assertVariableDeclarationTypes(
AstFinder.getFieldInClass(unit, "A", "y"), intType, intType);
assertVariableDeclarationTypes(
- AstFinder.getFieldInClass(unit, "A", "x2"), dynamicType, bottomType);
+ AstFinder.getFieldInClass(unit, "A", "x2"), dynamicType, nullType);
assertVariableDeclarationTypes(
AstFinder.getFieldInClass(unit, "A", "y2"), intType, intType);
diff --git a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
index db39828..ddf18db 100644
--- a/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
+++ b/pkg/analyzer/test/src/task/strong/inferred_type_test.dart
@@ -459,7 +459,7 @@
''');
var v = mainUnit.topLevelVariables[0];
expect(v.type.toString(), 'dynamic');
- expect(v.initializer.type.toString(), '() → <bottom>');
+ expect(v.initializer.type.toString(), '() → Null');
}
void test_bottom_inClosure() {
diff --git a/pkg/compiler/lib/src/common/resolution.dart b/pkg/compiler/lib/src/common/resolution.dart
index db13fd4..0ccd78e 100644
--- a/pkg/compiler/lib/src/common/resolution.dart
+++ b/pkg/compiler/lib/src/common/resolution.dart
@@ -6,6 +6,7 @@
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/compile_time_constants.dart b/pkg/compiler/lib/src/compile_time_constants.dart
index 9d2d6db..82459f3 100644
--- a/pkg/compiler/lib/src/compile_time_constants.dart
+++ b/pkg/compiler/lib/src/compile_time_constants.dart
@@ -865,8 +865,7 @@
target.computeType(resolution);
- FunctionSignature signature = target.functionSignature;
- if (!callStructure.signatureApplies(signature)) {
+ if (!callStructure.signatureApplies(target.type)) {
String name = Elements.constructorNameForDiagnostics(
target.enclosingClass.name, target.name);
reporter.reportErrorMessage(node,
@@ -876,8 +875,8 @@
target.functionSignature.parameterCount,
new ErroneousAstConstant(context, node));
}
- return callStructure.makeArgumentsList(
- arguments, target, compileArgument, compileDefaultValue);
+ return Elements.makeArgumentsList<AstConstant>(
+ callStructure, arguments, target, compileArgument, compileDefaultValue);
}
AstConstant visitNewExpression(NewExpression node) {
@@ -1113,7 +1112,7 @@
}
assert(invariant(
node,
- callStructure.signatureApplies(constructor.functionSignature) ||
+ callStructure.signatureApplies(constructor.type) ||
compiler.compilationFailed,
message: "Call structure $callStructure does not apply to constructor "
"$constructor."));
@@ -1295,10 +1294,10 @@
Function compileArgument = (element) => definitions[element];
Function compileConstant = handler.compileConstant;
FunctionElement target = constructor.definingConstructor.implementation;
- CallStructure.addForwardingElementArgumentsToList(constructor,
+ Elements.addForwardingElementArgumentsToList<AstConstant>(constructor,
compiledArguments, target, compileArgument, compileConstant);
- CallStructure callStructure =
- new CallStructure.fromSignature(target.functionSignature);
+ CallStructure callStructure = new CallStructure(
+ target.functionSignature.parameterCount, target.type.namedParameters);
evaluateSuperOrRedirectSend(compiledArguments, callStructure, target);
return;
}
diff --git a/pkg/compiler/lib/src/elements/elements.dart b/pkg/compiler/lib/src/elements/elements.dart
index 1170cd7..dcf3f09 100644
--- a/pkg/compiler/lib/src/elements/elements.dart
+++ b/pkg/compiler/lib/src/elements/elements.dart
@@ -17,6 +17,7 @@
import '../tokens/token.dart'
show Token, isUserDefinableOperator, isMinusOperator;
import '../tree/tree.dart';
+import '../universe/call_structure.dart';
import '../util/characters.dart' show $_;
import '../util/util.dart';
import '../world.dart' show ClosedWorld;
@@ -819,6 +820,131 @@
// label is also always unused.
return element == null || element.statement != body;
}
+
+ /**
+ * Returns a `List` with the evaluated arguments in the normalized order.
+ *
+ * [compileDefaultValue] is a function that returns a compiled constant
+ * of an optional argument that is not in [compiledArguments].
+ *
+ * Precondition: `callStructure.signatureApplies(element.type)`.
+ *
+ * Invariant: [element] must be the implementation element.
+ */
+ static List<T> makeArgumentsList<T>(
+ CallStructure callStructure,
+ Link<Node> arguments,
+ FunctionElement element,
+ T compileArgument(Node argument),
+ T compileDefaultValue(ParameterElement element)) {
+ assert(invariant(element, element.isImplementation));
+ List<T> result = <T>[];
+
+ FunctionSignature parameters = element.functionSignature;
+ parameters.forEachRequiredParameter((ParameterElement element) {
+ result.add(compileArgument(arguments.head));
+ arguments = arguments.tail;
+ });
+
+ if (!parameters.optionalParametersAreNamed) {
+ parameters.forEachOptionalParameter((ParameterElement element) {
+ if (!arguments.isEmpty) {
+ result.add(compileArgument(arguments.head));
+ arguments = arguments.tail;
+ } else {
+ result.add(compileDefaultValue(element));
+ }
+ });
+ } else {
+ // Visit named arguments and add them into a temporary list.
+ List compiledNamedArguments = [];
+ for (; !arguments.isEmpty; arguments = arguments.tail) {
+ NamedArgument namedArgument = arguments.head;
+ compiledNamedArguments.add(compileArgument(namedArgument.expression));
+ }
+ // Iterate over the optional parameters of the signature, and try to
+ // find them in [compiledNamedArguments]. If found, we use the
+ // value in the temporary list, otherwise the default value.
+ parameters.orderedOptionalParameters.forEach((ParameterElement element) {
+ int foundIndex = callStructure.namedArguments.indexOf(element.name);
+ if (foundIndex != -1) {
+ result.add(compiledNamedArguments[foundIndex]);
+ } else {
+ result.add(compileDefaultValue(element));
+ }
+ });
+ }
+ return result;
+ }
+
+ /**
+ * Fills [list] with the arguments in the order expected by
+ * [callee], and where [caller] is a synthesized element
+ *
+ * [compileArgument] is a function that returns a compiled version
+ * of a parameter of [callee].
+ *
+ * [compileConstant] is a function that returns a compiled constant
+ * of an optional argument that is not in the parameters of [callee].
+ *
+ * Returns [:true:] if the signature of the [caller] matches the
+ * signature of the [callee], [:false:] otherwise.
+ */
+ static bool addForwardingElementArgumentsToList<T>(
+ ConstructorElement caller,
+ List<T> list,
+ ConstructorElement callee,
+ T compileArgument(ParameterElement element),
+ T compileConstant(ParameterElement element)) {
+ assert(invariant(caller, !callee.isMalformed,
+ message: "Cannot compute arguments to malformed constructor: "
+ "$caller calling $callee."));
+
+ FunctionSignature signature = caller.functionSignature;
+ Map<Node, ParameterElement> mapping = <Node, ParameterElement>{};
+
+ // TODO(ngeoffray): This is a hack that fakes up AST nodes, so
+ // that we can call [addArgumentsToList].
+ Link<Node> computeCallNodesFromParameters() {
+ LinkBuilder<Node> builder = new LinkBuilder<Node>();
+ signature.forEachRequiredParameter((ParameterElement element) {
+ Node node = element.node;
+ mapping[node] = element;
+ builder.addLast(node);
+ });
+ if (signature.optionalParametersAreNamed) {
+ signature.forEachOptionalParameter((ParameterElement element) {
+ mapping[element.initializer] = element;
+ builder.addLast(new NamedArgument(null, null, element.initializer));
+ });
+ } else {
+ signature.forEachOptionalParameter((ParameterElement element) {
+ Node node = element.node;
+ mapping[node] = element;
+ builder.addLast(node);
+ });
+ }
+ return builder.toLink();
+ }
+
+ T internalCompileArgument(Node node) {
+ return compileArgument(mapping[node]);
+ }
+
+ Link<Node> nodes = computeCallNodesFromParameters();
+
+ // Synthesize a structure for the call.
+ // TODO(ngeoffray): Should the resolver do it instead?
+ CallStructure callStructure = new CallStructure(
+ signature.parameterCount, signature.type.namedParameters);
+ if (!callStructure.signatureApplies(signature.type)) {
+ return false;
+ }
+ list.addAll(makeArgumentsList<T>(callStructure, nodes, callee,
+ internalCompileArgument, compileConstant));
+
+ return true;
+ }
}
/// An element representing an erroneous resolution.
@@ -1113,9 +1239,6 @@
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/modelx.dart b/pkg/compiler/lib/src/elements/modelx.dart
index cd8e04c..6ff57cc 100644
--- a/pkg/compiler/lib/src/elements/modelx.dart
+++ b/pkg/compiler/lib/src/elements/modelx.dart
@@ -1345,7 +1345,7 @@
ResolutionTypedefType computeType(Resolution resolution) {
if (thisTypeCache != null) return thisTypeCache;
Typedef node = parseNode(resolution.parsingContext);
- setThisAndRawTypes(createTypeVariables(node.templateParameters));
+ setThisAndRawTypes(createTypeVariables(node.typeParameters));
ensureResolved(resolution);
return thisTypeCache;
}
@@ -1743,15 +1743,6 @@
: 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;
diff --git a/pkg/compiler/lib/src/elements/resolution_types.dart b/pkg/compiler/lib/src/elements/resolution_types.dart
index 3ba3468a..19fd8c8 100644
--- a/pkg/compiler/lib/src/elements/resolution_types.dart
+++ b/pkg/compiler/lib/src/elements/resolution_types.dart
@@ -642,16 +642,6 @@
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/inferrer/builder.dart b/pkg/compiler/lib/src/inferrer/builder.dart
index ae3c1c6..add6bab 100644
--- a/pkg/compiler/lib/src/inferrer/builder.dart
+++ b/pkg/compiler/lib/src/inferrer/builder.dart
@@ -2316,8 +2316,7 @@
// In erroneous code the number of arguments in the selector might not
// match the function element.
// TODO(polux): return nonNullEmpty and check it doesn'TypeInformation break anything
- if (target.isMalformed ||
- !callStructure.signatureApplies(target.functionSignature)) {
+ if (target.isMalformed || !callStructure.signatureApplies(target.type)) {
return types.dynamicType;
}
diff --git a/pkg/compiler/lib/src/inferrer/closure_tracer.dart b/pkg/compiler/lib/src/inferrer/closure_tracer.dart
index 007d1c4..0d00722 100644
--- a/pkg/compiler/lib/src/inferrer/closure_tracer.dart
+++ b/pkg/compiler/lib/src/inferrer/closure_tracer.dart
@@ -53,8 +53,7 @@
Selector selector = info.selector;
TypeMask mask = info.mask;
tracedElements.forEach((FunctionElement functionElement) {
- if (!selector.callStructure
- .signatureApplies(functionElement.functionSignature)) {
+ if (!selector.callStructure.signatureApplies(functionElement.type)) {
return;
}
inferrer.updateParameterAssignments(
diff --git a/pkg/compiler/lib/src/js_backend/namer.dart b/pkg/compiler/lib/src/js_backend/namer.dart
index bfabd01..97ad11cc 100644
--- a/pkg/compiler/lib/src/js_backend/namer.dart
+++ b/pkg/compiler/lib/src/js_backend/namer.dart
@@ -135,18 +135,106 @@
*/
class Namer {
static const List<String> javaScriptKeywords = const <String>[
- // These are current keywords.
- "break", "delete", "function", "return", "typeof", "case", "do", "if",
- "switch", "var", "catch", "else", "in", "this", "void", "continue",
- "false", "instanceof", "throw", "while", "debugger", "finally", "new",
- "true", "with", "default", "for", "null", "try",
+ // ES5 7.6.1.1 Keywords.
+ 'break',
+ 'do',
+ 'instanceof',
+ 'typeof',
+ 'case',
+ 'else',
+ 'new',
+ 'var',
+ 'catch',
+ 'finally',
+ 'return',
+ 'void',
+ 'continue',
+ 'for',
+ 'switch',
+ 'while',
+ 'debugger',
+ 'function',
+ 'this',
+ 'with',
+ 'default',
+ 'if',
+ 'throw',
+ 'delete',
+ 'in',
+ 'try',
- // These are future keywords.
- "abstract", "double", "goto", "native", "static", "boolean", "enum",
- "implements", "package", "super", "byte", "export", "import", "private",
- "synchronized", "char", "extends", "int", "protected", "throws",
- "class", "final", "interface", "public", "transient", "const", "float",
- "long", "short", "volatile"
+ // ES5 7.6.1.2 Future Reserved Words.
+ 'class',
+ 'enum',
+ 'extends',
+ 'super',
+ 'const',
+ 'export',
+ 'import',
+
+ // ES5 7.6.1.2 Words with semantic restrictions.
+ 'implements',
+ 'let',
+ 'private',
+ 'public',
+ 'yield',
+ 'interface',
+ 'package',
+ 'protected',
+ 'static',
+
+ // ES6 11.6.2.1 Keywords (including repeats of ES5 to ease comparison with
+ // documents).
+ 'break',
+ 'do',
+ 'in',
+ 'typeof',
+ 'case',
+ 'else',
+ 'instanceof',
+ 'var',
+ 'catch',
+ 'export',
+ 'new',
+ 'void',
+ 'class',
+ 'extends',
+ 'return',
+ 'while',
+ 'const',
+ 'finally',
+ 'super',
+ 'with',
+ 'continue',
+ 'for',
+ 'switch',
+ 'yield',
+ 'debugger',
+ 'function',
+ 'this',
+ 'default',
+ 'if',
+ 'throw',
+ 'delete',
+ 'import',
+ 'try',
+
+ // ES6 11.6.2.1 Words with semantic restrictions.
+ 'yield', 'let', 'static',
+
+ // ES6 11.6.2.2 Future Reserved Words.
+ 'enum',
+ 'await',
+
+ // ES6 11.6.2.2 / ES6 12.1.1 Words with semantic restrictions.
+ 'implements',
+ 'package',
+ 'protected',
+ 'interface',
+ 'private',
+ 'public',
+
+ // Other words to avoid due to non-standard keyword-like behavior.
];
static const List<String> reservedPropertySymbols = const <String>[
@@ -237,12 +325,6 @@
// https://developer.mozilla.org/en/New_in_JavaScript_1.8.1
"getPrototypeOf", "let", "yield",
- // "future reserved words"
- "abstract", "int", "short", "boolean", "interface", "static", "byte",
- "long", "char", "final", "native", "synchronized", "float", "package",
- "throws", "goto", "private", "transient", "implements", "protected",
- "volatile", "double", "public",
-
// IE methods
// (http://msdn.microsoft.com/en-us/library/ms535873(VS.85).aspx#)
"attachEvent", "clientInformation", "clipboardData", "createPopup",
@@ -278,7 +360,7 @@
"JavaArray", "JavaMember",
// ES6 collections.
- "Map",
+ "Map", "Set",
];
static const List<String> reservedGlobalObjectNames = const <String>[
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 ea09888..00b9ac7 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,8 +219,7 @@
}
if (expr is Send && expr.isTypeCast) {
Send sendExpr = expr;
- var typeAnnotation = sendExpr.typeAnnotationFromIsCheckOrCast;
- var typeName = typeAnnotation.asNominalTypeAnnotation()?.typeName;
+ var typeName = sendExpr.typeAnnotationFromIsCheckOrCast.typeName;
if (typeName is Identifier && typeName.source == "dynamic") {
expr = sendExpr.receiver;
}
diff --git a/pkg/compiler/lib/src/kernel/kernel_visitor.dart b/pkg/compiler/lib/src/kernel/kernel_visitor.dart
index 6a663b0..831eff4 100644
--- a/pkg/compiler/lib/src/kernel/kernel_visitor.dart
+++ b/pkg/compiler/lib/src/kernel/kernel_visitor.dart
@@ -104,7 +104,6 @@
ForIn,
FunctionDeclaration,
FunctionExpression,
- FunctionTypeAnnotation,
Identifier,
If,
Label,
@@ -123,7 +122,6 @@
NewExpression,
Node,
NodeList,
- NominalTypeAnnotation,
Operator,
ParenthesizedExpression,
RedirectingFactoryBody,
@@ -850,17 +848,17 @@
@override
ir.BoolLiteral visitLiteralBool(LiteralBool node) {
- return new ir.BoolLiteral(node.value);
+ return associateNode(new ir.BoolLiteral(node.value), node);
}
@override
ir.DoubleLiteral visitLiteralDouble(LiteralDouble node) {
- return new ir.DoubleLiteral(node.value);
+ return associateNode(new ir.DoubleLiteral(node.value), node);
}
@override
ir.IntLiteral visitLiteralInt(LiteralInt node) {
- return new ir.IntLiteral(node.value);
+ return associateNode(new ir.IntLiteral(node.value), node);
}
@override
@@ -911,7 +909,8 @@
@override
ir.Expression visitLiteralString(LiteralString node) {
if (node.dartString == null) return new ir.InvalidExpression();
- return new ir.StringLiteral(node.dartString.slowToString());
+ return associateNode(new ir.StringLiteral(node.dartString.slowToString()),
+ node);
}
@override
@@ -1041,8 +1040,10 @@
}
if (statements.isEmpty || fallsThrough(statements.last)) {
if (isLastCase) {
- statements.add(new ir.BreakStatement(
- getBreakTarget(elements.getTargetDefinition(node))));
+ if (!caseNode.isDefaultCase) {
+ statements.add(new ir.BreakStatement(
+ getBreakTarget(elements.getTargetDefinition(node))));
+ }
} else {
statements.add(new ir.ExpressionStatement(new ir.Throw(
new ir.ConstructorInvocation(
@@ -1089,28 +1090,14 @@
@override
visitTypeAnnotation(TypeAnnotation node) {
- // Shouldn't be called, as the resolver has already resolved types and
+ // Shouldn't be called, as the resolver have 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 has already resolved types and
+ // Shouldn't be called, as the resolver have already resolved types and
// created [DartType] objects.
return internalError(node, "TypeVariable");
}
@@ -1259,7 +1246,7 @@
@override
ir.InvocationExpression visitConstConstructorInvoke(
NewExpression node, ConstructedConstantExpression constant, _) {
- return buildConstructorInvoke(node, isConst: true);
+ return associateNode(buildConstructorInvoke(node, isConst: true), node);
}
@override
diff --git a/pkg/compiler/lib/src/native/behavior.dart b/pkg/compiler/lib/src/native/behavior.dart
index 1f9faa8..e236975 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, [lookupType] resolves named
+ /// [specString] is the specification string, [resolveType] 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 1c031aa..5c058ee 100644
--- a/pkg/compiler/lib/src/parser/element_listener.dart
+++ b/pkg/compiler/lib/src/parser/element_listener.dart
@@ -260,17 +260,10 @@
}
}
- 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();
- }
+ void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
+ popNode(); // TODO(karlklose): do not throw away typeVariables.
+ Identifier name = popNode();
+ popNode(); // returnType
pushElement(new PartialTypedefElement(
name.source, compilationUnitElement, typedefKeyword, endToken));
rejectBuiltInIdentifier(name);
@@ -301,12 +294,12 @@
void endMixinApplication() {
NodeList mixins = popNode();
- NominalTypeAnnotation superclass = popNode();
+ TypeAnnotation superclass = popNode();
pushNode(new MixinApplication(superclass, mixins));
}
void handleVoidKeyword(Token token) {
- pushNode(new NominalTypeAnnotation(new Identifier(token), null));
+ pushNode(new TypeAnnotation(new Identifier(token), null));
}
void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
@@ -373,7 +366,7 @@
}
void endTypeVariable(Token token, Token extendsOrSuper) {
- NominalTypeAnnotation bound = popNode();
+ TypeAnnotation bound = popNode();
Identifier name = popNode();
pushNode(new TypeVariable(name, extendsOrSuper, bound));
rejectBuiltInIdentifier(name);
@@ -398,17 +391,7 @@
void endType(Token beginToken, Token endToken) {
NodeList typeArguments = popNode();
Expression typeName = popNode();
- 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);
+ pushNode(new TypeAnnotation(typeName, typeArguments));
}
void handleParenthesizedExpression(BeginGroupToken token) {
diff --git a/pkg/compiler/lib/src/parser/listener.dart b/pkg/compiler/lib/src/parser/listener.dart
index d3eab2f..b33bd84 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 beginTypedef(Token token) {}
+ void beginFunctionTypeAlias(Token token) {}
- void endTypedef(Token typedefKeyword, Token equals, Token endToken) {}
+ void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {}
void beginMixinApplication(Token token) {}
@@ -295,10 +295,6 @@
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 e11a5f1..4dc325c 100644
--- a/pkg/compiler/lib/src/parser/node_listener.dart
+++ b/pkg/compiler/lib/src/parser/node_listener.dart
@@ -12,6 +12,7 @@
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,
@@ -114,58 +115,13 @@
pushNode(makeNodeList(count, null, null, '\n'));
}
- 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) {
+ void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
NodeList formals = popNode();
NodeList typeParameters = popNode();
+ Identifier name = popNode();
TypeAnnotation returnType = popNode();
- pushNode(new FunctionTypeAnnotation(
- returnType, functionToken, typeParameters, formals));
+ pushNode(new Typedef(
+ returnType, name, typeParameters, formals, typedefKeyword, endToken));
}
void endNamedMixinApplication(
@@ -250,7 +206,7 @@
NodeList typeArguments = popNode();
Node classReference = popNode();
if (typeArguments != null) {
- classReference = new NominalTypeAnnotation(classReference, typeArguments);
+ classReference = new TypeAnnotation(classReference, typeArguments);
} else {
Identifier identifier = classReference.asIdentifier();
Send send = classReference.asSend();
@@ -835,7 +791,7 @@
NodeList typeArguments = popNode();
Node receiver = popNode();
if (typeArguments != null) {
- receiver = new NominalTypeAnnotation(receiver, typeArguments);
+ receiver = new TypeAnnotation(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 fa4ac4b..0ef9cb8 100644
--- a/pkg/compiler/lib/src/parser/parser.dart
+++ b/pkg/compiler/lib/src/parser/parser.dart
@@ -362,21 +362,12 @@
Token parseTypedef(Token token) {
Token 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);
+ listener.beginFunctionTypeAlias(token);
+ token = parseReturnTypeOpt(token.next);
+ token = parseIdentifier(token);
+ token = parseTypeVariablesOpt(token);
+ token = parseFormalParameters(token);
+ listener.endFunctionTypeAlias(typedefKeyword, token);
return expect(';', token);
}
@@ -407,11 +398,7 @@
}
}
- /// 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 parseFormalParameters(Token token) {
Token begin = token;
listener.beginFormalParameters(begin);
expect('(', token);
@@ -424,23 +411,19 @@
++parameterCount;
String value = token.stringValue;
if (identical(value, '[')) {
- token = parseOptionalFormalParameters(
- token, false, inFunctionType: inFunctionType);
+ token = parseOptionalFormalParameters(token, false);
break;
} else if (identical(value, '{')) {
- token = parseOptionalFormalParameters(
- token, true, inFunctionType: inFunctionType);
+ token = parseOptionalFormalParameters(token, true);
break;
}
- token = parseFormalParameter(token, FormalParameterType.REQUIRED,
- inFunctionType: inFunctionType);
+ token = parseFormalParameter(token, FormalParameterType.REQUIRED);
} while (optional(',', token));
listener.endFormalParameters(parameterCount, begin, token);
return expect(')', token);
}
- Token parseFormalParameter(Token token, FormalParameterType type,
- {bool inFunctionType}) {
+ Token parseFormalParameter(Token token, FormalParameterType type) {
token = parseMetadataStar(token, forParameter: true);
listener.beginFormalParameter(token);
@@ -453,41 +436,24 @@
token = token.next;
}
token = parseModifiers(token);
- bool isNamedParameter = type == FormalParameterType.NAMED;
-
+ // TODO(ahe): Validate that there are formal parameters if void.
+ token = parseReturnTypeOpt(token);
Token thisKeyword = null;
- 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);
+ 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);
}
-
- // 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);
- }
+ 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);
}
String value = token.stringValue;
if ((identical('=', value)) || (identical(':', value))) {
@@ -507,8 +473,7 @@
return token;
}
- Token parseOptionalFormalParameters(Token token, bool isNamed,
- {bool inFunctionType}) {
+ Token parseOptionalFormalParameters(Token token, bool isNamed) {
Token begin = token;
listener.beginOptionalFormalParameters(begin);
assert((isNamed && optional('{', token)) || optional('[', token));
@@ -522,8 +487,7 @@
}
var type =
isNamed ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
- token =
- parseFormalParameter(token, type, inFunctionType: inFunctionType);
+ token = parseFormalParameter(token, type);
++parameterCount;
} while (optional(',', token));
if (parameterCount == 0) {
@@ -542,10 +506,6 @@
}
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);
@@ -710,7 +670,7 @@
token = token.next;
}
Token classKeyword = token;
- var isMixinApplication = optional('=', peekAfterNominalType(token.next));
+ var isMixinApplication = optional('=', peekAfterType(token.next));
if (isMixinApplication) {
listener.beginNamedMixinApplication(begin);
} else {
@@ -751,7 +711,7 @@
Token extendsKeyword;
if (optional('extends', token)) {
extendsKeyword = token;
- if (optional('with', peekAfterNominalType(token.next))) {
+ if (optional('with', peekAfterType(token.next))) {
token = parseMixinApplication(token.next);
} else {
token = parseType(token.next);
@@ -849,53 +809,16 @@
!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 (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);
+ if (isValidTypeReference(token)) {
+ token = parseIdentifier(token);
+ token = parseQualifiedRestOpt(token);
} else {
- if (isValidTypeReference(token)) {
- token = parseIdentifier(token);
- token = parseQualifiedRestOpt(token);
- } else {
- token = listener.expectedType(token);
- }
- token = parseTypeArgumentsOpt(token);
- listener.endType(begin, token);
+ token = listener.expectedType(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);
+ token = parseTypeArgumentsOpt(token);
+ listener.endType(begin, token);
return token;
}
@@ -1252,55 +1175,26 @@
hasName = true;
}
identifiers = identifiers.prepend(token);
-
- 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 (isValidTypeReference(token)) {
+ // type ...
+ if (optional('.', token.next)) {
+ // type '.' ...
+ if (token.next.next.isIdentifier()) {
+ // type '.' identifier
+ token = token.next.next;
}
}
- token = token.next;
- }
- while (isGeneralizedFunctionType(token)) {
- token = token.next;
- if (optional('<', token)) {
- if (token is BeginGroupToken) {
- BeginGroupToken beginGroup = token;
+ if (optional('<', token.next)) {
+ if (token.next is BeginGroupToken) {
+ BeginGroupToken beginGroup = token.next;
if (beginGroup.endGroup == null) {
listener.unmatched(beginGroup);
}
- token = beginGroup.endGroup.next;
+ token = beginGroup.endGroup;
}
}
- 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>();
}
@@ -1398,31 +1292,11 @@
/**
* 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()) {
@@ -1438,57 +1312,13 @@
Token gtToken = beginGroupToken.endGroup;
if (gtToken != null) {
// We are looking at "qualified '<' ... '>' ...".
- peek = gtToken.next;
+ return 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 1c03790..6aaa52c 100644
--- a/pkg/compiler/lib/src/parser/partial_parser.dart
+++ b/pkg/compiler/lib/src/parser/partial_parser.dart
@@ -156,8 +156,7 @@
return token;
}
- Token parseFormalParameters(Token token, {bool inFunctionType: false})
- => skipFormals(token);
+ Token parseFormalParameters(Token token) => skipFormals(token);
Token skipFormals(Token token) {
listener.beginOptionalFormalParameters(token);
diff --git a/pkg/compiler/lib/src/resolution/class_hierarchy.dart b/pkg/compiler/lib/src/resolution/class_hierarchy.dart
index f9e6480..2544cb4 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
- .resolveNominalTypeAnnotation(this, typeNode.bound, const []);
+ ResolutionDartType boundType =
+ typeResolver.resolveTypeAnnotation(this, typeNode.bound);
variableElement.boundCache = boundType;
void checkTypeVariableBound() {
@@ -202,8 +202,7 @@
} else {
ConstructorElement superConstructor = superMember;
superConstructor.computeType(resolution);
- if (!CallStructure.NO_ARGS
- .signatureApplies(superConstructor.functionSignature)) {
+ if (!CallStructure.NO_ARGS.signatureApplies(superConstructor.type)) {
MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
reporter.reportErrorMessage(node, kind);
superMember = new ErroneousElementX(kind, {}, '', element);
@@ -251,8 +250,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(NominalTypeAnnotation mixinNode) {
- ResolutionDartType mixinType = resolveNominalType(mixinNode);
+ ResolutionDartType checkMixinType(TypeAnnotation mixinNode) {
+ ResolutionDartType mixinType = resolveType(mixinNode);
if (isBlackListed(mixinType)) {
reporter.reportErrorMessage(
mixinNode, MessageKind.CANNOT_MIXIN, {'type': mixinType});
@@ -441,13 +440,13 @@
return mixinType;
}
- ResolutionDartType resolveNominalType(NominalTypeAnnotation node) {
- return typeResolver.resolveNominalTypeAnnotation(this, node, const []);
+ ResolutionDartType resolveType(TypeAnnotation node) {
+ return typeResolver.resolveTypeAnnotation(this, node);
}
ResolutionDartType resolveSupertype(
- ClassElement cls, NominalTypeAnnotation superclass) {
- ResolutionDartType supertype = resolveNominalType(superclass);
+ ClassElement cls, TypeAnnotation superclass) {
+ ResolutionDartType supertype = resolveType(superclass);
if (supertype != null) {
if (supertype.isMalformed) {
reporter.reportErrorMessage(
@@ -477,7 +476,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 = resolveNominalType(link.head);
+ ResolutionDartType interfaceType = resolveType(link.head);
if (interfaceType != null) {
if (interfaceType.isMalformed) {
reporter.reportErrorMessage(
@@ -491,7 +490,7 @@
{'className': element.name, 'enumType': interfaceType});
} else if (!interfaceType.isInterfaceType) {
// TODO(johnniwinther): Handle dynamic.
- NominalTypeAnnotation typeAnnotation = link.head;
+ TypeAnnotation typeAnnotation = link.head;
reporter.reportErrorMessage(
typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
} else {
@@ -616,7 +615,7 @@
visitNodeList(node.interfaces);
}
- void visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+ void visitTypeAnnotation(TypeAnnotation node) {
node.typeName.accept(this);
}
diff --git a/pkg/compiler/lib/src/resolution/constructors.dart b/pkg/compiler/lib/src/resolution/constructors.dart
index cc02a99..90964c8 100644
--- a/pkg/compiler/lib/src/resolution/constructors.dart
+++ b/pkg/compiler/lib/src/resolution/constructors.dart
@@ -275,8 +275,7 @@
reportAndCreateErroneousConstructor(node, constructorName, kind, {});
} else {
lookedupConstructor.computeType(visitor.resolution);
- if (!callStructure
- .signatureApplies(lookedupConstructor.functionSignature)) {
+ if (!callStructure.signatureApplies(lookedupConstructor.type)) {
MessageKind kind = isImplicitSuperCall
? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
: MessageKind.NO_MATCHING_CONSTRUCTOR;
@@ -619,7 +618,7 @@
return result;
}
- ConstructorResult visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+ ConstructorResult visitTypeAnnotation(TypeAnnotation 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 b02d8bf..844f0b0 100644
--- a/pkg/compiler/lib/src/resolution/members.dart
+++ b/pkg/compiler/lib/src/resolution/members.dart
@@ -1566,7 +1566,7 @@
case AccessKind.SUPER_METHOD:
MethodElement superMethod = semantics.element;
superMethod.computeType(resolution);
- if (!callStructure.signatureApplies(superMethod.functionSignature)) {
+ if (!callStructure.signatureApplies(superMethod.type)) {
registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
registry.registerDynamicUse(new DynamicUse(selector, null));
registry.registerFeature(Feature.SUPER_NO_SUCH_METHOD);
@@ -2494,7 +2494,7 @@
case AccessKind.LOCAL_FUNCTION:
LocalFunctionElementX function = semantics.element;
function.computeType(resolution);
- if (!callStructure.signatureApplies(function.functionSignature)) {
+ if (!callStructure.signatureApplies(function.type)) {
registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
registry.registerDynamicUse(new DynamicUse(selector, null));
isIncompatibleInvoke = true;
@@ -2662,7 +2662,7 @@
case AccessKind.TOPLEVEL_METHOD:
MethodElement method = semantics.element;
method.computeType(resolution);
- if (!callStructure.signatureApplies(method.functionSignature)) {
+ if (!callStructure.signatureApplies(method.type)) {
registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
registry.registerDynamicUse(new DynamicUse(selector, null));
isIncompatibleInvoke = true;
@@ -3841,7 +3841,7 @@
case ConstructorResultKind.GENERATIVE:
// Ensure that the signature of [constructor] has been computed.
constructor.computeType(resolution);
- if (!callStructure.signatureApplies(constructor.functionSignature)) {
+ if (!callStructure.signatureApplies(constructor.type)) {
isInvalid = true;
kind = ConstructorAccessKind.INCOMPATIBLE;
registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
@@ -3852,7 +3852,7 @@
case ConstructorResultKind.FACTORY:
// Ensure that the signature of [constructor] has been computed.
constructor.computeType(resolution);
- if (!callStructure.signatureApplies(constructor.functionSignature)) {
+ if (!callStructure.signatureApplies(constructor.type)) {
// The effective target might still be valid(!) so the is not an
// invalid case in itself. For instance
//
diff --git a/pkg/compiler/lib/src/resolution/resolution_common.dart b/pkg/compiler/lib/src/resolution/resolution_common.dart
index 837906c..53d3c69 100644
--- a/pkg/compiler/lib/src/resolution/resolution_common.dart
+++ b/pkg/compiler/lib/src/resolution/resolution_common.dart
@@ -56,10 +56,6 @@
/// 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/send_structure.dart b/pkg/compiler/lib/src/resolution/send_structure.dart
index 6f9d97f..799b0a2 100644
--- a/pkg/compiler/lib/src/resolution/send_structure.dart
+++ b/pkg/compiler/lib/src/resolution/send_structure.dart
@@ -2116,8 +2116,7 @@
ConstructorElement effectiveTarget = constructor.effectiveTarget;
ResolutionInterfaceType effectiveTargetType =
constructor.computeEffectiveTargetType(semantics.type);
- if (callStructure
- .signatureApplies(effectiveTarget.functionSignature)) {
+ if (callStructure.signatureApplies(effectiveTarget.type)) {
return visitor.visitRedirectingFactoryConstructorInvoke(
node,
semantics.element,
@@ -2137,7 +2136,7 @@
arg);
}
}
- if (callStructure.signatureApplies(constructor.functionSignature)) {
+ if (callStructure.signatureApplies(constructor.type)) {
return visitor.visitFactoryConstructorInvoke(node, constructor,
semantics.type, node.send.argumentsNode, callStructure, arg);
}
diff --git a/pkg/compiler/lib/src/resolution/signatures.dart b/pkg/compiler/lib/src/resolution/signatures.dart
index 7fd39ee..ae39454 100644
--- a/pkg/compiler/lib/src/resolution/signatures.dart
+++ b/pkg/compiler/lib/src/resolution/signatures.dart
@@ -94,9 +94,7 @@
reporter.internalError(node, 'function type parameters not supported');
}
currentDefinitions = node;
- FormalElementX element = definition == null
- ? createUnnamedParameter() // This happens in function types.
- : definition.accept(this);
+ FormalElementX element = definition.accept(this);
if (currentDefinitions.metadata != null) {
element.metadataInternal =
resolution.resolver.resolveMetadata(element, node);
@@ -115,8 +113,7 @@
void computeParameterType(FormalElementX element,
[VariableElement fieldElement]) {
- // Function-type as in `foo(int bar(String x))`
- void computeInlineFunctionType(FunctionExpression functionExpression) {
+ void computeFunctionType(FunctionExpression functionExpression) {
FunctionSignature functionSignature = SignatureResolver.analyze(
resolution,
scope,
@@ -138,14 +135,13 @@
assert(invariant(currentDefinitions, link.tail.isEmpty));
if (link.head.asFunctionExpression() != null) {
// Inline function typed parameter, like `void m(int f(String s))`.
- computeInlineFunctionType(link.head);
+ computeFunctionType(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])`.
- computeInlineFunctionType(
- link.head.asSend().selector.asFunctionExpression());
+ computeFunctionType(link.head.asSend().selector.asFunctionExpression());
} else {
assert(invariant(currentDefinitions,
link.head.asIdentifier() != null || link.head.asSend() != null));
@@ -202,15 +198,6 @@
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;
@@ -434,7 +421,7 @@
List<Element> orderedOptionalParameters =
visitor.optionalParameters.toList();
if (visitor.optionalParametersAreNamed) {
- // TODO(karlklose); replace when [visitor.optionalParameters] is a [List].
+ // TODO(karlklose); replace when [visitor.optinalParameters] is a [List].
orderedOptionalParameters.sort((Element a, Element b) {
return a.name.compareTo(b.name);
});
@@ -449,7 +436,7 @@
namedParameterTypes =
namedParameterTypesBuilder.toLink().toList(growable: false);
} else {
- // TODO(karlklose); replace when [visitor.optionalParameters] is a [List].
+ // TODO(karlklose); replace when [visitor.optinalParameters] 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 34e5cab..318e748 100644
--- a/pkg/compiler/lib/src/resolution/type_resolver.dart
+++ b/pkg/compiler/lib/src/resolution/type_resolver.dart
@@ -27,16 +27,6 @@
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;
@@ -76,154 +66,6 @@
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;
@@ -232,8 +74,7 @@
ResolutionDartType checkNoTypeArguments(ResolutionDartType type) {
List<ResolutionDartType> arguments = new List<ResolutionDartType>();
bool hasTypeArgumentMismatch = resolveTypeArguments(
- visitor, node, const <ResolutionDartType>[], arguments,
- visibleTypeParameterNames);
+ visitor, node, const <ResolutionDartType>[], arguments);
if (hasTypeArgumentMismatch) {
return new MalformedType(
new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
@@ -265,6 +106,9 @@
}
}
+ Element element = resolveTypeName(prefixName, typeName, visitor.scope,
+ deferredIsMalformed: deferredIsMalformed);
+
ResolutionDartType reportFailureAndCreateType(
MessageKind messageKind, Map messageArguments,
{ResolutionDartType userProvidedBadType,
@@ -284,33 +128,14 @@
typeName.source, visitor.enclosingElement);
}
List<ResolutionDartType> arguments = <ResolutionDartType>[];
- resolveTypeArguments(visitor, node, const <ResolutionDartType>[],
- arguments, visibleTypeParameterNames);
+ resolveTypeArguments(
+ visitor, node, const <ResolutionDartType>[], arguments);
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 (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) {
+ if (element == null) {
type = reportFailureAndCreateType(
MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
} else if (element.isAmbiguous) {
@@ -345,9 +170,8 @@
resolver.ensureClassWillBeResolvedInternal(cls);
cls.computeType(resolution);
List<ResolutionDartType> arguments = <ResolutionDartType>[];
- bool hasTypeArgumentMismatch = resolveTypeArguments(
- visitor, node, cls.typeVariables, arguments,
- visibleTypeParameterNames);
+ bool hasTypeArgumentMismatch =
+ resolveTypeArguments(visitor, node, cls.typeVariables, arguments);
if (hasTypeArgumentMismatch) {
type = new BadInterfaceType(
cls.declaration,
@@ -370,8 +194,7 @@
typdef.computeType(resolution);
List<ResolutionDartType> arguments = <ResolutionDartType>[];
bool hasTypeArgumentMismatch = resolveTypeArguments(
- visitor, node, typdef.typeVariables, arguments,
- visibleTypeParameterNames);
+ visitor, node, typdef.typeVariables, arguments);
if (hasTypeArgumentMismatch) {
type = new BadTypedefType(
typdef,
@@ -418,7 +241,7 @@
}
/// Checks the type arguments of [type] against the type variable bounds.
- void checkTypeVariableBounds(NominalTypeAnnotation node, GenericType type) {
+ void checkTypeVariableBounds(TypeAnnotation node, GenericType type) {
void checkTypeVariableBound(_, ResolutionDartType typeArgument,
ResolutionTypeVariableType typeVariable, ResolutionDartType bound) {
if (!types.isSubtype(typeArgument, bound)) {
@@ -443,10 +266,9 @@
*/
bool resolveTypeArguments(
MappingVisitor visitor,
- NominalTypeAnnotation node,
+ TypeAnnotation node,
List<ResolutionDartType> typeVariables,
- List<ResolutionDartType> arguments,
- List<List<String>> visibleTypeParameterNames) {
+ List<ResolutionDartType> arguments) {
if (node.typeArguments == null) {
return false;
}
@@ -461,8 +283,8 @@
typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
typeArgumentCountMismatch = true;
}
- ResolutionDartType argType = _resolveTypeAnnotation(
- visitor, typeArguments.head, visibleTypeParameterNames);
+ ResolutionDartType argType =
+ resolveTypeAnnotation(visitor, typeArguments.head);
// 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 6ed34df..90fc2c3 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.templateParameters);
+ resolveTypeVariableBounds(node.typeParameters);
FunctionSignature signature = SignatureResolver.analyze(
resolution,
scope,
- node.typeParameters,
+ null /* typeVariables */,
node.formals,
node.returnType,
element,
diff --git a/pkg/compiler/lib/src/serialization/equivalence.dart b/pkg/compiler/lib/src/serialization/equivalence.dart
index 50318a8..f3fc4f1 100644
--- a/pkg/compiler/lib/src/serialization/equivalence.dart
+++ b/pkg/compiler/lib/src/serialization/equivalence.dart
@@ -1965,8 +1965,7 @@
}
@override
- bool visitNominalTypeAnnotation(
- NominalTypeAnnotation node1, NominalTypeAnnotation node2) {
+ bool visitTypeAnnotation(TypeAnnotation node1, TypeAnnotation node2) {
return testNodes(
node1, node2, 'typeName', node1.typeName, node2.typeName) &&
testNodes(node1, node2, 'typeArguments', node1.typeArguments,
@@ -1974,16 +1973,6 @@
}
@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);
@@ -1997,8 +1986,8 @@
testNodes(
node1, node2, 'returnType', node1.returnType, node2.returnType) &&
testNodes(node1, node2, 'name', node1.name, node2.name) &&
- testNodes(node1, node2, 'typeParameters', node1.templateParameters,
- node2.templateParameters) &&
+ testNodes(node1, node2, 'typeParameters', node1.typeParameters,
+ node2.typeParameters) &&
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 4c20911..e1fb5d0 100644
--- a/pkg/compiler/lib/src/serialization/modelz.dart
+++ b/pkg/compiler/lib/src/serialization/modelz.dart
@@ -2152,9 +2152,6 @@
@override
ElementKind get kind => ElementKind.PARAMETER;
-
- @override
- bool get isUnnamed => false;
}
class InitializingFormalElementZ extends LocalParameterElementZ
diff --git a/pkg/compiler/lib/src/ssa/builder.dart b/pkg/compiler/lib/src/ssa/builder.dart
index 7cf54fc..24feb36 100644
--- a/pkg/compiler/lib/src/ssa/builder.dart
+++ b/pkg/compiler/lib/src/ssa/builder.dart
@@ -668,8 +668,6 @@
Local returnLocal;
ResolutionDartType returnType;
- bool inTryStatement = false;
-
ConstantValue getConstantForNode(ast.Node node) {
ConstantValue constantValue =
backend.constants.getConstantValueForNode(node, elements);
@@ -1070,7 +1068,7 @@
ConstructorElement target = constructor.definingConstructor.implementation;
bool match = !target.isMalformed &&
- CallStructure.addForwardingElementArgumentsToList(
+ Elements.addForwardingElementArgumentsToList<HInstruction>(
constructor,
arguments,
target,
@@ -1163,7 +1161,8 @@
reporter.internalError(
superClass, "No default constructor available.");
}
- List<HInstruction> arguments = CallStructure.NO_ARGS.makeArgumentsList(
+ List<HInstruction> arguments = Elements.makeArgumentsList<HInstruction>(
+ CallStructure.NO_ARGS,
const Link<ast.Node>(),
target.implementation,
null,
@@ -1910,6 +1909,17 @@
}
}
+ void handleIf(
+ {ast.Node node,
+ void visitCondition(),
+ void visitThen(),
+ void visitElse(),
+ SourceInformation sourceInformation}) {
+ SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
+ branchBuilder.handleIf(visitCondition, visitThen, visitElse,
+ sourceInformation: sourceInformation);
+ }
+
visitIf(ast.If node) {
assert(isReachable);
handleIf(
@@ -2547,7 +2557,8 @@
return pop();
}
- return callStructure.makeArgumentsList(
+ return Elements.makeArgumentsList<HInstruction>(
+ callStructure,
arguments,
element,
compileArgument,
@@ -3435,8 +3446,7 @@
// calling [makeStaticArgumentList].
constructorImplementation = constructor.implementation;
if (constructorImplementation.isMalformed ||
- !callStructure
- .signatureApplies(constructorImplementation.functionSignature)) {
+ !callStructure.signatureApplies(constructorImplementation.type)) {
generateWrongArgumentCountError(send, constructor, send.arguments);
return;
}
@@ -5053,14 +5063,6 @@
dup();
}
- void handleInTryStatement() {
- if (!inTryStatement) return;
- HBasicBlock block = close(new HExitTry());
- HBasicBlock newBlock = graph.addNewBlock();
- block.addSuccessor(newBlock);
- open(newBlock);
- }
-
visitRethrow(ast.Rethrow node) {
HInstruction exception = rethrowableException;
if (exception == null) {
@@ -5985,7 +5987,7 @@
* [switchCases] must be either an [Iterable] of [ast.SwitchCase] nodes or
* a [Link] or a [ast.NodeList] of [ast.SwitchCase] nodes.
* [getConstants] returns the set of constants for a switch case.
- * [isDefaultCase] returns [:true:] if the provided switch case should be
+ * [isDefaultCase] returns true if the provided switch case should be
* considered default for the created switch statement.
* [buildSwitchCase] creates the statements for the switch case.
*/
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index 2fb417b..223889e 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -40,6 +40,7 @@
import 'loop_handler.dart';
import 'nodes.dart';
import 'ssa_branch_builder.dart';
+import 'switch_continue_analysis.dart';
import 'type_builder.dart';
import 'types.dart' show TypeMaskFactory;
@@ -558,6 +559,7 @@
if (expression is ir.Throw) {
// TODO(sra): Prevent generating a statement when inlining.
_visitThrowExpression(expression.expression);
+ handleInTryStatement();
closeAndGotoExit(new HThrow(pop(), null));
} else {
expression.accept(this);
@@ -565,6 +567,26 @@
}
}
+ /// Returns true if the [type] is a valid return type for an asynchronous
+ /// function.
+ ///
+ /// Asynchronous functions return a `Future`, and a valid return is thus
+ /// either dynamic, Object, or Future.
+ ///
+ /// We do not accept the internal Future implementation class.
+ bool isValidAsyncReturnType(ir.DartType type) {
+ // TODO(sigurdm): In an internal library a function could be declared:
+ //
+ // _FutureImpl foo async => 1;
+ //
+ // This should be valid (because the actual value returned from an async
+ // function is a `_FutureImpl`), but currently false is returned in this
+ // case.
+ return type is ir.DynamicType ||
+ type == astAdapter.objectClass.thisType ||
+ (type is ir.InterfaceType && type == astAdapter.futureClass.thisType);
+ }
+
@override
void visitReturnStatement(ir.ReturnStatement returnStatement) {
HInstruction value;
@@ -573,10 +595,25 @@
} else {
assert(_targetFunction != null && _targetFunction is ir.FunctionNode);
returnStatement.expression.accept(this);
- value = typeBuilder.potentiallyCheckOrTrustType(
- pop(), astAdapter.getFunctionReturnType(_targetFunction));
+ value = pop();
+ if (_targetFunction.asyncMarker == ir.AsyncMarker.Async) {
+ var returnType = astAdapter.getDartType(_targetFunction.returnType);
+ if (compiler.options.enableTypeAssertions &&
+ !isValidAsyncReturnType(_targetFunction.returnType)) {
+ generateTypeError(
+ returnStatement,
+ "Async function returned a Future,"
+ " was declared to return a ${_targetFunction.returnType}.");
+ pop();
+ return;
+ }
+ } else {
+ value = typeBuilder.potentiallyCheckOrTrustType(
+ value, astAdapter.getFunctionReturnType(_targetFunction));
+ }
}
// TODO(het): Add source information
+ handleInTryStatement();
// TODO(het): Set a return value instead of closing the function when we
// support inlining.
closeAndGotoExit(new HReturn(value, null));
@@ -621,8 +658,7 @@
@override
void visitForInStatement(ir.ForInStatement forInStatement) {
if (forInStatement.isAsync) {
- compiler.reporter.internalError(astAdapter.getNode(forInStatement),
- "Cannot compile async for-in using kernel.");
+ _buildAsyncForIn(forInStatement);
}
// If the expression being iterated over is a JS indexable type, we can
// generate an optimized version of for-in that uses indexing.
@@ -777,6 +813,57 @@
forInStatement, buildInitializer, buildCondition, () {}, buildBody);
}
+ void _buildAsyncForIn(ir.ForInStatement forInStatement) {
+ // The async-for is implemented with a StreamIterator.
+ HInstruction streamIterator;
+
+ forInStatement.iterable.accept(this);
+ _pushStaticInvocation(
+ astAdapter.streamIteratorConstructor,
+ [pop(), graph.addConstantNull(closedWorld)],
+ astAdapter.streamIteratorConstructorType);
+ streamIterator = pop();
+
+ void buildInitializer() {}
+
+ HInstruction buildCondition() {
+ TypeMask mask = astAdapter.typeOfIteratorMoveNext(forInStatement);
+ _pushDynamicInvocation(forInStatement, mask, [streamIterator],
+ selector: Selectors.moveNext);
+ HInstruction future = pop();
+ push(new HAwait(future, astAdapter.makeSubtypeOfObject(closedWorld)));
+ return popBoolified();
+ }
+
+ void buildBody() {
+ TypeMask mask = astAdapter.typeOfIteratorCurrent(forInStatement);
+ _pushDynamicInvocation(forInStatement, mask, [streamIterator],
+ selector: Selectors.current);
+ localsHandler.updateLocal(
+ astAdapter.getLocal(forInStatement.variable), pop());
+ forInStatement.body.accept(this);
+ }
+
+ void buildUpdate() {}
+
+ // Creates a synthetic try/finally block in case anything async goes amiss.
+ TryCatchFinallyBuilder tryBuilder = new TryCatchFinallyBuilder(this);
+ // Build fake try body:
+ loopHandler.handleLoop(forInStatement, buildInitializer, buildCondition,
+ buildUpdate, buildBody);
+
+ void finalizerFunction() {
+ _pushDynamicInvocation(forInStatement, null, [streamIterator],
+ selector: Selectors.cancel);
+ add(new HAwait(pop(), astAdapter.makeSubtypeOfObject(closedWorld)));
+ }
+
+ tryBuilder
+ ..closeTryBody()
+ ..buildFinallyBlock(finalizerFunction)
+ ..cleanUp();
+ }
+
HInstruction callSetRuntimeTypeInfo(
HInstruction typeInfo, HInstruction newObject) {
// Set the runtime type information on the object.
@@ -820,8 +907,7 @@
HLoopInformation loopInfo = current.loopInformation;
HBasicBlock loopEntryBlock = current;
HBasicBlock bodyEntryBlock = current;
- JumpTarget target = astAdapter.elements
- .getTargetDefinition(astAdapter.getNode(doStatement));
+ JumpTarget target = astAdapter.getJumpTarget(doStatement);
bool hasContinues = target != null && target.isContinueTarget;
if (hasContinues) {
// Add extra block to hang labels on.
@@ -933,8 +1019,7 @@
// Since the body of the loop has a break, we attach a synthesized label
// to the body.
SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
- JumpTarget target = astAdapter.elements
- .getTargetDefinition(astAdapter.getNode(doStatement));
+ JumpTarget target = astAdapter.getJumpTarget(doStatement);
LabelDefinition label = target.addLabel(null, 'loop');
label.setBreakTarget();
HLabeledBlockInformation info = new HLabeledBlockInformation(
@@ -958,6 +1043,18 @@
visitElse: () => ifStatement.otherwise?.accept(this));
}
+ void handleIf(
+ {ir.Node node,
+ void visitCondition(),
+ void visitThen(),
+ void visitElse(),
+ SourceInformation sourceInformation}) {
+ SsaBranchBuilder branchBuilder = new SsaBranchBuilder(
+ this, compiler, node == null ? node : astAdapter.getNode(node));
+ branchBuilder.handleIf(visitCondition, visitThen, visitElse,
+ sourceInformation: sourceInformation);
+ }
+
@override
void visitAsExpression(ir.AsExpression asExpression) {
asExpression.operand.accept(this);
@@ -1031,30 +1128,56 @@
handleIf(visitCondition: buildCondition, visitThen: fail);
}
+ /// Creates a [JumpHandler] for a statement. The node must be a jump
+ /// target. If there are no breaks or continues targeting the statement,
+ /// a special "null handler" is returned.
+ ///
+ /// [isLoopJump] is true when the jump handler is for a loop. This is used
+ /// to distinguish the synthesized loop created for a switch statement with
+ /// continue statements from simple switch statements.
+ JumpHandler createJumpHandler(ir.TreeNode node, {bool isLoopJump: false}) {
+ JumpTarget target = astAdapter.getJumpTarget(node);
+ assert(target is KernelJumpTarget);
+ if (target == null) {
+ // No breaks or continues to this node.
+ return new NullJumpHandler(compiler.reporter);
+ }
+ if (isLoopJump && node is ir.SwitchStatement) {
+ throw 'Kernel Switch Statement handler not yet implemented.';
+ }
+
+ return new JumpHandler(this, target);
+ }
+
@override
void visitBreakStatement(ir.BreakStatement breakStatement) {
assert(!isAborted());
+ handleInTryStatement();
JumpTarget target = astAdapter.getJumpTarget(breakStatement.target);
assert(target != null);
JumpHandler handler = jumpTargets[target];
assert(handler != null);
- handler.generateBreak(handler.labels.first);
+ if (handler.labels.isNotEmpty) {
+ handler.generateBreak(handler.labels.first);
+ } else {
+ handler.generateBreak();
+ }
}
@override
void visitLabeledStatement(ir.LabeledStatement labeledStatement) {
- JumpTarget target = astAdapter.getJumpTarget(labeledStatement);
- JumpHandler handler = new JumpHandler(this, target);
-
ir.Statement body = labeledStatement.body;
if (body is ir.WhileStatement ||
body is ir.DoStatement ||
body is ir.ForStatement ||
- body is ir.ForInStatement) {
- // loops handle breaks on their own
+ body is ir.ForInStatement ||
+ body is ir.SwitchStatement) {
+ // loops and switches handle breaks on their own
body.accept(this);
return;
}
+ JumpHandler handler = createJumpHandler(labeledStatement);
+
LocalsHandler beforeLocals = new LocalsHandler.from(localsHandler);
HBasicBlock newBlock = openNewBlock();
@@ -1084,6 +1207,198 @@
handler.close();
}
+ /// Loop through the cases in a switch and create a mapping of case
+ /// expressions to constants.
+ Map<ir.Expression, ConstantValue> _buildSwitchCaseConstants(
+ ir.SwitchStatement switchStatement) {
+ Map<ir.Expression, ConstantValue> constants =
+ new Map<ir.Expression, ConstantValue>();
+ for (ir.SwitchCase switchCase in switchStatement.cases) {
+ for (ir.Expression caseExpression in switchCase.expressions) {
+ ConstantValue constant = astAdapter.getConstantFor(caseExpression);
+ constants[caseExpression] = constant;
+ }
+ }
+ return constants;
+ }
+
+ @override
+ void visitContinueSwitchStatement(
+ ir.ContinueSwitchStatement switchStatement) {
+ handleInTryStatement();
+ JumpTarget target = astAdapter.getJumpTarget(switchStatement.target);
+ assert(target != null);
+ JumpHandler handler = jumpTargets[target];
+ assert(handler != null);
+ assert(target.labels.isNotEmpty);
+ handler.generateContinue(target.labels.first);
+ }
+
+ @override
+ void visitSwitchStatement(ir.SwitchStatement switchStatement) {
+ Map<ir.Expression, ConstantValue> constants =
+ _buildSwitchCaseConstants(switchStatement);
+
+ // The switch case indices must match those computed in
+ // [KernelSwitchCaseJumpHandler].
+ bool hasContinue = false;
+ Map<ir.SwitchCase, int> caseIndex = new Map<ir.SwitchCase, int>();
+ int switchIndex = 1;
+ bool hasDefault = false;
+ for (ir.SwitchCase switchCase in switchStatement.cases) {
+ if (SwitchContinueAnalysis.containsContinue(switchCase.body)) {
+ hasContinue = true;
+ }
+ if (switchCase.isDefault) {
+ hasDefault = true;
+ }
+ caseIndex[switchCase] = switchIndex;
+ switchIndex++;
+ }
+
+ JumpHandler jumpHandler = createJumpHandler(switchStatement);
+ if (!hasContinue) {
+ // If the switch statement has no switch cases targeted by continue
+ // statements we encode the switch statement directly.
+ _buildSimpleSwitchStatement(switchStatement, jumpHandler, constants);
+ } else {
+ throw 'Complex switch statement with continue label not implemented yet.';
+ }
+ }
+
+ /// Helper for building switch statements.
+ static bool _isDefaultCase(ir.SwitchCase switchCase) =>
+ switchCase == null || switchCase.isDefault;
+
+ /// Builds a simple switch statement which does not handle uses of continue
+ /// statements to labeled switch cases.
+ void _buildSimpleSwitchStatement(ir.SwitchStatement switchStatement,
+ JumpHandler jumpHandler, Map<ir.Expression, ConstantValue> constants) {
+ void buildSwitchCase(ir.SwitchCase switchCase) {
+ switchCase.body.accept(this);
+ }
+
+ handleSwitch(switchStatement, jumpHandler, switchStatement.cases,
+ _isDefaultCase, buildSwitchCase, constants);
+ jumpHandler.close();
+ }
+
+ /// Creates a switch statement.
+ ///
+ /// [jumpHandler] is the [JumpHandler] for the created switch statement.
+ /// [buildSwitchCase] creates the statements for the switch case.
+ void handleSwitch(
+ ir.SwitchStatement switchStatement,
+ JumpHandler jumpHandler,
+ List<ir.SwitchCase> switchCases,
+ bool isDefaultCase(ir.SwitchCase switchCase),
+ void buildSwitchCase(ir.SwitchCase switchCase),
+ Map<ir.Expression, ConstantValue> constantsLookup) {
+ HBasicBlock expressionStart = openNewBlock();
+ switchStatement.expression.accept(this);
+ HInstruction expression = pop();
+
+ List<ConstantValue> getConstants(ir.SwitchCase switchCase) {
+ List<ConstantValue> constantList = <ConstantValue>[];
+ if (switchCase != null) {
+ for (var expression in switchCase.expressions) {
+ constantList.add(constantsLookup[expression]);
+ }
+ }
+ return constantList;
+ }
+
+ if (switchCases.isEmpty) {
+ return;
+ }
+
+ HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
+ HBasicBlock expressionEnd = close(switchInstruction);
+ LocalsHandler savedLocals = localsHandler;
+
+ List<HStatementInformation> statements = <HStatementInformation>[];
+ bool hasDefault = false;
+ for (ir.SwitchCase switchCase in switchCases) {
+ HBasicBlock block = graph.addNewBlock();
+ for (ConstantValue constant in getConstants(switchCase)) {
+ HConstant hConstant = graph.addConstant(constant, closedWorld);
+ switchInstruction.inputs.add(hConstant);
+ hConstant.usedBy.add(switchInstruction);
+ expressionEnd.addSuccessor(block);
+ }
+
+ if (isDefaultCase(switchCase)) {
+ // An HSwitch has n inputs and n+1 successors, the last being the
+ // default case.
+ expressionEnd.addSuccessor(block);
+ hasDefault = true;
+ }
+ open(block);
+ localsHandler = new LocalsHandler.from(savedLocals);
+ buildSwitchCase(switchCase);
+ statements.add(
+ new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
+ }
+
+ // Add a join-block if necessary.
+ // We create [joinBlock] early, and then go through the cases that might
+ // want to jump to it. In each case, if we add [joinBlock] as a successor
+ // of another block, we also add an element to [caseHandlers] that is used
+ // to create the phis in [joinBlock].
+ // If we never jump to the join block, [caseHandlers] will stay empty, and
+ // the join block is never added to the graph.
+ HBasicBlock joinBlock = new HBasicBlock();
+ List<LocalsHandler> caseHandlers = <LocalsHandler>[];
+ jumpHandler.forEachBreak((HBreak instruction, LocalsHandler locals) {
+ instruction.block.addSuccessor(joinBlock);
+ caseHandlers.add(locals);
+ });
+ jumpHandler.forEachContinue((HContinue instruction, LocalsHandler locals) {
+ assert(invariant(astAdapter.getNode(switchStatement), false,
+ message: 'Continue cannot target a switch.'));
+ });
+ if (!isAborted()) {
+ current.close(new HGoto());
+ lastOpenedBlock.addSuccessor(joinBlock);
+ caseHandlers.add(localsHandler);
+ }
+ if (!hasDefault) {
+ // Always create a default case, to avoid a critical edge in the
+ // graph.
+ HBasicBlock defaultCase = addNewBlock();
+ expressionEnd.addSuccessor(defaultCase);
+ open(defaultCase);
+ close(new HGoto());
+ defaultCase.addSuccessor(joinBlock);
+ caseHandlers.add(savedLocals);
+ statements.add(new HSubGraphBlockInformation(
+ new SubGraph(defaultCase, defaultCase)));
+ }
+ assert(caseHandlers.length == joinBlock.predecessors.length);
+ if (caseHandlers.length != 0) {
+ graph.addBlock(joinBlock);
+ open(joinBlock);
+ if (caseHandlers.length == 1) {
+ localsHandler = caseHandlers[0];
+ } else {
+ localsHandler = savedLocals.mergeMultiple(caseHandlers, joinBlock);
+ }
+ } else {
+ // The joinblock is not used.
+ joinBlock = null;
+ }
+
+ HSubExpressionBlockInformation expressionInfo =
+ new HSubExpressionBlockInformation(
+ new SubExpression(expressionStart, expressionEnd));
+ expressionStart.setBlockFlow(
+ new HSwitchBlockInformation(
+ expressionInfo, statements, jumpHandler.target, jumpHandler.labels),
+ joinBlock);
+
+ jumpHandler.close();
+ }
+
@override
void visitConditionalExpression(ir.ConditionalExpression conditional) {
SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler);
@@ -2242,6 +2557,7 @@
void visitThrow(ir.Throw throwNode) {
_visitThrowExpression(throwNode.expression);
if (isReachable) {
+ handleInTryStatement();
push(new HThrowExpression(pop(), null));
isReachable = false;
}
@@ -2257,6 +2573,19 @@
}
}
+ void visitYieldStatement(ir.YieldStatement yieldStatement) {
+ yieldStatement.expression.accept(this);
+ add(new HYield(pop(), yieldStatement.isYieldStar));
+ }
+
+ @override
+ void visitAwaitExpression(ir.AwaitExpression await) {
+ await.operand.accept(this);
+ HInstruction awaited = pop();
+ // TODO(herhut): Improve this type.
+ push(new HAwait(awaited, astAdapter.makeSubtypeOfObject(closedWorld)));
+ }
+
@override
void visitRethrow(ir.Rethrow rethrowNode) {
HInstruction exception = rethrowableException;
@@ -2265,6 +2594,7 @@
compiler.reporter.internalError(astAdapter.getNode(rethrowNode),
'rethrowableException should not be null.');
}
+ handleInTryStatement();
SourceInformation sourceInformation = null;
closeAndGotoExit(new HThrow(exception, sourceInformation, isRethrow: true));
// ir.Rethrow is an expression so we need to push a value - a constant with
@@ -2326,7 +2656,9 @@
}
tryBuilder
- ..buildFinallyBlock(tryFinally)
+ ..buildFinallyBlock(() {
+ tryFinally.finalizer.accept(this);
+ })
..cleanUp();
}
}
@@ -2347,6 +2679,10 @@
HLocalValue exception;
KernelSsaBuilder kernelBuilder;
+ /// True if the code surrounding this try statement was also part of a
+ /// try/catch/finally statement.
+ bool previouslyInTryStatement;
+
SubGraph bodyGraph;
SubGraph catchGraph;
SubGraph finallyGraph;
@@ -2364,6 +2700,8 @@
originalSavedLocals = new LocalsHandler.from(kernelBuilder.localsHandler);
enterBlock = kernelBuilder.openNewBlock();
kernelBuilder.close(tryInstruction);
+ previouslyInTryStatement = kernelBuilder.inTryStatement;
+ kernelBuilder.inTryStatement = true;
startTryBlock = kernelBuilder.graph.addNewBlock();
kernelBuilder.open(startTryBlock);
@@ -2423,11 +2761,11 @@
/// Build the finally{} clause of a try/{catch}/finally statement. Note this
/// does not examine the body of the try clause, only the finally portion.
- void buildFinallyBlock(ir.TryFinally tryFinally) {
+ void buildFinallyBlock(void buildFinalizer()) {
kernelBuilder.localsHandler = new LocalsHandler.from(originalSavedLocals);
startFinallyBlock = kernelBuilder.graph.addNewBlock();
kernelBuilder.open(startFinallyBlock);
- tryFinally.finalizer.accept(kernelBuilder);
+ buildFinalizer();
if (!kernelBuilder.isAborted()) {
endFinallyBlock = kernelBuilder.close(new HGoto());
}
@@ -2545,5 +2883,6 @@
kernelBuilder.wrapStatementGraph(catchGraph),
kernelBuilder.wrapStatementGraph(finallyGraph)),
exitBlock);
+ kernelBuilder.inTryStatement = previouslyInTryStatement;
}
}
diff --git a/pkg/compiler/lib/src/ssa/graph_builder.dart b/pkg/compiler/lib/src/ssa/graph_builder.dart
index 8948546..a426b34 100644
--- a/pkg/compiler/lib/src/ssa/graph_builder.dart
+++ b/pkg/compiler/lib/src/ssa/graph_builder.dart
@@ -35,12 +35,17 @@
/// A reference to the compiler.
Compiler compiler;
- /// The JavaScript backend we are targeting in this compilation.
- JavaScriptBackend get backend;
+ /// True if the builder is processing nodes inside a try statement. This is
+ /// important for generating control flow out of a try block like returns or
+ /// breaks.
+ bool inTryStatement = false;
/// The tree elements for the element being built into an SSA graph.
TreeElements get elements;
+ /// The JavaScript backend we are targeting in this compilation.
+ JavaScriptBackend get backend;
+
CodegenRegistry get registry;
ClosedWorld get closedWorld;
@@ -180,17 +185,6 @@
return result;
}
- void handleIf(
- {ast.Node node,
- void visitCondition(),
- void visitThen(),
- void visitElse(),
- SourceInformation sourceInformation}) {
- SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, compiler, node);
- branchBuilder.handleIf(visitCondition, visitThen, visitElse,
- sourceInformation: sourceInformation);
- }
-
HSubGraphBlockInformation wrapStatementGraph(SubGraph statements) {
if (statements == null) return null;
return new HSubGraphBlockInformation(statements);
@@ -237,6 +231,16 @@
return callSetRuntimeTypeInfo(typeInfo, newObject);
}
+ /// Called when control flow is about to change, in which case we need to
+ /// specify special successors if we are already in a try/catch/finally block.
+ void handleInTryStatement() {
+ if (!inTryStatement) return;
+ HBasicBlock block = close(new HExitTry());
+ HBasicBlock newBlock = graph.addNewBlock();
+ block.addSuccessor(newBlock);
+ open(newBlock);
+ }
+
HInstruction callSetRuntimeTypeInfo(
HInstruction typeInfo, HInstruction newObject);
@@ -263,14 +267,6 @@
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/kernel_ast_adapter.dart b/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart
index 10b7855..f1396ca 100644
--- a/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart
+++ b/pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart
@@ -27,6 +27,7 @@
import '../universe/selector.dart';
import '../universe/side_effects.dart';
import '../world.dart';
+import 'jump_handler.dart' show SwitchCaseJumpHandler;
import 'locals_handler.dart';
import 'types.dart';
@@ -40,8 +41,12 @@
final Map<ir.Node, Element> _nodeToElement;
final Map<ir.VariableDeclaration, SyntheticLocal> _syntheticLocals =
<ir.VariableDeclaration, SyntheticLocal>{};
- final Map<ir.LabeledStatement, KernelJumpTarget> _jumpTargets =
- <ir.LabeledStatement, KernelJumpTarget>{};
+ // TODO(efortuna): In an ideal world the TreeNodes should be some common
+ // interface we create for both ir.Statements and ir.SwitchCase (the
+ // ContinueSwitchStatement's target is a SwitchCase) rather than general
+ // TreeNode. Talking to Asger about this.
+ final Map<ir.TreeNode, KernelJumpTarget> _jumpTargets =
+ <ir.TreeNode, KernelJumpTarget>{};
DartTypeConverter _typeConverter;
ResolvedAst _resolvedAst;
@@ -52,6 +57,7 @@
KernelAstAdapter(this.kernel, this._backend, this._resolvedAst,
this._nodeToAst, this._nodeToElement) {
+ KernelJumpTarget.index = 0;
// TODO(het): Maybe just use all of the kernel maps directly?
for (FieldElement fieldElement in kernel.fields.keys) {
_nodeToElement[kernel.fields[fieldElement]] = fieldElement;
@@ -366,14 +372,13 @@
LibraryElement get jsHelperLibrary => _backend.helpers.jsHelperLibrary;
- JumpTarget getTargetDefinition(ir.Node node) =>
- elements.getTargetDefinition(getNode(node));
-
- JumpTarget getTargetOf(ir.Node node) => elements.getTargetOf(getNode(node));
-
- KernelJumpTarget getJumpTarget(ir.LabeledStatement labeledStatement) =>
- _jumpTargets.putIfAbsent(labeledStatement, () {
- return new KernelJumpTarget();
+ KernelJumpTarget getJumpTarget(ir.TreeNode node) =>
+ _jumpTargets.putIfAbsent(node, () {
+ if (node is ir.LabeledStatement &&
+ _jumpTargets.containsKey((node as ir.LabeledStatement).body)) {
+ return _jumpTargets[(node as ir.LabeledStatement).body];
+ }
+ return new KernelJumpTarget(node);
});
LabelDefinition getTargetLabel(ir.Node node) =>
@@ -405,6 +410,19 @@
TypeMaskFactory.inferredReturnTypeForElement(
_backend.helpers.traceFromException, _globalInferenceResults);
+ ir.Procedure get streamIteratorConstructor =>
+ kernel.functions[_backend.helpers.streamIteratorConstructor];
+
+ TypeMask get streamIteratorConstructorType =>
+ TypeMaskFactory.inferredReturnTypeForElement(
+ _backend.helpers.streamIteratorConstructor, _globalInferenceResults);
+ ir.Procedure get fallThroughError =>
+ kernel.functions[_backend.helpers.fallThroughError];
+
+ TypeMask get fallThroughErrorType =>
+ TypeMaskFactory.inferredReturnTypeForElement(
+ _backend.helpers.fallThroughError, _globalInferenceResults);
+
ir.Procedure get mapLiteralUntypedMaker =>
kernel.functions[_backend.helpers.mapLiteralUntypedMaker];
@@ -467,6 +485,12 @@
ir.Class get objectClass =>
kernel.classes[_compiler.commonElements.objectClass];
+ ir.Class get futureClass =>
+ kernel.classes[_compiler.commonElements.futureClass];
+
+ TypeMask makeSubtypeOfObject(ClosedWorld closedWorld) =>
+ new TypeMask.subclass(_compiler.commonElements.objectClass, closedWorld);
+
ir.Procedure get currentIsolate =>
kernel.functions[_backend.helpers.currentIsolate];
@@ -948,24 +972,35 @@
class KernelJumpTarget extends JumpTarget {
static int index = 0;
- KernelJumpTarget() {
- labels = <LabelDefinition>[
- new LabelDefinitionX(null, 'l${index++}', this)..setBreakTarget()
- ];
- }
+ /// Pointer to the actual executable statements that a jump target refers to.
+ /// If this jump target was not initially constructed with a LabeledStatement,
+ /// this value is identical to originalStatement.
+ // TODO(efortuna): In an ideal world the Node should be some common
+ // interface we create for both ir.Statements and ir.SwitchCase (the
+ // ContinueSwitchStatement's target is a SwitchCase) rather than general
+ // Node. Talking to Asger about this.
+ ir.Node targetStatement;
+
+ /// The original statement used to construct this jump target.
+ /// If this jump target was not initially constructed with a LabeledStatement,
+ /// this value is identical to targetStatement.
+ ir.Node originalStatement;
@override
- bool get isBreakTarget => true;
-
- set isBreakTarget(bool x) {
- // do nothing, these are always break targets
- }
+ bool isBreakTarget = false;
@override
- bool get isContinueTarget => false;
+ bool isContinueTarget = false;
- set isContinueTarget(bool x) {
- // do nothing, these are always break targets
+ KernelJumpTarget(this.targetStatement) {
+ labels = <LabelDefinition>[];
+ originalStatement = targetStatement;
+ if (targetStatement is ir.LabeledStatement) {
+ targetStatement = (targetStatement as ir.LabeledStatement).body;
+ labels.add(
+ new LabelDefinitionX(null, 'L${index++}', this)..setBreakTarget());
+ isBreakTarget = true;
+ }
}
@override
@@ -979,10 +1014,10 @@
ExecutableElement get executableContext => null;
@override
- bool get isSwitch => false;
+ bool get isSwitch => targetStatement is ir.SwitchStatement;
@override
- bool get isTarget => true;
+ bool get isTarget => isBreakTarget || isContinueTarget;
@override
List<LabelDefinition> labels;
@@ -995,4 +1030,6 @@
@override
ast.Node get statement => null;
+
+ String toString() => 'Target:$targetStatement';
}
diff --git a/pkg/compiler/lib/src/ssa/loop_handler.dart b/pkg/compiler/lib/src/ssa/loop_handler.dart
index 6a22a8d..3b59a5f 100644
--- a/pkg/compiler/lib/src/ssa/loop_handler.dart
+++ b/pkg/compiler/lib/src/ssa/loop_handler.dart
@@ -360,28 +360,15 @@
super(builder);
@override
- JumpHandler createJumpHandler(ir.TreeNode node, {bool isLoopJump}) {
- if (node.parent is! ir.LabeledStatement) {
- // No breaks or continues to this node.
- return new NullJumpHandler(builder.compiler.reporter);
- }
- // We must have already created a JumpHandler for the labeled statement
- JumpHandler result =
- builder.jumpTargets[astAdapter.getJumpTarget(node.parent)];
- assert(result != null);
- return result;
- }
+ JumpHandler createJumpHandler(ir.TreeNode node, {bool isLoopJump}) =>
+ builder.createJumpHandler(node, isLoopJump: isLoopJump);
@override
ast.Node getNode(ir.TreeNode node) => astAdapter.getNode(node);
@override
- JumpTarget getTargetDefinition(ir.TreeNode node) {
- if (node.parent is ir.LabeledStatement) {
- return astAdapter.getJumpTarget(node.parent);
- }
- return null;
- }
+ JumpTarget getTargetDefinition(ir.TreeNode node) =>
+ astAdapter.getJumpTarget(node.parent);
@override
int loopKind(ir.TreeNode node) => node.accept(new _KernelLoopTypeVisitor());
diff --git a/pkg/compiler/lib/src/ssa/switch_continue_analysis.dart b/pkg/compiler/lib/src/ssa/switch_continue_analysis.dart
new file mode 100644
index 0000000..fd67da6
--- /dev/null
+++ b/pkg/compiler/lib/src/ssa/switch_continue_analysis.dart
@@ -0,0 +1,113 @@
+import 'package:kernel/ast.dart' as ir;
+
+/// Helper class that traverses a kernel AST subtree to see if it has any
+/// continue statements in the body of any switch cases (having continue
+/// statements results in a more complex generated code).
+class SwitchContinueAnalysis extends ir.Visitor<bool> {
+
+ SwitchContinueAnalysis._();
+
+ static bool containsContinue(ir.Statement switchCaseBody) {
+ return switchCaseBody.accept(new SwitchContinueAnalysis._());
+ }
+
+ bool visitContinueSwitchStatement(ir.ContinueSwitchStatement continueStmt) {
+ // TODO(efortuna): Check what the target of this continue statement actually
+ // IS, because depending on where the label points if we have a nested
+ // switch statement we might be able to output simpler code (not the complex
+ // switch statement).
+ return true;
+ }
+
+ bool visitBlock(ir.Block block) {
+ for (ir.Statement statement in block.statements) {
+ if (statement.accept(this)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool visitLabeledStatement(ir.LabeledStatement statement) {
+ return statement.body.accept(this);
+ }
+
+ bool visitDoStatement(ir.DoStatement doStatement) {
+ return doStatement.body.accept(this);
+ }
+
+ bool visitForStatement(ir.ForStatement forStatement) {
+ return forStatement.body.accept(this);
+ }
+
+ bool visitForInStatement(ir.ForInStatement forInStatement) {
+ return forInStatement.body.accept(this);
+ }
+
+ bool visitSwitchStatement(ir.SwitchStatement switchStatement) {
+ for (var switchCase in switchStatement.cases) {
+ if (switchCase.accept(this)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool visitSwitchCase(ir.SwitchCase switchCase) {
+ return switchCase.body.accept(this);
+ }
+
+ bool visitIfStatement(ir.IfStatement ifStatement) {
+ if (ifStatement.then.accept(this)) {
+ if (ifStatement.otherwise != null) {
+ return ifStatement.otherwise.accept(this);
+ }
+ }
+ return false;
+ }
+
+ bool visitTryCatch(ir.TryCatch tryCatch) {
+ if (tryCatch.body.accept(this)) {
+ for (var catchStatement in tryCatch.catches) {
+ if (catchStatement.accept(this)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ bool visitWhileStatement(ir.WhileStatement statement) {
+ return statement.body.accept(this);
+ }
+
+ bool visitCatch(ir.Catch catchStatement) {
+ return catchStatement.body.accept(this);
+ }
+
+ bool visitTryFinally(ir.TryFinally tryFinally) {
+ return tryFinally.body.accept(this) &&
+ tryFinally.finalizer.accept(this);
+ }
+
+ bool visitFunctionDeclaration(ir.FunctionDeclaration declaration) {
+ return declaration.function.accept(this);
+ }
+
+ bool visitFunctionNode(ir.FunctionNode node) {
+ return node.body.accept(this);
+ }
+
+ bool defaultStatement(ir.Statement node) {
+ if (node is ir.ExpressionStatement || node is ir.EmptyStatement ||
+ node is ir.InvalidStatement || node is ir.BreakStatement ||
+ node is ir.ReturnStatement || node is ir.AssertStatement ||
+ node is ir.YieldStatement || node is ir.VariableDeclaration) {
+ return false;
+ }
+ throw 'Statement type ${node.runtimeType} not handled in '
+ 'SwitchContinueAnalysis';
+ }
+
+ bool defaultNode(ir.Node node) => false;
+}
diff --git a/pkg/compiler/lib/src/tokens/token.dart b/pkg/compiler/lib/src/tokens/token.dart
index 79bf27c..af31142 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 precedence info.
+ * A [SymbolToken] represents the symbol in its precendence 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 3ef0fb3..1e5f9dd 100644
--- a/pkg/compiler/lib/src/tree/nodes.dart
+++ b/pkg/compiler/lib/src/tree/nodes.dart
@@ -48,10 +48,6 @@
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);
@@ -83,10 +79,6 @@
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);
@@ -184,10 +176,6 @@
return visitExpression(node, arg);
}
- R visitFunctionTypeAnnotation(FunctionTypeAnnotation node, A arg) {
- return visitTypeAnnotation(node, arg);
- }
-
R visitGotoStatement(GotoStatement node, A arg) {
return visitStatement(node, arg);
}
@@ -237,10 +225,6 @@
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);
@@ -276,8 +260,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 visitTypedef(Typedef node, A arg) => visitNode(node, arg);
R visitTypeAnnotation(TypeAnnotation node, A arg) => visitNode(node, arg);
+ R visitTypedef(Typedef 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);
@@ -376,7 +360,6 @@
ForIn asForIn() => null;
FunctionDeclaration asFunctionDeclaration() => null;
FunctionExpression asFunctionExpression() => null;
- FunctionTypeAnnotation asFunctionTypeAnnotation() => null;
Identifier asIdentifier() => null;
If asIf() => null;
Import asImport() => null;
@@ -400,7 +383,6 @@
NamedMixinApplication asNamedMixinApplication() => null;
NewExpression asNewExpression() => null;
NodeList asNodeList() => null;
- NominalTypeAnnotation asNominalTypeAnnotation() => null;
Operator asOperator() => null;
ParenthesizedExpression asParenthesizedExpression() => null;
Part asPart() => null;
@@ -419,6 +401,7 @@
SwitchStatement asSwitchStatement() => null;
Throw asThrow() => null;
TryStatement asTryStatement() => null;
+ TypeAnnotation asTypeAnnotation() => null;
TypeVariable asTypeVariable() => null;
Typedef asTypedef() => null;
VariableDefinitions asVariableDefinitions() => null;
@@ -503,7 +486,7 @@
}
class MixinApplication extends Node {
- final NominalTypeAnnotation superclass;
+ final TypeAnnotation superclass;
final NodeList mixins;
MixinApplication(this.superclass, this.mixins);
@@ -528,6 +511,8 @@
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;
@@ -542,7 +527,7 @@
NamedMixinApplication(this.name, this.typeParameters, this.modifiers,
this.mixinApplication, this.interfaces, this.classKeyword, this.endToken);
- NominalTypeAnnotation get superclass => mixinApplication.superclass;
+ TypeAnnotation get superclass => mixinApplication.superclass;
NodeList get mixins => mixinApplication.mixins;
MixinApplication asMixinApplication() => this;
@@ -1735,22 +1720,17 @@
Token getEndToken() => endToken;
}
-abstract class TypeAnnotation extends Node {
-}
-
-class NominalTypeAnnotation extends TypeAnnotation {
+class TypeAnnotation extends Node {
final Expression typeName;
final NodeList typeArguments;
- NominalTypeAnnotation(this.typeName, this.typeArguments);
+ TypeAnnotation(Expression this.typeName, NodeList this.typeArguments);
- NominalTypeAnnotation asNominalTypeAnnotation() => this;
+ TypeAnnotation asTypeAnnotation() => this;
- accept(Visitor visitor) => visitor.visitNominalTypeAnnotation(this);
+ accept(Visitor visitor) => visitor.visitTypeAnnotation(this);
- accept1(Visitor1 visitor, arg) {
- return visitor.visitNominalTypeAnnotation(this, arg);
- }
+ accept1(Visitor1 visitor, arg) => visitor.visitTypeAnnotation(this, arg);
visitChildren(Visitor visitor) {
typeName.accept(visitor);
@@ -1846,13 +1826,7 @@
return token;
}
- Token getEndToken() {
- var result = definitions.getEndToken();
- if (result != null) return result;
- assert(definitions.nodes.length == 1);
- assert(definitions.nodes.last == null);
- return type.getEndToken();
- }
+ Token getEndToken() => definitions.getEndToken();
}
abstract class Loop extends Statement {
@@ -2880,30 +2854,16 @@
}
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.isGeneralizedTypeAlias, this.templateParameters, this.returnType,
- this.name, this.typeParameters, this.formals, this.typedefKeyword,
- this.endToken);
+ Typedef(this.returnType, this.name, this.typeParameters, this.formals,
+ this.typedefKeyword, this.endToken);
Typedef asTypedef() => this;
@@ -2912,7 +2872,6 @@
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);
@@ -2920,7 +2879,6 @@
}
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);
@@ -2932,43 +2890,6 @@
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;
@@ -3213,8 +3134,6 @@
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 1549d4d..837db37 100644
--- a/pkg/compiler/lib/src/tree/prettyprint.dart
+++ b/pkg/compiler/lib/src/tree/prettyprint.dart
@@ -153,14 +153,6 @@
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});
}
@@ -252,13 +244,6 @@
}
}
- visitNominalTypeAnnotation(NominalTypeAnnotation node) {
- openNode(node, "NominalTypeAnnotation");
- visitChildNode(node.typeName, "typeName");
- visitChildNode(node.typeArguments, "typeArguments");
- closeNode();
- }
-
visitOperator(Operator node) {
openAndCloseNode(node, "Operator", {"value": node.token});
}
@@ -360,6 +345,13 @@
visitNodeWithChildren(node, "TryStatement");
}
+ visitTypeAnnotation(TypeAnnotation node) {
+ openNode(node, "TypeAnnotation");
+ visitChildNode(node.typeName, "typeName");
+ visitChildNode(node.typeArguments, "typeArguments");
+ closeNode();
+ }
+
visitTypedef(Typedef node) {
visitNodeWithChildren(node, "Typedef");
}
@@ -480,10 +472,6 @@
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 f2cef05..5d1d154 100644
--- a/pkg/compiler/lib/src/tree/unparser.dart
+++ b/pkg/compiler/lib/src/tree/unparser.dart
@@ -548,18 +548,11 @@
visit(node.expression);
}
- visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+ visitTypeAnnotation(TypeAnnotation 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) {
@@ -778,8 +771,8 @@
write(' ');
}
visit(node.name);
- if (node.templateParameters != null) {
- visit(node.templateParameters);
+ if (node.typeParameters != null) {
+ visit(node.typeParameters);
}
visit(node.formals);
write(node.endToken.value);
@@ -911,8 +904,4 @@
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 cb6557c..14da1cd 100644
--- a/pkg/compiler/lib/src/typechecker.dart
+++ b/pkg/compiler/lib/src/typechecker.dart
@@ -809,13 +809,8 @@
if (memberName.isSimilarTo(member.name)) {
PrivateName privateName = member.name;
LibraryElement library = privateName.library;
- reportMessage(
- node,
- MessageKind.PRIVATE_ACCESS,
- {
- 'name': name,
- 'libraryName': library.libraryOrScriptName
- },
+ reportMessage(node, MessageKind.PRIVATE_ACCESS,
+ {'name': name, 'libraryName': library.libraryOrScriptName},
isHint: isHint);
foundPrivateMember = true;
}
diff --git a/pkg/compiler/lib/src/universe/call_structure.dart b/pkg/compiler/lib/src/universe/call_structure.dart
index b60d435..7386238 100644
--- a/pkg/compiler/lib/src/universe/call_structure.dart
+++ b/pkg/compiler/lib/src/universe/call_structure.dart
@@ -6,8 +6,7 @@
import '../common.dart';
import '../common/names.dart' show Names;
-import '../elements/elements.dart';
-import '../tree/tree.dart';
+import '../elements/types.dart' show FunctionType;
import '../util/util.dart';
import 'selector.dart' show Selector;
@@ -39,17 +38,6 @@
return new NamedCallStructure(argumentCount, namedArguments);
}
- /// Creates the [CallStructure] corresponding to calling [signature] as
- /// declared, that is, all named arguments are in the order of declaration.
- factory CallStructure.fromSignature(FunctionSignature signature) {
- List<String> namedParameters;
- if (signature.optionalParametersAreNamed) {
- namedParameters =
- signature.optionalParameters.map((e) => e.name).toList();
- }
- return new CallStructure(signature.parameterCount, namedParameters);
- }
-
/// `true` if this call has named arguments.
bool get isNamed => false;
@@ -87,161 +75,44 @@
return match(other);
}
- bool signatureApplies(FunctionSignature parameters) {
- if (argumentCount > parameters.parameterCount) return false;
- int requiredParameterCount = parameters.requiredParameterCount;
- int optionalParameterCount = parameters.optionalParameterCount;
+ bool signatureApplies(FunctionType type) {
+ int requiredParameterCount = type.parameterTypes.length;
+ int optionalParameterCount =
+ type.optionalParameterTypes.length + type.namedParameters.length;
+ int parameterCount = requiredParameterCount + optionalParameterCount;
+ if (argumentCount > parameterCount) return false;
if (positionalArgumentCount < requiredParameterCount) return false;
- if (!parameters.optionalParametersAreNamed) {
+ if (type.namedParameters.isEmpty) {
// We have already checked that the number of arguments are
// not greater than the number of parameters. Therefore the
// number of positional arguments are not greater than the
// number of parameters.
- assert(positionalArgumentCount <= parameters.parameterCount);
+ assert(positionalArgumentCount <= parameterCount);
return namedArguments.isEmpty;
} else {
if (positionalArgumentCount > requiredParameterCount) return false;
assert(positionalArgumentCount == requiredParameterCount);
if (namedArgumentCount > optionalParameterCount) return false;
- Set<String> nameSet = new Set<String>();
- parameters.optionalParameters.forEach((Element element) {
- nameSet.add(element.name);
- });
- for (String name in namedArguments) {
- if (!nameSet.contains(name)) return false;
- // TODO(5213): By removing from the set we are checking
- // that we are not passing the name twice. We should have this
- // check in the resolver also.
- nameSet.remove(name);
+
+ int nameIndex = 0;
+ List<String> namedParameters = type.namedParameters;
+ for (String name in getOrderedNamedArguments()) {
+ bool found = false;
+ // Note: we start at the existing index because arguments are sorted.
+ while (nameIndex < namedParameters.length) {
+ if (name == namedParameters[nameIndex]) {
+ found = true;
+ break;
+ }
+ nameIndex++;
+ }
+ if (!found) return false;
}
return true;
}
}
- /**
- * Returns a `List` with the evaluated arguments in the normalized order.
- *
- * [compileDefaultValue] is a function that returns a compiled constant
- * of an optional argument that is not in [compiledArguments].
- *
- * Precondition: `this.applies(element, world)`.
- *
- * Invariant: [element] must be the implementation element.
- */
- /*<T>*/ List/*<T>*/ makeArgumentsList(
- Link<Node> arguments,
- FunctionElement element,
- /*T*/ compileArgument(Node argument),
- /*T*/ compileDefaultValue(ParameterElement element)) {
- assert(invariant(element, element.isImplementation));
- List/*<T>*/ result = new List();
-
- FunctionSignature parameters = element.functionSignature;
- parameters.forEachRequiredParameter((ParameterElement element) {
- result.add(compileArgument(arguments.head));
- arguments = arguments.tail;
- });
-
- if (!parameters.optionalParametersAreNamed) {
- parameters.forEachOptionalParameter((ParameterElement element) {
- if (!arguments.isEmpty) {
- result.add(compileArgument(arguments.head));
- arguments = arguments.tail;
- } else {
- result.add(compileDefaultValue(element));
- }
- });
- } else {
- // Visit named arguments and add them into a temporary list.
- List compiledNamedArguments = [];
- for (; !arguments.isEmpty; arguments = arguments.tail) {
- NamedArgument namedArgument = arguments.head;
- compiledNamedArguments.add(compileArgument(namedArgument.expression));
- }
- // Iterate over the optional parameters of the signature, and try to
- // find them in [compiledNamedArguments]. If found, we use the
- // value in the temporary list, otherwise the default value.
- parameters.orderedOptionalParameters.forEach((ParameterElement element) {
- int foundIndex = namedArguments.indexOf(element.name);
- if (foundIndex != -1) {
- result.add(compiledNamedArguments[foundIndex]);
- } else {
- result.add(compileDefaultValue(element));
- }
- });
- }
- return result;
- }
-
- /**
- * Fills [list] with the arguments in the order expected by
- * [callee], and where [caller] is a synthesized element
- *
- * [compileArgument] is a function that returns a compiled version
- * of a parameter of [callee].
- *
- * [compileConstant] is a function that returns a compiled constant
- * of an optional argument that is not in the parameters of [callee].
- *
- * Returns [:true:] if the signature of the [caller] matches the
- * signature of the [callee], [:false:] otherwise.
- */
- static/*<T>*/ bool addForwardingElementArgumentsToList(
- ConstructorElement caller,
- List/*<T>*/ list,
- ConstructorElement callee,
- /*T*/ compileArgument(ParameterElement element),
- /*T*/ compileConstant(ParameterElement element)) {
- assert(invariant(caller, !callee.isMalformed,
- message: "Cannot compute arguments to malformed constructor: "
- "$caller calling $callee."));
-
- FunctionSignature signature = caller.functionSignature;
- Map<Node, ParameterElement> mapping = <Node, ParameterElement>{};
-
- // TODO(ngeoffray): This is a hack that fakes up AST nodes, so
- // that we can call [addArgumentsToList].
- Link<Node> computeCallNodesFromParameters() {
- LinkBuilder<Node> builder = new LinkBuilder<Node>();
- signature.forEachRequiredParameter((ParameterElement element) {
- Node node = element.node;
- mapping[node] = element;
- builder.addLast(node);
- });
- if (signature.optionalParametersAreNamed) {
- signature.forEachOptionalParameter((ParameterElement element) {
- mapping[element.initializer] = element;
- builder.addLast(new NamedArgument(null, null, element.initializer));
- });
- } else {
- signature.forEachOptionalParameter((ParameterElement element) {
- Node node = element.node;
- mapping[node] = element;
- builder.addLast(node);
- });
- }
- return builder.toLink();
- }
-
- /*T*/ internalCompileArgument(Node node) {
- return compileArgument(mapping[node]);
- }
-
- Link<Node> nodes = computeCallNodesFromParameters();
-
- // Synthesize a structure for the call.
- // TODO(ngeoffray): Should the resolver do it instead?
- CallStructure callStructure = new CallStructure.fromSignature(signature);
- if (!callStructure.signatureApplies(signature)) {
- return false;
- }
- list.addAll(callStructure.makeArgumentsList(
- nodes, callee, internalCompileArgument, compileConstant));
-
- return true;
- }
-
static bool sameNames(List<String> first, List<String> second) {
for (int i = 0; i < first.length; i++) {
if (first[i] != second[i]) return false;
diff --git a/pkg/compiler/lib/src/universe/selector.dart b/pkg/compiler/lib/src/universe/selector.dart
index 647c3fb..be129c1 100644
--- a/pkg/compiler/lib/src/universe/selector.dart
+++ b/pkg/compiler/lib/src/universe/selector.dart
@@ -14,10 +14,9 @@
MemberElement,
MethodElement,
Name,
- LibraryElement,
PublicName;
+import '../elements/entities.dart';
import '../util/util.dart' show Hashing;
-import '../common/resolution.dart' show Target;
import 'call_structure.dart' show CallStructure;
class SelectorKind {
@@ -58,7 +57,7 @@
String get name => memberName.text;
- LibraryElement get library => memberName.library;
+ LibraryEntity get library => memberName.library;
Selector.internal(
this.kind, this.memberName, this.callStructure, this.hashCode) {
@@ -245,7 +244,7 @@
bool signatureApplies(MethodElement function) {
if (Elements.isUnresolved(function)) return false;
- return callStructure.signatureApplies(function.functionSignature);
+ return callStructure.signatureApplies(function.type);
}
bool applies(MemberElement element) {
diff --git a/pkg/compiler/lib/src/use_unused_api.dart b/pkg/compiler/lib/src/use_unused_api.dart
index ddd2685..de79fb6 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()
- ..asNominalTypeAnnotation()
+ ..asTypeAnnotation()
..asTypeVariable()
..asTypedef()
..asWhile()
diff --git a/pkg/dev_compiler/lib/js/amd/dart_sdk.js b/pkg/dev_compiler/lib/js/amd/dart_sdk.js
index ebd0c84..5f518fc 100644
--- a/pkg/dev_compiler/lib/js/amd/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/amd/dart_sdk.js
@@ -1780,7 +1780,7 @@
if (actuals.length < type.args.length) return false;
let index = 0;
for (let i = 0; i < type.args.length; ++i) {
- if (!dart.instanceOfOrNull(actuals[i], type.args[i])) return false;
+ dart.check(actuals[i], type.args[i]);
++index;
}
if (actuals.length == type.args.length) return true;
@@ -1788,7 +1788,7 @@
if (type.optionals.length > 0) {
if (extras > type.optionals.length) return false;
for (let i = 0, j = index; i < extras; ++i, ++j) {
- if (!dart.instanceOfOrNull(actuals[j], type.optionals[i])) return false;
+ dart.check(actuals[j], type.optionals[i]);
}
return true;
}
@@ -1801,7 +1801,7 @@
if (!dart.hasOwnProperty.call(type.named, name)) {
return false;
}
- if (!dart.instanceOfOrNull(opts[name], type.named[name])) return false;
+ dart.check(opts[name], type.named[name]);
}
return true;
};
diff --git a/pkg/dev_compiler/lib/js/common/dart_sdk.js b/pkg/dev_compiler/lib/js/common/dart_sdk.js
index 822f847..5364eaf 100644
--- a/pkg/dev_compiler/lib/js/common/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/common/dart_sdk.js
@@ -1780,7 +1780,7 @@
if (actuals.length < type.args.length) return false;
let index = 0;
for (let i = 0; i < type.args.length; ++i) {
- if (!dart.instanceOfOrNull(actuals[i], type.args[i])) return false;
+ dart.check(actuals[i], type.args[i]);
++index;
}
if (actuals.length == type.args.length) return true;
@@ -1788,7 +1788,7 @@
if (type.optionals.length > 0) {
if (extras > type.optionals.length) return false;
for (let i = 0, j = index; i < extras; ++i, ++j) {
- if (!dart.instanceOfOrNull(actuals[j], type.optionals[i])) return false;
+ dart.check(actuals[j], type.optionals[i]);
}
return true;
}
@@ -1801,7 +1801,7 @@
if (!dart.hasOwnProperty.call(type.named, name)) {
return false;
}
- if (!dart.instanceOfOrNull(opts[name], type.named[name])) return false;
+ dart.check(opts[name], type.named[name]);
}
return true;
};
diff --git a/pkg/dev_compiler/lib/js/es6/dart_sdk.js b/pkg/dev_compiler/lib/js/es6/dart_sdk.js
index 30fa1b5..12f64f0 100644
--- a/pkg/dev_compiler/lib/js/es6/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/es6/dart_sdk.js
@@ -1778,7 +1778,7 @@
if (actuals.length < type.args.length) return false;
let index = 0;
for (let i = 0; i < type.args.length; ++i) {
- if (!dart.instanceOfOrNull(actuals[i], type.args[i])) return false;
+ dart.check(actuals[i], type.args[i]);
++index;
}
if (actuals.length == type.args.length) return true;
@@ -1786,7 +1786,7 @@
if (type.optionals.length > 0) {
if (extras > type.optionals.length) return false;
for (let i = 0, j = index; i < extras; ++i, ++j) {
- if (!dart.instanceOfOrNull(actuals[j], type.optionals[i])) return false;
+ dart.check(actuals[j], type.optionals[i]);
}
return true;
}
@@ -1799,7 +1799,7 @@
if (!dart.hasOwnProperty.call(type.named, name)) {
return false;
}
- if (!dart.instanceOfOrNull(opts[name], type.named[name])) return false;
+ dart.check(opts[name], type.named[name]);
}
return true;
};
diff --git a/pkg/dev_compiler/lib/js/legacy/dart_sdk.js b/pkg/dev_compiler/lib/js/legacy/dart_sdk.js
index 751f1e8..029beee 100644
--- a/pkg/dev_compiler/lib/js/legacy/dart_sdk.js
+++ b/pkg/dev_compiler/lib/js/legacy/dart_sdk.js
@@ -1781,7 +1781,7 @@
if (actuals.length < type.args.length) return false;
let index = 0;
for (let i = 0; i < type.args.length; ++i) {
- if (!dart.instanceOfOrNull(actuals[i], type.args[i])) return false;
+ dart.check(actuals[i], type.args[i]);
++index;
}
if (actuals.length == type.args.length) return true;
@@ -1789,7 +1789,7 @@
if (type.optionals.length > 0) {
if (extras > type.optionals.length) return false;
for (let i = 0, j = index; i < extras; ++i, ++j) {
- if (!dart.instanceOfOrNull(actuals[j], type.optionals[i])) return false;
+ dart.check(actuals[j], type.optionals[i]);
}
return true;
}
@@ -1802,7 +1802,7 @@
if (!dart.hasOwnProperty.call(type.named, name)) {
return false;
}
- if (!dart.instanceOfOrNull(opts[name], type.named[name])) return false;
+ dart.check(opts[name], type.named[name]);
}
return true;
};
diff --git a/pkg/dev_compiler/lib/sdk/ddc_sdk.sum b/pkg/dev_compiler/lib/sdk/ddc_sdk.sum
index 670fd6f..9faed73 100644
--- a/pkg/dev_compiler/lib/sdk/ddc_sdk.sum
+++ b/pkg/dev_compiler/lib/sdk/ddc_sdk.sum
Binary files differ
diff --git a/pkg/dev_compiler/lib/src/compiler/code_generator.dart b/pkg/dev_compiler/lib/src/compiler/code_generator.dart
index afabcf3..0606bbf 100644
--- a/pkg/dev_compiler/lib/src/compiler/code_generator.dart
+++ b/pkg/dev_compiler/lib/src/compiler/code_generator.dart
@@ -188,7 +188,7 @@
_buildUnit = unit;
_libraryRoot = _buildUnit.libraryRoot;
if (!_libraryRoot.endsWith(separator)) {
- _libraryRoot = '$_libraryRoot${separator}';
+ _libraryRoot += separator;
}
var module = _emitModule(compilationUnits);
@@ -1806,7 +1806,6 @@
Function lookup;
List<JS.Property> tMember;
- JS.Expression type;
if (node.isGetter) {
lookup = classElem.lookUpInheritedConcreteGetter;
tMember = node.isStatic ? tStaticGetters : tInstanceGetters;
@@ -1819,22 +1818,38 @@
tMember = node.isStatic ? tStaticMethods : tInstanceMethods;
}
- type = _emitAnnotatedFunctionType(element.type, node.metadata,
+ // Swap in "Object" for parameter types that are covariant overrides.
+ var objectType = context.typeProvider.objectType;
+ var reifiedType = element is MethodElement
+ ? element.getReifiedType(objectType)
+ : element.type;
+ var type = _emitAnnotatedFunctionType(reifiedType, node.metadata,
parameters: node.parameters?.parameters,
nameType: options.hoistSignatureTypes,
hoistType: options.hoistSignatureTypes,
definite: true);
+ // Don't add redundant signatures for inherited methods whose signature
+ // did not change.
+ var needsSignature = true;
var inheritedElement = lookup(name, currentLibrary);
- if (inheritedElement != null && inheritedElement.type == element.type) {
- continue;
+ if (inheritedElement != null) {
+ if (inheritedElement is MethodElement) {
+ needsSignature =
+ inheritedElement.getReifiedType(objectType) != reifiedType;
+ } else {
+ needsSignature = inheritedElement.type != reifiedType;
+ }
}
- var memberName = _declareMemberName(element);
- var property = new JS.Property(memberName, type);
- tMember.add(property);
- // TODO(vsm): Why do we need this?
- if (node.isStatic && !node.isGetter && !node.isSetter) {
- sNames.add(memberName);
+
+ if (needsSignature) {
+ var memberName = _declareMemberName(element);
+ var property = new JS.Property(memberName, type);
+ tMember.add(property);
+ // TODO(vsm): Why do we need this?
+ if (node.isStatic && !node.isGetter && !node.isSetter) {
+ sNames.add(memberName);
+ }
}
}
@@ -2908,7 +2923,7 @@
lowerTypedef: lowerTypedef,
nameType: nameType,
hoistType: hoistType);
- var helper = (definite) ? 'definiteFunctionType' : 'functionType';
+ var helper = definite ? 'definiteFunctionType' : 'functionType';
var fullType = _callHelper('${helper}(#)', [parts]);
if (!nameType) return fullType;
return _typeTable.nameType(type, fullType,
@@ -2943,6 +2958,7 @@
var namedTypes = type.namedParameterTypes;
var rt =
_emitType(type.returnType, nameType: nameType, hoistType: hoistType);
+
var ra = _emitTypeNames(parameterTypes, parameters,
nameType: nameType, hoistType: hoistType);
@@ -5624,7 +5640,9 @@
///
/// JSNumber is the type that actually "implements" all numbers, hence it's
/// a subtype of int and double (and num). It's in our "dart:_interceptors".
- bool _isNumberInJS(DartType t) => rules.isSubtypeOf(t, types.numType);
+ bool _isNumberInJS(DartType t) =>
+ rules.isSubtypeOf(t, types.numType) &&
+ !rules.isSubtypeOf(t, types.nullType);
/// Return true if this is one of the methods/properties on all Dart Objects
/// (toString, hashCode, noSuchMethod, runtimeType).
diff --git a/pkg/dev_compiler/test/browser/language_tests.js b/pkg/dev_compiler/test/browser/language_tests.js
index 694ee01..d7222dc 100644
--- a/pkg/dev_compiler/test/browser/language_tests.js
+++ b/pkg/dev_compiler/test/browser/language_tests.js
@@ -32,6 +32,10 @@
const firefox_fail = is.firefox() ? fail : pass;
const chrome_fail = is.chrome() ? fail : pass;
+ // These are typically tests with asynchronous exceptions that our
+ // test framework doesn't always catch.
+ const flaky = 'skip';
+
// Tests marked with this are still using the deprecated unittest package
// because they rely on its support for futures and asynchronous tests, which
// expect and minitest do not handle.
@@ -101,6 +105,7 @@
'const_switch_test_02_multi': fail,
'const_switch_test_04_multi': fail,
'constructor12_test': fail,
+ 'covariant_subtyping_unsafe_call2_test': fail,
'cyclic_type2_test': fail,
'cyclic_type_test_00_multi': fail,
'cyclic_type_test_01_multi': fail,
@@ -126,7 +131,6 @@
'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': fail,
'final_syntax_test_08_multi': fail,
@@ -200,6 +204,7 @@
'many_generic_instanceof_test': fail,
'map_literal10_test': fail,
'map_literal7_test': fail,
+ 'memory_swap_test': is.firefox() ? skip_timeout : pass,
'method_invocation_test': fail,
'mint_arithmetic_test': fail,
'mixin_forwarding_constructor3_test': fail,
@@ -227,7 +232,7 @@
'regress_16640_test': fail,
'regress_18535_test': fail,
'regress_22666_test': fail,
- 'regress_22777_test': fail,
+ 'regress_22777_test': flaky,
'setter_no_getter_test_01_multi': fail,
'stack_overflow_stacktrace_test': fail,
'stack_overflow_test': fail,
@@ -270,6 +275,8 @@
},
+ 'language/covariant_override': {},
+
'corelib': {
'apply2_test': fail,
'apply3_test': fail,
@@ -291,7 +298,6 @@
'hash_map2_test': skip_timeout,
'hash_set_test_01_multi': fail,
'hidden_library2_test_01_multi': fail,
- 'indexed_list_access_test': fail,
'int_modulo_arith_test_bignum_multi': fail,
'int_modulo_arith_test_modPow_multi': fail,
'int_modulo_arith_test_none_multi': fail,
@@ -792,7 +798,7 @@
async_helper.asyncTestInitialize(finish);
if (has('slow')) this.timeout(10000);
-
+
var result;
try {
var result = mainLibrary.main();
diff --git a/pkg/dev_compiler/test/codegen_test.dart b/pkg/dev_compiler/test/codegen_test.dart
index 7ac885d..5e5e98b 100644
--- a/pkg/dev_compiler/test/codegen_test.dart
+++ b/pkg/dev_compiler/test/codegen_test.dart
@@ -89,9 +89,6 @@
path.join('lib', 'collection'),
path.join('lib', 'convert'),
path.join('lib', 'html'),
- // TODO(vsm): Fix these - they import files from a different directory
- // - this triggers an invalid library root build error.
- // path.join('lib', 'html', 'custom'),
path.join('lib', 'math'),
path.join('lib', 'mirrors'),
path.join('lib', 'typed_data'),
@@ -263,7 +260,7 @@
path.join(dirParts[0] + "_strong", path.joinAll(dirParts.skip(1)));
var inputPath = path.join(testDirectory, '../../../tests/', sdkTestDir);
- for (var file in _listFiles(inputPath, recursive: false)) {
+ for (var file in _listFiles(inputPath, recursive: true)) {
var relativePath = path.relative(file, from: inputPath);
var outputPath = path.join(codegenTestDir, testDir, relativePath);
@@ -391,5 +388,13 @@
'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'
+ 'language/mixin_illegal_syntax_test_14_multi',
+
+ // TODO(vsm): Fix these - they import files from a different directory
+ // - this triggers an invalid library root build error.
+ 'lib/html/custom/attribute_changed_callback_test',
+ 'lib/html/custom/entered_left_view_test',
+ 'lib/html/custom/js_custom_test',
+ 'lib/html/custom/mirrors_test',
+ 'lib/html/custom/regress_194523002_test',
]);
diff --git a/pkg/dev_compiler/test/not_yet_strong_tests.dart b/pkg/dev_compiler/test/not_yet_strong_tests.dart
index 2544ae8..7cf87cc 100644
--- a/pkg/dev_compiler/test/not_yet_strong_tests.dart
+++ b/pkg/dev_compiler/test/not_yet_strong_tests.dart
@@ -517,7 +517,6 @@
'language/cyclic_class_member_test_01_multi',
'language/cyclic_constructor_test_01_multi',
'language/cyclic_default_values_test',
- 'language/cyclic_import_test',
'language/cyclic_type_variable_test_01_multi',
'language/cyclic_type_variable_test_02_multi',
'language/cyclic_type_variable_test_03_multi',
@@ -2396,6 +2395,11 @@
'lib/convert/chunked_conversion_utf8_test',
'lib/convert/line_splitter_test',
'lib/html/cross_frame_test',
+ 'lib/html/custom/constructor_calls_created_synchronously_test',
+ 'lib/html/custom/created_callback_test',
+ 'lib/html/custom/document_register_basic_test',
+ 'lib/html/custom/document_register_type_extensions_test',
+ 'lib/html/custom/element_upgrade_test',
'lib/html/element_test',
'lib/html/events_test',
'lib/html/fileapi_test',
diff --git a/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart b/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart
index 629ae6b..d936333 100644
--- a/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart
+++ b/pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.dart
@@ -58,7 +58,7 @@
if ($actuals.length < $type.args.length) return false;
let index = 0;
for(let i = 0; i < $type.args.length; ++i) {
- if (!$instanceOfOrNull($actuals[i], $type.args[i])) return false;
+ $check($actuals[i], $type.args[i]);
++index;
}
if ($actuals.length == $type.args.length) return true;
@@ -66,7 +66,7 @@
if ($type.optionals.length > 0) {
if (extras > $type.optionals.length) return false;
for(let i = 0, j=index; i < extras; ++i, ++j) {
- if (!$instanceOfOrNull($actuals[j], $type.optionals[i])) return false;
+ $check($actuals[j], $type.optionals[i]);
}
return true;
}
@@ -84,7 +84,7 @@
if (!($hasOwnProperty.call($type.named, name))) {
return false;
}
- if (!$instanceOfOrNull(opts[name], $type.named[name])) return false;
+ $check(opts[name], $type.named[name]);
}
return true;
})()''');
diff --git a/pkg/front_end/lib/incremental_kernel_generator.dart b/pkg/front_end/lib/incremental_kernel_generator.dart
new file mode 100644
index 0000000..5e80960
--- /dev/null
+++ b/pkg/front_end/lib/incremental_kernel_generator.dart
@@ -0,0 +1,92 @@
+// 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 'package:front_end/src/base/processed_options.dart';
+import 'package:front_end/src/incremental_kernel_generator_impl.dart';
+import 'package:kernel/kernel.dart';
+
+import 'compiler_options.dart';
+
+/// Represents the difference between "old" and "new" states of a program.
+///
+/// Not intended to be implemented or extended by clients.
+class DeltaProgram {
+ /// The new state of the program.
+ ///
+ /// Libraries whose kernel representation is known to be unchanged since the
+ /// last [DeltaProgram] are not included.
+ final Map<Uri, Program> newState;
+
+ DeltaProgram(this.newState);
+
+ /// TODO(paulberry): add information about libraries that were removed.
+}
+
+/// Interface for generating an initial kernel representation of a program and
+/// keeping it up to date as incremental changes are made.
+///
+/// This class maintains an internal "previous program state"; each
+/// time [computeDelta] is called, it updates the previous program state and
+/// produces a representation of what has changed. When there are few changes,
+/// a call to [computeDelta] should be much faster than compiling the whole
+/// program from scratch.
+///
+/// This class also maintains a set of "valid sources", which is a (possibly
+/// empty) subset of the sources constituting the previous program state. Files
+/// in this set are assumed to be unchanged since the last call to
+/// [computeDelta].
+///
+/// Behavior is undefined if the client does not obey the following concurrency
+/// restrictions:
+/// - no two invocations of [computeDelta] may be outstanding at any given time.
+/// - neither [invalidate] nor [invalidateAll] may be called while an invocation
+/// of [computeDelta] is outstanding.
+///
+/// Not intended to be implemented or extended by clients.
+abstract class IncrementalKernelGenerator {
+ /// Creates an [IncrementalKernelGenerator] which is prepared to generate
+ /// kernel representations of the program whose main library is in the given
+ /// [source].
+ ///
+ /// No file system access is performed by this constructor; the initial
+ /// "previous program state" is an empty program containing no code, and the
+ /// initial set of valid sources is empty. To obtain a kernel representation
+ /// of the program, call [computeDelta].
+ factory IncrementalKernelGenerator(Uri source, CompilerOptions options) =>
+ new IncrementalKernelGeneratorImpl(source, new ProcessedOptions(options));
+
+ /// Generates a kernel representation of the changes to the program, assuming
+ /// that all valid sources are unchanged since the last call to
+ /// [computeDelta].
+ ///
+ /// Source files in the set of valid sources are guaranteed not to be re-read
+ /// from disk; they are assumed to be unchanged regardless of the state of the
+ /// filesystem.
+ ///
+ /// If the future completes successfully, the previous file state is updated
+ /// and the set of valid sources is set to the set of all sources in the
+ /// program.
+ ///
+ /// If the future completes with an error (due to errors in the compiled
+ /// source code), the caller may consider the previous file state and the set
+ /// of valid sources to be unchanged; this means that once the user fixes the
+ /// errors, it is safe to call [computeDelta] again.
+ Future<DeltaProgram> computeDelta();
+
+ /// Remove any source file(s) associated with the given file path from the set
+ /// of valid sources. This guarantees that those files will be re-read on the
+ /// next call to [computeDelta]).
+ void invalidate(String path);
+
+ /// Remove all source files from the set of valid sources. This guarantees
+ /// that all files will be re-read on the next call to [computeDelta].
+ ///
+ /// Note that this does not erase the previous program state; the next time
+ /// [computeDelta] is called, if parts of the program are discovered to be
+ /// unchanged, parts of the previous program state will still be re-used to
+ /// speed up compilation.
+ void invalidateAll();
+}
diff --git a/pkg/front_end/lib/incremental_resolved_ast_generator.dart b/pkg/front_end/lib/incremental_resolved_ast_generator.dart
new file mode 100644
index 0000000..79799de
--- /dev/null
+++ b/pkg/front_end/lib/incremental_resolved_ast_generator.dart
@@ -0,0 +1,104 @@
+// 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 'package:front_end/src/base/processed_options.dart';
+import 'package:front_end/src/incremental_resolved_ast_generator_impl.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+
+import 'compiler_options.dart';
+
+/// Represents the difference between "old" and "new" states of a program.
+///
+/// Not intended to be implemented or extended by clients.
+class DeltaLibraries {
+ /// The new state of the program, as a map from Uri to [ResolvedLibrary].
+ ///
+ /// Libraries whose resolved AST is known to be unchanged since the last
+ /// [DeltaLibraries] are not included.
+ final Map<Uri, ResolvedLibrary> newState;
+
+ DeltaLibraries(this.newState);
+
+/// TODO(paulberry): add information about libraries that were removed.
+}
+
+/// Represents the resolved ASTs for all the compilation units in a single
+/// library.
+///
+/// Not intended to be implemented or extended by clients.
+class ResolvedLibrary {
+ final CompilationUnit definingCompilationUnit;
+
+ ResolvedLibrary(this.definingCompilationUnit);
+
+ // TODO(paulberry): add support for parts.
+}
+
+/// Interface for generating an initial resolved representation of a program and
+/// keeping it up to date as incremental changes are made.
+///
+/// This class maintains an internal "previous program state"; each
+/// time [computeDelta] is called, it updates the previous program state and
+/// produces a representation of what has changed. When there are few changes,
+/// a call to [computeDelta] should be much faster than compiling the whole
+/// program from scratch.
+///
+/// This class also maintains a set of "valid sources", which is a (possibly
+/// empty) subset of the sources constituting the previous program state. Files
+/// in this set are assumed to be unchanged since the last call to
+/// [computeDelta].
+///
+/// Behavior is undefined if the client does not obey the following concurrency
+/// restrictions:
+/// - no two invocations of [computeDelta] may be outstanding at any given time.
+/// - neither [invalidate] nor [invalidateAll] may be called while an invocation
+/// of [computeDelta] is outstanding.
+///
+/// Not intended to be implemented or extended by clients.
+abstract class IncrementalResolvedAstGenerator {
+ /// Creates an [IncrementalResolvedAstGenerator] which is prepared to generate
+ /// resolved ASTs for the program whose main library is in the given
+ /// [source].
+ ///
+ /// No file system access is performed by this constructor; the initial
+ /// "previous program state" is an empty program containing no code, and the
+ /// initial set of valid sources is empty. To obtain a resolved AST
+ /// representation of the program, call [computeDelta].
+ factory IncrementalResolvedAstGenerator(Uri source, CompilerOptions options) =>
+ new IncrementalResolvedAstGeneratorImpl(source, new ProcessedOptions(options));
+
+ /// Generates a resolved AST representation of the changes to the program,
+ /// assuming that all valid sources are unchanged since the last call to
+ /// [computeDelta].
+ ///
+ /// Source files in the set of valid sources are guaranteed not to be re-read
+ /// from disk; they are assumed to be unchanged regardless of the state of the
+ /// filesystem.
+ ///
+ /// If the future completes successfully, the previous file state is updated
+ /// and the set of valid sources is set to the set of all sources in the
+ /// program.
+ ///
+ /// If the future completes with an error (due to errors in the compiled
+ /// source code), the caller may consider the previous file state and the set
+ /// of valid sources to be unchanged; this means that once the user fixes the
+ /// errors, it is safe to call [computeDelta] again.
+ Future<DeltaLibraries> computeDelta();
+
+ /// Remove any source file(s) associated with the given file path from the set
+ /// of valid sources. This guarantees that those files will be re-read on the
+ /// next call to [computeDelta]).
+ void invalidate(String path);
+
+ /// Remove all source files from the set of valid sources. This guarantees
+ /// that all files will be re-read on the next call to [computeDelta].
+ ///
+ /// Note that this does not erase the previous program state; the next time
+ /// [computeDelta] is called, if parts of the program are discovered to be
+ /// unchanged, parts of the previous program state will still be re-used to
+ /// speed up compilation.
+ void invalidateAll();
+}
diff --git a/pkg/front_end/lib/src/base/source.dart b/pkg/front_end/lib/src/base/source.dart
index 0ed4747..a87f933 100644
--- a/pkg/front_end/lib/src/base/source.dart
+++ b/pkg/front_end/lib/src/base/source.dart
@@ -5,6 +5,33 @@
import 'package:front_end/src/base/analysis_target.dart';
import 'package:front_end/src/base/timestamped_data.dart';
import 'package:front_end/src/base/uri_kind.dart';
+import 'package:path/path.dart' as pathos;
+
+/// Base class providing implementations for the methods in [Source] that don't
+/// require filesystem access.
+abstract class BasicSource extends Source {
+ final Uri uri;
+
+ BasicSource(this.uri);
+
+ @override
+ String get encoding => uri.toString();
+
+ @override
+ String get fullName => encoding;
+
+ @override
+ int get hashCode => uri.hashCode;
+
+ @override
+ bool get isInSystemLibrary => uri.scheme == 'dart';
+
+ @override
+ String get shortName => pathos.basename(fullName);
+
+ @override
+ bool operator ==(Object object) => object is Source && object.uri == uri;
+}
/**
* The interface `Source` defines the behavior of objects representing source code that can be
diff --git a/pkg/front_end/lib/src/incremental_kernel_generator_impl.dart b/pkg/front_end/lib/src/incremental_kernel_generator_impl.dart
new file mode 100644
index 0000000..8ea6d18
--- /dev/null
+++ b/pkg/front_end/lib/src/incremental_kernel_generator_impl.dart
@@ -0,0 +1,143 @@
+// 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 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_resolution_map.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:front_end/incremental_kernel_generator.dart';
+import 'package:front_end/incremental_resolved_ast_generator.dart';
+import 'package:front_end/src/base/processed_options.dart';
+import 'package:front_end/src/base/source.dart';
+import 'package:front_end/src/incremental_resolved_ast_generator_impl.dart';
+import 'package:kernel/analyzer/loader.dart';
+import 'package:kernel/kernel.dart' hide Source;
+import 'package:kernel/repository.dart';
+
+dynamic unimplemented() {
+ // TODO(paulberry): get rid of this.
+ throw new UnimplementedError();
+}
+
+DartOptions _convertOptions(ProcessedOptions options) {
+ // TODO(paulberry): make sure options.compileSdk is handled correctly.
+ return new DartOptions(
+ strongMode: true, // TODO(paulberry): options.strongMode,
+ sdk: null, // TODO(paulberry): _uriToPath(options.sdkRoot, options),
+ sdkSummary:
+ null, // TODO(paulberry): options.compileSdk ? null : _uriToPath(options.sdkSummary, options),
+ packagePath:
+ null, // TODO(paulberry): _uriToPath(options.packagesFileUri, options),
+ declaredVariables: null // TODO(paulberry): options.declaredVariables
+ );
+}
+
+/// Implementation of [IncrementalKernelGenerator].
+///
+/// Theory of operation: an instance of [IncrementalResolvedAstGenerator] is
+/// used to obtain resolved ASTs, and these are fed into kernel code generation
+/// logic.
+///
+/// Note that the kernel doesn't expect to take resolved ASTs as a direct input;
+/// it expects to request resolved ASTs from an [AnalysisContext]. To deal with
+/// this, we create [_AnalysisContextProxy] which returns the resolved ASTs when
+/// requested. TODO(paulberry): Make this unnecessary.
+class IncrementalKernelGeneratorImpl implements IncrementalKernelGenerator {
+ final IncrementalResolvedAstGenerator _resolvedAstGenerator;
+ final ProcessedOptions _options;
+
+ IncrementalKernelGeneratorImpl(Uri source, ProcessedOptions options)
+ : _resolvedAstGenerator =
+ new IncrementalResolvedAstGeneratorImpl(source, options),
+ _options = options;
+
+ @override
+ Future<DeltaProgram> computeDelta() async {
+ var deltaLibraries = await _resolvedAstGenerator.computeDelta();
+ var kernelOptions = _convertOptions(_options);
+ var packages = null; // TODO(paulberry)
+ var kernels = <Uri, Program>{};
+ deltaLibraries.newState.forEach((uri, resolvedLibrary) {
+ // The kernel generation code doesn't currently support building a kernel
+ // directly from resolved ASTs--it wants to query an analysis context. So
+ // we provide it with a proxy analysis context that feeds it the resolved
+ // ASTs.
+ var strongMode = true; // TODO(paulberry): set this correctly
+ var analysisOptions = new _AnalysisOptionsProxy(strongMode);
+ var context =
+ new _AnalysisContextProxy(deltaLibraries.newState, analysisOptions);
+ var repository = new Repository();
+ var loader =
+ new DartLoader(repository, kernelOptions, packages, context: context);
+ loader.loadLibrary(uri);
+ kernels[uri] = new Program(repository.libraries);
+ });
+ return new DeltaProgram(kernels);
+ }
+
+ @override
+ void invalidate(String path) => _resolvedAstGenerator.invalidate(path);
+
+ @override
+ void invalidateAll() => _resolvedAstGenerator.invalidateAll();
+}
+
+class _AnalysisContextProxy implements AnalysisContext {
+ final Map<Uri, ResolvedLibrary> _resolvedLibraries;
+
+ @override
+ final _SourceFactoryProxy sourceFactory = new _SourceFactoryProxy();
+
+ @override
+ final AnalysisOptions analysisOptions;
+
+ _AnalysisContextProxy(this._resolvedLibraries, this.analysisOptions);
+
+ List<AnalysisError> computeErrors(Source source) {
+ // TODO(paulberry): do we need to return errors sometimes?
+ return [];
+ }
+
+ LibraryElement computeLibraryElement(Source source) {
+ assert(_resolvedLibraries.containsKey(source.uri));
+ return resolutionMap
+ .elementDeclaredByCompilationUnit(
+ _resolvedLibraries[source.uri].definingCompilationUnit)
+ .library;
+ }
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+
+ CompilationUnit resolveCompilationUnit(
+ Source unitSource, LibraryElement library) {
+ assert(_resolvedLibraries.containsKey(library.source.uri));
+ // TODO(paulberry): support parts.
+ assert(unitSource == library.source);
+ return _resolvedLibraries[library.source.uri].definingCompilationUnit;
+ }
+}
+
+class _AnalysisOptionsProxy implements AnalysisOptions {
+ final bool strongMode;
+
+ _AnalysisOptionsProxy(this.strongMode);
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+}
+
+class _SourceFactoryProxy implements SourceFactory {
+ Source forUri2(Uri absoluteUri) => new _SourceProxy(absoluteUri);
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+}
+
+class _SourceProxy extends BasicSource {
+ _SourceProxy(Uri uri) : super(uri);
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+}
diff --git a/pkg/front_end/lib/src/incremental_resolved_ast_generator_impl.dart b/pkg/front_end/lib/src/incremental_resolved_ast_generator_impl.dart
new file mode 100644
index 0000000..20c4e2e
--- /dev/null
+++ b/pkg/front_end/lib/src/incremental_resolved_ast_generator_impl.dart
@@ -0,0 +1,288 @@
+// 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 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/context/context.dart';
+import 'package:analyzer/src/dart/analysis/byte_store.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart' as driver;
+import 'package:analyzer/src/dart/analysis/file_state.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/sdk.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/summary/idl.dart';
+import 'package:analyzer/src/summary/summary_sdk.dart';
+import 'package:analyzer/src/util/absolute_path.dart';
+import 'package:front_end/incremental_resolved_ast_generator.dart';
+import 'package:front_end/src/base/processed_options.dart';
+import 'package:front_end/src/base/source.dart';
+import 'package:front_end/src/dependency_grapher_impl.dart';
+import 'package:path/src/context.dart';
+
+dynamic unimplemented() {
+ // TODO(paulberry): get rid of this.
+ throw new UnimplementedError();
+}
+
+/// Implementation of [IncrementalKernelGenerator].
+///
+/// Theory of operation: this class is a thin wrapper around
+/// [driver.AnalysisDriver]. When the client requests a new delta, we forward
+/// the request to the analysis driver. When the client calls an invalidate
+/// method, we ensure that the proper files will be re-read next time a delta is
+/// requested.
+///
+/// Note that the analysis driver expects to be able to read file contents
+/// synchronously based on filesystem path rather than asynchronously based on
+/// URI, so the file contents are first read into memory using the asynchronous
+/// FileSystem API, and then these are fed into the analysis driver using a
+/// proxy implementation of [ResourceProvider]. TODO(paulberry): make this (and
+/// other proxies in this file) unnecessary.
+class IncrementalResolvedAstGeneratorImpl
+ implements IncrementalResolvedAstGenerator {
+ driver.AnalysisDriverScheduler _scheduler;
+ final _pathToUriMap = <String, Uri>{};
+ final _uriToPathMap = <Uri, String>{};
+ final _fileContents = <String, String>{};
+ _ResourceProviderProxy _resourceProvider;
+ driver.AnalysisDriver _driver;
+ bool _isInitialized = false;
+ final ProcessedOptions _options;
+ final Uri _source;
+ bool _schedulerStarted = false;
+
+ IncrementalResolvedAstGeneratorImpl(this._source, this._options);
+
+ @override
+ Future<DeltaLibraries> computeDelta() async {
+ if (!_isInitialized) {
+ await init();
+ }
+ // The analysis driver doesn't currently support an asynchronous file API,
+ // so we have to find all the files first to read their contents.
+ // TODO(paulberry): this is an unnecessary source of duplicate work and
+ // should be eliminated ASAP.
+ var graph = await graphForProgram([_source], _options);
+ var libraries = <Uri, ResolvedLibrary>{};
+ // TODO(paulberry): it should be possible to seed the driver using a URI,
+ // not a file path.
+ if (!_schedulerStarted) {
+ _scheduler.start();
+ _schedulerStarted = true;
+ }
+ _driver.addFile(_source.path);
+ for (var libraryCycle in graph.topologicallySortedCycles) {
+ for (var uri in libraryCycle.libraries.keys) {
+ var contents =
+ await _options.fileSystem.entityForUri(uri).readAsString();
+ _storeVirtualFile(uri, uri.path, contents);
+ }
+ // The driver will request files from dart:, even though it actually uses
+ // the data from the summary. TODO(paulberry): fix this.
+ _storeVirtualFile(_DartSdkProxy._dartCoreSource.uri, 'core.dart', '');
+ for (var uri in libraryCycle.libraries.keys) {
+ var result = await _driver.getResult(uri.path);
+ // TODO(paulberry): handle errors.
+ libraries[uri] = new ResolvedLibrary(result.unit);
+ }
+ }
+ // TODO(paulberry): stop the scheduler
+ return new DeltaLibraries(libraries);
+ }
+
+ Future<Null> init() async {
+ // TODO(paulberry): can we just use null?
+ var performanceLog = new driver.PerformanceLog(new _NullStringSink());
+ _scheduler = new driver.AnalysisDriverScheduler(performanceLog);
+ _resourceProvider =
+ new _ResourceProviderProxy(_fileContents, _pathToUriMap);
+ // TODO(paulberry): MemoryByteStore leaks memory (it never discards data).
+ // Do something better here.
+ var byteStore = new MemoryByteStore();
+ // TODO(paulberry): can we just use null?
+ var fileContentOverlay = new FileContentOverlay();
+ var sdkContext = new AnalysisContextImpl();
+ var dartSdk = new _DartSdkProxy(await _options.getSdkSummary(), sdkContext);
+ sdkContext.sourceFactory =
+ new SourceFactory([new DartUriResolver(dartSdk)]);
+ bool strongMode = true; // TODO(paulberry): support strong mode flag.
+ sdkContext.resultProvider = new SdkSummaryResultProvider(
+ sdkContext, await _options.getSdkSummary(), strongMode);
+
+ var sourceFactory =
+ new _SourceFactoryProxy(dartSdk, _pathToUriMap, _uriToPathMap);
+ var analysisOptions = new AnalysisOptionsImpl();
+ _driver = new driver.AnalysisDriver(
+ _scheduler,
+ performanceLog,
+ _resourceProvider,
+ byteStore,
+ fileContentOverlay,
+ 'front_end',
+ sourceFactory,
+ analysisOptions);
+ _isInitialized = true;
+ }
+
+ @override
+ void invalidate(String path) {
+ throw new UnimplementedError();
+ }
+
+ @override
+ void invalidateAll() {
+ // TODO(paulberry): verify that this has an effect (requires a multi-file
+ // test).
+ if (_isInitialized) {
+ _driver.knownFiles.forEach(_driver.changeFile);
+ }
+ }
+
+ void _storeVirtualFile(Uri uri, String path, String contents) {
+ _pathToUriMap[path] = uri;
+ _uriToPathMap[uri] = path;
+ _fileContents[path] = contents;
+ }
+}
+
+class _DartSdkProxy implements DartSdk {
+ static final _dartCoreSource =
+ new _SourceProxy(Uri.parse('dart:core'), 'core.dart');
+
+ final PackageBundle summary;
+
+ final AnalysisContext context;
+
+ _DartSdkProxy(this.summary, this.context);
+
+ @override
+ PackageBundle getLinkedBundle() => summary;
+
+ @override
+ Source mapDartUri(String uri) {
+ // TODO(paulberry): this seems hacky.
+ return new _SourceProxy(Uri.parse(uri), '$uri.dart');
+ }
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+}
+
+class _FileProxy implements File {
+ final _SourceProxy _source;
+
+ final _ResourceProviderProxy _resourceProvider;
+
+ _FileProxy(this._source, this._resourceProvider);
+
+ @override
+ String get path => _source.fullName;
+
+ @override
+ String get shortName => path;
+
+ @override
+ Source createSource([Uri uri]) {
+ assert(uri == null);
+ return _source;
+ }
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+
+ @override
+ String readAsStringSync() {
+ assert(_resourceProvider.fileContents.containsKey(path));
+ return _resourceProvider.fileContents[path];
+ }
+}
+
+/// A string sink that ignores everything written to it.
+class _NullStringSink implements StringSink {
+ void write(Object obj) {}
+ void writeAll(Iterable objects, [String separator = ""]) {}
+ void writeCharCode(int charCode) {}
+ void writeln([Object obj = ""]) {}
+}
+
+class _ResourceProviderProxy implements ResourceProvider {
+ final Map<String, String> fileContents;
+ final Map<String, Uri> pathToUriMap;
+
+ _ResourceProviderProxy(this.fileContents, this.pathToUriMap);
+
+ @override
+ AbsolutePathContext get absolutePathContext => throw new UnimplementedError();
+
+ @override
+ Context get pathContext => throw new UnimplementedError();
+
+ @override
+ File getFile(String path) {
+ assert(fileContents.containsKey(path));
+ assert(pathToUriMap.containsKey(path));
+ return new _FileProxy(new _SourceProxy(pathToUriMap[path], path), this);
+ }
+
+ @override
+ Folder getFolder(String path) => throw new UnimplementedError();
+
+ @override
+ Future<List<int>> getModificationTimes(List<Source> sources) =>
+ throw new UnimplementedError();
+
+ @override
+ Resource getResource(String path) => throw new UnimplementedError();
+
+ @override
+ Folder getStateLocation(String pluginId) => throw new UnimplementedError();
+}
+
+class _SourceFactoryProxy implements SourceFactory {
+ @override
+ final DartSdk dartSdk;
+
+ final Map<String, Uri> pathToUriMap;
+
+ final Map<Uri, String> uriToPathMap;
+
+ @override
+ AnalysisContext context;
+
+ _SourceFactoryProxy(this.dartSdk, this.pathToUriMap, this.uriToPathMap);
+
+ @override
+ SourceFactory clone() =>
+ new _SourceFactoryProxy(dartSdk, pathToUriMap, uriToPathMap);
+
+ @override
+ Source forUri(String absoluteUri) {
+ if (absoluteUri == 'dart:core') return _DartSdkProxy._dartCoreSource;
+ Uri uri = Uri.parse(absoluteUri);
+ assert(uriToPathMap.containsKey(uri));
+ return new _SourceProxy(uri, uriToPathMap[uri]);
+ }
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+
+ Source resolveUri(Source containingSource, String containedUri) {
+ // TODO(paulberry): re-use code from dependency_grapher_impl, and support
+ // SDK URI resolution logic.
+ var absoluteUri = containingSource.uri.resolve(containedUri);
+ return forUri(absoluteUri.toString());
+ }
+
+ @override
+ Uri restoreUri(Source source) => source.uri;
+}
+
+class _SourceProxy extends BasicSource {
+ @override
+ final String fullName;
+
+ _SourceProxy(Uri uri, this.fullName) : super(uri);
+
+ int get modificationStamp => 0;
+
+ noSuchMethod(Invocation invocation) => unimplemented();
+}
diff --git a/pkg/front_end/test/incremental_kernel_generator_test.dart b/pkg/front_end/test/incremental_kernel_generator_test.dart
new file mode 100644
index 0000000..9dc58c2
--- /dev/null
+++ b/pkg/front_end/test/incremental_kernel_generator_test.dart
@@ -0,0 +1,126 @@
+// 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 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
+import 'package:front_end/compiler_options.dart';
+import 'package:front_end/incremental_kernel_generator.dart';
+import 'package:front_end/memory_file_system.dart';
+import 'package:kernel/ast.dart';
+import 'package:path/path.dart' as pathos;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(IncrementalKernelGeneratorTest);
+ });
+}
+
+final _sdkSummary = _readSdkSummary();
+
+List<int> _readSdkSummary() {
+ var resourceProvider = PhysicalResourceProvider.INSTANCE;
+ var sdk = new FolderBasedDartSdk(resourceProvider,
+ FolderBasedDartSdk.defaultSdkDirectory(resourceProvider))
+ ..useSummary = true;
+ var path = resourceProvider.pathContext
+ .join(sdk.directory.path, 'lib', '_internal', 'strong.sum');
+ return resourceProvider.getFile(path).readAsBytesSync();
+}
+
+typedef void LibraryChecker(Library lib);
+
+@reflectiveTest
+class IncrementalKernelGeneratorTest {
+ static final sdkSummaryUri = Uri.parse('special:sdk_summary');
+
+ /// Virtual filesystem for testing.
+ final fileSystem = new MemoryFileSystem(pathos.posix, Uri.parse('file:///'));
+
+ /// The object under test.
+ IncrementalKernelGenerator incrementalKernelGenerator;
+
+ void checkLibraries(
+ List<Library> libraries, Map<Uri, LibraryChecker> expected) {
+ expect(
+ libraries.map((lib) => lib.importUri), unorderedEquals(expected.keys));
+ var librariesMap = <Uri, Library>{};
+ for (var lib in libraries) {
+ librariesMap[lib.importUri] = lib;
+ }
+ expected.forEach((uri, checker) => checker(librariesMap[uri]));
+ }
+
+ Future<Map<Uri, Program>> getInitialState(Uri startingUri) async {
+ fileSystem.entityForUri(sdkSummaryUri).writeAsBytesSync(_sdkSummary);
+ incrementalKernelGenerator = new IncrementalKernelGenerator(
+ startingUri,
+ new CompilerOptions()
+ ..fileSystem = fileSystem
+ ..chaseDependencies = true
+ ..sdkSummary = sdkSummaryUri
+ ..packagesFileUri = new Uri());
+ return (await incrementalKernelGenerator.computeDelta()).newState;
+ }
+
+ test_incrementalUpdate_referenceToCore() async {
+ // TODO(paulberry): test parts.
+ writeFiles({'/foo.dart': 'main() { print(1); }'});
+ var fileUri = Uri.parse('file:///foo.dart');
+ var initialState = await getInitialState(fileUri);
+ expect(initialState.keys, unorderedEquals([fileUri]));
+ void _checkMain(List<Library> libraries, int expectedArgument) {
+ checkLibraries(libraries, {
+ fileUri: (library) {
+ expect(library.importUri, fileUri);
+ expect(library.classes, isEmpty);
+ expect(library.procedures, hasLength(1));
+ expect(library.procedures[0].name.name, 'main');
+ var body = library.procedures[0].function.body;
+ expect(body, new isInstanceOf<Block>());
+ var block = body as Block;
+ expect(block.statements, hasLength(1));
+ expect(block.statements[0], new isInstanceOf<ExpressionStatement>());
+ var expressionStatement = block.statements[0] as ExpressionStatement;
+ expect(expressionStatement.expression,
+ new isInstanceOf<StaticInvocation>());
+ var staticInvocation =
+ expressionStatement.expression as StaticInvocation;
+ expect(staticInvocation.target.name.name, 'print');
+ expect(staticInvocation.arguments.positional, hasLength(1));
+ expect(staticInvocation.arguments.positional[0],
+ new isInstanceOf<IntLiteral>());
+ var intLiteral =
+ staticInvocation.arguments.positional[0] as IntLiteral;
+ expect(intLiteral.value, expectedArgument);
+ },
+ Uri.parse('dart:core'): (library) {
+ // Should contain the procedure "print" but not its definition.
+ expect(library.procedures, hasLength(1));
+ expect(library.procedures[0].name.name, 'print');
+ expect(library.procedures[0].function.body, isNull);
+ }
+ });
+ }
+
+ _checkMain(initialState[fileUri].libraries, 1);
+ writeFiles({'/foo.dart': 'main() { print(2); }'});
+ incrementalKernelGenerator.invalidateAll();
+ var deltaProgram = await incrementalKernelGenerator.computeDelta();
+ expect(deltaProgram.newState.keys, unorderedEquals([fileUri]));
+ _checkMain(deltaProgram.newState[fileUri].libraries, 2);
+ }
+
+ /// Write the given file contents to the virtual filesystem.
+ void writeFiles(Map<String, String> contents) {
+ contents.forEach((path, text) {
+ fileSystem
+ .entityForUri(Uri.parse('file://$path'))
+ .writeAsStringSync(text);
+ });
+ }
+}
diff --git a/pkg/front_end/test/incremental_resolved_ast_generator_test.dart b/pkg/front_end/test/incremental_resolved_ast_generator_test.dart
new file mode 100644
index 0000000..3478835
--- /dev/null
+++ b/pkg/front_end/test/incremental_resolved_ast_generator_test.dart
@@ -0,0 +1,124 @@
+// 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 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_resolution_map.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:analyzer/src/dart/sdk/sdk.dart';
+import 'package:front_end/compiler_options.dart';
+import 'package:front_end/incremental_resolved_ast_generator.dart';
+import 'package:front_end/memory_file_system.dart';
+import 'package:path/path.dart' as pathos;
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(IncrementalResolvedAstGeneratorTest);
+ });
+}
+
+final _sdkSummary = _readSdkSummary();
+
+List<int> _readSdkSummary() {
+ var resourceProvider = PhysicalResourceProvider.INSTANCE;
+ var sdk = new FolderBasedDartSdk(resourceProvider,
+ FolderBasedDartSdk.defaultSdkDirectory(resourceProvider))
+ ..useSummary = true;
+ var path = resourceProvider.pathContext
+ .join(sdk.directory.path, 'lib', '_internal', 'strong.sum');
+ return resourceProvider.getFile(path).readAsBytesSync();
+}
+
+@reflectiveTest
+class IncrementalResolvedAstGeneratorTest {
+ static final sdkSummaryUri = Uri.parse('special:sdk_summary');
+
+ /// Virtual filesystem for testing.
+ final fileSystem = new MemoryFileSystem(pathos.posix, Uri.parse('file:///'));
+
+ /// The object under test.
+ IncrementalResolvedAstGenerator incrementalResolvedAstGenerator;
+
+ Future<Map<Uri, ResolvedLibrary>> getInitialProgram(Uri startingUri) async {
+ fileSystem.entityForUri(sdkSummaryUri).writeAsBytesSync(_sdkSummary);
+ incrementalResolvedAstGenerator = new IncrementalResolvedAstGenerator(
+ startingUri,
+ new CompilerOptions()
+ ..fileSystem = fileSystem
+ ..chaseDependencies = true
+ ..sdkSummary = sdkSummaryUri
+ ..packagesFileUri = new Uri());
+ return (await incrementalResolvedAstGenerator.computeDelta()).newState;
+ }
+
+ test_incrementalUpdate_referenceToCore() async {
+ // TODO(paulberry): test parts.
+ writeFiles({'/foo.dart': 'main() { print(1); }'});
+ var fooUri = Uri.parse('file:///foo.dart');
+ var initialProgram = await getInitialProgram(fooUri);
+ expect(initialProgram.keys, unorderedEquals([fooUri]));
+
+ void _checkMain(CompilationUnit unit, int expectedArgument) {
+ expect(unit.declarations, hasLength(1));
+ expect(unit.declarations[0], new isInstanceOf<FunctionDeclaration>());
+ var main = unit.declarations[0] as FunctionDeclaration;
+ expect(main.name.name, 'main');
+ expect(
+ main.functionExpression.body, new isInstanceOf<BlockFunctionBody>());
+ var blockFunctionBody = main.functionExpression.body as BlockFunctionBody;
+ expect(blockFunctionBody.block.statements, hasLength(1));
+ expect(blockFunctionBody.block.statements[0],
+ new isInstanceOf<ExpressionStatement>());
+ var expressionStatement =
+ blockFunctionBody.block.statements[0] as ExpressionStatement;
+ expect(
+ expressionStatement.expression, new isInstanceOf<MethodInvocation>());
+ var methodInvocation = expressionStatement.expression as MethodInvocation;
+ expect(methodInvocation.methodName.name, 'print');
+ var printElement =
+ resolutionMap.staticElementForIdentifier(methodInvocation.methodName);
+ expect(printElement, isNotNull);
+ expect(printElement.library.source.uri, Uri.parse('dart:core'));
+ expect(methodInvocation.argumentList.arguments, hasLength(1));
+ expect(methodInvocation.argumentList.arguments[0],
+ new isInstanceOf<IntegerLiteral>());
+ var integerLiteral =
+ methodInvocation.argumentList.arguments[0] as IntegerLiteral;
+ expect(integerLiteral.value, expectedArgument);
+ }
+
+ _checkMain(initialProgram[fooUri].definingCompilationUnit, 1);
+ writeFiles({'/foo.dart': 'main() { print(2); }'});
+ // TODO(paulberry): verify that the file isn't actually reread until
+ // invalidate is called.
+ // var deltaProgram1 = await incrementalResolvedAstGenerator.computeDelta();
+ // expect(deltaProgram1.newState, isEmpty);
+ incrementalResolvedAstGenerator.invalidateAll();
+ var deltaProgram2 = await incrementalResolvedAstGenerator.computeDelta();
+ expect(deltaProgram2.newState.keys, unorderedEquals([fooUri]));
+ _checkMain(deltaProgram2.newState[fooUri].definingCompilationUnit, 2);
+ }
+
+ test_invalidateAllBeforeInitialProgram() async {
+ incrementalResolvedAstGenerator = new IncrementalResolvedAstGenerator(
+ Uri.parse('file:///foo.dart'),
+ new CompilerOptions()
+ ..fileSystem = fileSystem
+ ..chaseDependencies = true
+ ..packagesFileUri = new Uri());
+ incrementalResolvedAstGenerator.invalidateAll();
+ }
+
+ /// Write the given file contents to the virtual filesystem.
+ void writeFiles(Map<String, String> contents) {
+ contents.forEach((path, text) {
+ fileSystem
+ .entityForUri(Uri.parse('file://$path'))
+ .writeAsStringSync(text);
+ });
+ }
+}
diff --git a/pkg/kernel/lib/analyzer/ast_from_analyzer.dart b/pkg/kernel/lib/analyzer/ast_from_analyzer.dart
index 7bf54a7..034decd 100644
--- a/pkg/kernel/lib/analyzer/ast_from_analyzer.dart
+++ b/pkg/kernel/lib/analyzer/ast_from_analyzer.dart
@@ -2840,6 +2840,7 @@
}
visitFunctionDeclaration(FunctionDeclaration node) {
+ addAnnotations(node.metadata);
var function = node.functionExpression;
ast.Procedure procedure = currentMember;
procedure.function = scope.buildFunctionNode(
diff --git a/pkg/kernel/lib/analyzer/loader.dart b/pkg/kernel/lib/analyzer/loader.dart
index cba5824..cb5c9c6 100644
--- a/pkg/kernel/lib/analyzer/loader.dart
+++ b/pkg/kernel/lib/analyzer/loader.dart
@@ -108,8 +108,8 @@
bool get strongMode => context.analysisOptions.strongMode;
DartLoader(this.repository, DartOptions options, Packages packages,
- {DartSdk dartSdk})
- : this.context = createContext(options, packages, dartSdk: dartSdk),
+ {DartSdk dartSdk, AnalysisContext context})
+ : this.context = context ?? createContext(options, packages, dartSdk: dartSdk),
this.applicationRoot = options.applicationRoot;
String getLibraryName(LibraryElement element) {
diff --git a/pkg/kernel/lib/target/targets.dart b/pkg/kernel/lib/target/targets.dart
index 1dcae03..1c06273 100644
--- a/pkg/kernel/lib/target/targets.dart
+++ b/pkg/kernel/lib/target/targets.dart
@@ -6,6 +6,7 @@
import '../ast.dart';
import 'vm.dart';
+import 'vmcc.dart';
import 'flutter.dart';
final List<String> targetNames = targets.keys.toList();
@@ -20,6 +21,7 @@
final Map<String, _TargetBuilder> targets = <String, _TargetBuilder>{
'none': (TargetFlags flags) => new NoneTarget(flags),
'vm': (TargetFlags flags) => new VmTarget(flags),
+ 'vmcc': (TargetFlags flags) => new VmClosureConvertedTarget(flags),
'flutter': (TargetFlags flags) => new FlutterTarget(flags),
};
diff --git a/pkg/kernel/lib/target/vmcc.dart b/pkg/kernel/lib/target/vmcc.dart
new file mode 100644
index 0000000..b292457
--- /dev/null
+++ b/pkg/kernel/lib/target/vmcc.dart
@@ -0,0 +1,23 @@
+// 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.
+library kernel.target.vmcc;
+
+import '../ast.dart' show Program;
+import '../transformations/closure_conversion.dart' as cc show transformProgram;
+
+import 'targets.dart' show TargetFlags;
+import 'vm.dart' as vm_target;
+
+class VmClosureConvertedTarget extends vm_target.VmTarget {
+ VmClosureConvertedTarget(TargetFlags flags) : super(flags);
+
+ @override
+ String get name => "vmcc";
+
+ @override
+ void transformProgram(Program program) {
+ super.transformProgram(program);
+ cc.transformProgram(program);
+ }
+}
diff --git a/pkg/kernel/lib/transformations/closure/mock.dart b/pkg/kernel/lib/transformations/closure/mock.dart
index be8847d..6f13fca 100644
--- a/pkg/kernel/lib/transformations/closure/mock.dart
+++ b/pkg/kernel/lib/transformations/closure/mock.dart
@@ -24,6 +24,7 @@
Library,
MethodInvocation,
Name,
+ NullLiteral,
Procedure,
ProcedureKind,
Program,
@@ -84,6 +85,11 @@
/// Context(int i) : list = new List(i);
VariableDeclaration iParameter = new VariableDeclaration("i",
type: coreTypes.intClass.rawType, isFinal: true);
+
+ // TODO(karlklose): use the default factory when it is exposed again.
+ Procedure listConstructor = coreTypes.listClass.procedures.firstWhere(
+ (Procedure p) => p.name.name == 'filled');
+
Constructor constructor = new Constructor(
new FunctionNode(new EmptyStatement(),
positionalParameters: <VariableDeclaration>[iParameter]),
@@ -92,9 +98,10 @@
new FieldInitializer(
listField,
new StaticInvocation(
- coreTypes.listClass.procedures.first,
+ listConstructor,
new Arguments(<Expression>[
- new VariableAccessor(iParameter).buildSimpleRead()
+ new VariableAccessor(iParameter).buildSimpleRead(),
+ new NullLiteral(),
], types: <DartType>[
const DynamicType()
])))
diff --git a/pkg/kernel/lib/transformations/insert_covariance_checks.dart b/pkg/kernel/lib/transformations/insert_covariance_checks.dart
index b4e1869..662dda9 100644
--- a/pkg/kernel/lib/transformations/insert_covariance_checks.dart
+++ b/pkg/kernel/lib/transformations/insert_covariance_checks.dart
@@ -504,13 +504,21 @@
@override
visitMethodInvocation(MethodInvocation node) {
- node.interfaceTarget = getChecked(node.receiver, node.interfaceTarget);
+ var target = getChecked(node.receiver, node.interfaceTarget);
+ if (target != null) {
+ node.interfaceTarget = target;
+ node.name = target.name;
+ }
node.visitChildren(this);
}
@override
visitPropertySet(PropertySet node) {
- node.interfaceTarget = getChecked(node.receiver, node.interfaceTarget);
+ var target = getChecked(node.receiver, node.interfaceTarget);
+ if (target != null) {
+ node.interfaceTarget = target;
+ node.name = target.name;
+ }
node.visitChildren(this);
}
}
diff --git a/pkg/kernel/lib/transformations/sanitize_for_vm.dart b/pkg/kernel/lib/transformations/sanitize_for_vm.dart
index f5f86c3..fc83ab7 100644
--- a/pkg/kernel/lib/transformations/sanitize_for_vm.dart
+++ b/pkg/kernel/lib/transformations/sanitize_for_vm.dart
@@ -14,7 +14,7 @@
for (var class_ in library.classes) {
if (class_.constructors.isEmpty && class_.procedures.isEmpty) {
class_.addMember(new Constructor(
- new FunctionNode(new InvalidStatement()),
+ new FunctionNode(new EmptyStatement()),
name: new Name('')));
}
}
diff --git a/pkg/kernel/testcases/closures/capture_closure.dart.expect b/pkg/kernel/testcases/closures/capture_closure.dart.expect
index 115cb6b..830004b 100644
--- a/pkg/kernel/testcases/closures/capture_closure.dart.expect
+++ b/pkg/kernel/testcases/closures/capture_closure.dart.expect
@@ -31,6 +31,6 @@
final mock::Context #context = new mock::Context::•(1);
#context.parent = null;
#context.[]=(0, new self::Closure#main#f::•(#context));
- final() → dynamic g = new self::Closure#main#g::•(#context);
+ final () → dynamic g = new self::Closure#main#g::•(#context);
g.call();
}
diff --git a/pkg/kernel/testcases/closures/capture_closure_parameter.dart.expect b/pkg/kernel/testcases/closures/capture_closure_parameter.dart.expect
index 204b5c1..7cc52f2 100644
--- a/pkg/kernel/testcases/closures/capture_closure_parameter.dart.expect
+++ b/pkg/kernel/testcases/closures/capture_closure_parameter.dart.expect
@@ -27,11 +27,11 @@
final mock::Context #context = new mock::Context::•(1);
#context.parent = #contextParameter;
#context.[]=(0, null);
- final() → dynamic bar = new self::Closure#main#foo#bar::•(#context);
+ final () → dynamic bar = new self::Closure#main#foo#bar::•(#context);
return bar;
}
}
static method main(core::List<core::String> arguments) → dynamic {
- final(dynamic) → dynamic foo = new self::Closure#main#foo::•(null);
+ final (dynamic) → dynamic foo = new self::Closure#main#foo::•(null);
foo.call(arguments.[](0)).call();
}
diff --git a/pkg/kernel/testcases/closures/named_closure.dart.expect b/pkg/kernel/testcases/closures/named_closure.dart.expect
index c1b236d..cac6a81 100644
--- a/pkg/kernel/testcases/closures/named_closure.dart.expect
+++ b/pkg/kernel/testcases/closures/named_closure.dart.expect
@@ -23,7 +23,7 @@
final mock::Context #context = new mock::Context::•(1);
#context.parent = null;
#context.[]=(0, arguments);
- final(dynamic) → dynamic g = new self::Closure#main#g::•(#context);
+ final (dynamic) → dynamic g = new self::Closure#main#g::•(#context);
self::f = g;
self::foo();
}
diff --git a/pkg/kernel/testcases/closures/type_variables.dart.expect b/pkg/kernel/testcases/closures/type_variables.dart.expect
index 189739d..b58d4db 100644
--- a/pkg/kernel/testcases/closures/type_variables.dart.expect
+++ b/pkg/kernel/testcases/closures/type_variables.dart.expect
@@ -20,7 +20,7 @@
return new self::Closure#C#baz#function::•<self::C::T, self::C::S>(null);
}
static factory •<T extends core::Object, S extends core::Object>() → self::C<self::C::•::T, self::C::•::S> {
- final() → dynamic local = new self::Closure#C#function#local::•<self::C::•::T, self::C::•::S>(null);
+ final () → dynamic local = new self::Closure#C#function#local::•<self::C::•::T, self::C::•::S>(null);
return local.call();
}
}
diff --git a/pkg/pkg.status b/pkg/pkg.status
index dd69e65..d0e1b66 100644
--- a/pkg/pkg.status
+++ b/pkg/pkg.status
@@ -18,6 +18,7 @@
# Skip dev_compiler codegen tests
dev_compiler/test/codegen/*: Skip
+dev_compiler/gen/*: SkipByDesign
[ $runtime == vm && $mode == release && $system == linux ]
kernel/test/closures_test: Slow, Pass
@@ -30,7 +31,6 @@
dev_compiler/test/*: Skip
[ $compiler == dart2analyzer ]
-dev_compiler/gen/*: SkipByDesign
dev_compiler/test/options/*: SkipByDesign
[ $compiler == none && ($runtime == drt || $runtime == dartium) ]
@@ -68,6 +68,8 @@
front_end/tool/*: SkipByDesign # Only meant to run on vm
lookup_map/test/version_check_test: SkipByDesign # Only meant to run in vm.
typed_data/test/typed_buffers_test/01: Fail # Not supporting Int64List, Uint64List.
+front_end/test/incremental_kernel_generator_test: SkipByDesign # Uses dart:io
+front_end/test/incremental_resolved_ast_generator_test: SkipByDesign # Uses dart:io
front_end/test/memory_file_system_test: CompileTimeError # Issue 23773
front_end/test/dependency_grapher_test: SkipByDesign # Uses dart:io
front_end/test/physical_file_system_test: SkipByDesign # Uses dart:io
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index 9c73008..18520de 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -40,7 +40,8 @@
// isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
// snapshot otherwise it is initialized to NULL.
-extern const uint8_t* isolate_snapshot_buffer;
+extern const uint8_t* core_isolate_snapshot_buffer;
+
/**
* Global state used to control and store generation of application snapshots
@@ -51,7 +52,7 @@
* To Run the application snapshot generated above, use :
* dart <app_snapshot_filename> [<script_options>]
*/
-static bool run_app_snapshot = false;
+static bool vm_run_app_snapshot = false;
static const char* snapshot_filename = NULL;
enum SnapshotKind {
kNone,
@@ -108,6 +109,10 @@
static bool trace_loading = false;
+static char* app_script_uri = NULL;
+static const uint8_t* app_isolate_snapshot_buffer = NULL;
+
+
static Dart_Isolate main_isolate = NULL;
@@ -723,7 +728,7 @@
Log::PrintErr("Generating a snapshot requires a filename (--snapshot).\n");
return -1;
}
- if ((gen_snapshot_kind != kNone) && run_app_snapshot) {
+ if ((gen_snapshot_kind != kNone) && vm_run_app_snapshot) {
Log::PrintErr(
"Specifying an option to generate a snapshot and"
" run using a snapshot is invalid.\n");
@@ -807,7 +812,8 @@
// Returns true on success, false on failure.
-static Dart_Isolate CreateIsolateAndSetupHelper(const char* script_uri,
+static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
+ const char* script_uri,
const char* main,
const char* package_root,
const char* packages_config,
@@ -826,12 +832,29 @@
}
}
+#if defined(DART_PRECOMPILED_RUNTIME)
+ // AOT: All isolates start from the app snapshot.
+ bool isolate_run_app_snapshot = true;
+ const uint8_t* isolate_snapshot_buffer = app_isolate_snapshot_buffer;
+#else
+ // JIT: Main isolate starts from the app snapshot, if any. Other use the
+ // core libraries snapshot.
+ bool isolate_run_app_snapshot = false;
+ const uint8_t* isolate_snapshot_buffer = core_isolate_snapshot_buffer;
+ if ((app_isolate_snapshot_buffer != NULL) &&
+ (is_main_isolate || ((app_script_uri != NULL) &&
+ (strcmp(script_uri, app_script_uri) == 0)))) {
+ isolate_run_app_snapshot = true;
+ isolate_snapshot_buffer = app_isolate_snapshot_buffer;
+ }
+#endif
+
// If the script is a Kernel binary, then we will try to bootstrap from the
// script.
const uint8_t* kernel_file = NULL;
intptr_t kernel_length = -1;
const bool is_kernel =
- !run_app_snapshot &&
+ !isolate_run_app_snapshot &&
TryReadKernel(script_uri, &kernel_file, &kernel_length);
void* kernel_program = NULL;
@@ -867,14 +890,14 @@
Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
Builtin::SetNativeResolver(Builtin::kIOLibrary);
}
- if (run_app_snapshot) {
+ if (isolate_run_app_snapshot) {
Dart_Handle result = Loader::ReloadNativeExtensions();
CHECK_RESULT(result);
}
if (Dart_IsServiceIsolate(isolate)) {
// If this is the service isolate, load embedder specific bits and return.
- bool skip_library_load = run_app_snapshot;
+ bool skip_library_load = isolate_run_app_snapshot;
if (!VmService::Setup(vm_service_server_ip, vm_service_server_port,
skip_library_load, vm_service_dev_mode)) {
*error = strdup(VmService::GetErrorMessage());
@@ -923,10 +946,23 @@
}
}
- if (run_app_snapshot) {
+ if (isolate_run_app_snapshot) {
result = DartUtils::SetupIOLibrary(script_uri);
CHECK_RESULT(result);
Loader::InitForSnapshot(script_uri);
+#if !defined(DART_PRECOMPILED_RUNTIME)
+ if (is_main_isolate) {
+ // Find the canonical uri of the app snapshot. We'll use this to decide if
+ // other isolates should use the app snapshot or the core snapshot.
+ const char* resolved_script_uri = NULL;
+ result = Dart_StringToCString(
+ DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri)),
+ &resolved_script_uri);
+ CHECK_RESULT(result);
+ ASSERT(app_script_uri == NULL);
+ app_script_uri = strdup(resolved_script_uri);
+ }
+#endif // !defined(DART_PRECOMPILED_RUNTIME)
} else {
// Load the specified application script into the newly created isolate.
Dart_Handle uri =
@@ -979,9 +1015,11 @@
return NULL;
}
+ bool is_main_isolate = false;
int exit_code = 0;
- return CreateIsolateAndSetupHelper(script_uri, main, package_root,
- package_config, flags, error, &exit_code);
+ return CreateIsolateAndSetupHelper(is_main_isolate, script_uri, main,
+ package_root, package_config, flags, error,
+ &exit_code);
}
@@ -1523,19 +1561,17 @@
instructions_blob_size, rodata_blob_buffer,
rodata_blob_size);
#else
- uint8_t* vm_isolate_buffer = NULL;
- intptr_t vm_isolate_size = 0;
uint8_t* isolate_buffer = NULL;
intptr_t isolate_size = 0;
- Dart_Handle result = Dart_CreateSnapshot(&vm_isolate_buffer, &vm_isolate_size,
- &isolate_buffer, &isolate_size);
+ Dart_Handle result =
+ Dart_CreateSnapshot(NULL, NULL, &isolate_buffer, &isolate_size);
if (Dart_IsError(result)) {
ErrorExit(kErrorExitCode, "%s\n", Dart_GetError(result));
}
- WriteAppSnapshot(snapshot_filename, vm_isolate_buffer, vm_isolate_size,
- isolate_buffer, isolate_size, NULL, 0, NULL, 0);
+ WriteAppSnapshot(snapshot_filename, NULL, 0, isolate_buffer, isolate_size,
+ NULL, 0, NULL, 0);
#endif // defined(TARGET_ARCH_X64)
}
@@ -1572,11 +1608,12 @@
// Call CreateIsolateAndSetup which creates an isolate and loads up
// the specified application script.
char* error = NULL;
+ bool is_main_isolate = true;
int exit_code = 0;
char* isolate_name = BuildIsolateName(script_name, "main");
Dart_Isolate isolate = CreateIsolateAndSetupHelper(
- script_name, "main", commandline_package_root, commandline_packages_file,
- NULL, &error, &exit_code);
+ is_main_isolate, script_name, "main", commandline_package_root,
+ commandline_packages_file, NULL, &error, &exit_code);
if (isolate == NULL) {
delete[] isolate_name;
if (exit_code == kRestartRequestExitCode) {
@@ -1902,16 +1939,15 @@
const uint8_t* instructions_snapshot = NULL;
const uint8_t* data_snapshot = NULL;
-
if (ReadAppSnapshot(script_name, &vm_isolate_snapshot_buffer,
- &isolate_snapshot_buffer, &instructions_snapshot,
+ &app_isolate_snapshot_buffer, &instructions_snapshot,
&data_snapshot)) {
- run_app_snapshot = true;
+ vm_run_app_snapshot = true;
}
#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
// Constant true if PRODUCT or DART_PRECOMPILED_RUNTIME.
- if ((gen_snapshot_kind != kNone) || run_app_snapshot) {
+ if ((gen_snapshot_kind != kNone) || vm_run_app_snapshot) {
vm_options.AddArgument("--load_deferred_eagerly");
}
#endif
@@ -1983,6 +2019,8 @@
}
EventHandler::Stop();
+ free(app_script_uri);
+
// Free copied argument strings if converted.
if (argv_converted) {
for (int i = 0; i < argc; i++) {
diff --git a/runtime/bin/snapshot_empty.cc b/runtime/bin/snapshot_empty.cc
index bab9212..f2eef2f 100644
--- a/runtime/bin/snapshot_empty.cc
+++ b/runtime/bin/snapshot_empty.cc
@@ -17,7 +17,7 @@
namespace bin {
const uint8_t* vm_isolate_snapshot_buffer = NULL;
-const uint8_t* isolate_snapshot_buffer = NULL;
+const uint8_t* core_isolate_snapshot_buffer = NULL;
} // namespace bin
} // namespace dart
diff --git a/runtime/bin/snapshot_in.cc b/runtime/bin/snapshot_in.cc
index 1f63a86..861eeb4 100644
--- a/runtime/bin/snapshot_in.cc
+++ b/runtime/bin/snapshot_in.cc
@@ -32,10 +32,10 @@
// generated snapshot binary file for a regular dart isolate.
// This string forms the content of a regular dart isolate snapshot which is
// loaded into an isolate when it is created.
-static const uint8_t isolate_snapshot_buffer_[] = {
+static const uint8_t core_isolate_snapshot_buffer_[] = {
%s
};
-const uint8_t* isolate_snapshot_buffer = isolate_snapshot_buffer_;
+const uint8_t* core_isolate_snapshot_buffer = core_isolate_snapshot_buffer_;
} // namespace bin
} // namespace dart
diff --git a/runtime/lib/isolate.cc b/runtime/lib/isolate.cc
index 4eff307..337fec1 100644
--- a/runtime/lib/isolate.cc
+++ b/runtime/lib/isolate.cc
@@ -340,10 +340,11 @@
GET_NATIVE_ARGUMENT(String, packageRoot, arguments->NativeArgAt(10));
GET_NATIVE_ARGUMENT(String, packageConfig, arguments->NativeArgAt(11));
- if (Snapshot::IncludesCode(Dart::snapshot_kind())) {
+ if (Dart::snapshot_kind() == Snapshot::kAppAOT) {
const Array& args = Array::Handle(Array::New(1));
- args.SetAt(0, String::Handle(String::New(
- "Isolate.spawnUri not supported under precompilation")));
+ args.SetAt(
+ 0, String::Handle(String::New(
+ "Isolate.spawnUri not supported when using AOT compilation")));
Exceptions::ThrowByType(Exceptions::kUnsupported, args);
UNREACHABLE();
}
diff --git a/runtime/lib/mirrors.cc b/runtime/lib/mirrors.cc
index a64dbed..8a4078a 100644
--- a/runtime/lib/mirrors.cc
+++ b/runtime/lib/mirrors.cc
@@ -11,6 +11,7 @@
#include "vm/dart_entry.h"
#include "vm/exceptions.h"
#include "vm/flags.h"
+#include "vm/kernel_to_il.h"
#include "vm/object_store.h"
#include "vm/parser.h"
#include "vm/port.h"
@@ -150,8 +151,15 @@
// * The default value of a parameter.
// * Whether a parameters has been declared as final.
// * Any metadata associated with the parameter.
- const Object& result =
- Object::Handle(Parser::ParseFunctionParameters(func));
+ Object& result = Object::Handle();
+
+ kernel::TreeNode* kernel_node =
+ reinterpret_cast<kernel::TreeNode*>(func.kernel_function());
+ if (kernel_node != NULL) {
+ result = kernel::BuildParameterDescriptor(kernel_node);
+ } else {
+ result = Parser::ParseFunctionParameters(func);
+ }
if (result.IsError()) {
Exceptions::PropagateError(Error::Cast(result));
UNREACHABLE();
diff --git a/runtime/observatory/lib/src/elements/css/shared.css b/runtime/observatory/lib/src/elements/css/shared.css
index 4e6e480..556d997 100644
--- a/runtime/observatory/lib/src/elements/css/shared.css
+++ b/runtime/observatory/lib/src/elements/css/shared.css
@@ -1435,6 +1435,17 @@
isolate-shared-summary {
display: block;
}
+
+.isolate-ref-container {
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+
+.isolate-state-container {
+ display: inline-block;
+ min-width: 18ex;
+}
+
isolate-shared-summary > .summary {
height: 300px;
position: relative;
diff --git a/runtime/observatory/lib/src/elements/isolate/summary.dart b/runtime/observatory/lib/src/elements/isolate/summary.dart
index 82d768a..0943996 100644
--- a/runtime/observatory/lib/src/elements/isolate/summary.dart
+++ b/runtime/observatory/lib/src/elements/isolate/summary.dart
@@ -79,11 +79,13 @@
..classes = ['flex-row']
..children = [
new DivElement()
+ ..classes = ['isolate-ref-container']
..children = [
new IsolateRefElement(_isolate, _events, queue: _r.queue)
],
new DivElement()..style.flex = '1',
new DivElement()
+ ..classes = ['flex-row', 'isolate-state-container']
..children = [
new IsolateRunStateElement(_isolate, _events, queue: _r.queue),
new IsolateLocationElement(_isolate, _events, _scripts,
diff --git a/runtime/observatory/tests/service/service.status b/runtime/observatory/tests/service/service.status
index 7c243e7..cee1a67 100644
--- a/runtime/observatory/tests/service/service.status
+++ b/runtime/observatory/tests/service/service.status
@@ -56,7 +56,6 @@
address_mapper_test: CompileTimeError # Issue 27806
capture_stdio_test: CompileTimeError # Issue 27806
complex_reload_test: RuntimeError # Issue 27806
-dev_fs_spawn_test: RuntimeError # Issue 27806
developer_extension_test: RuntimeError # Issue 27806
evaluate_activation_test/instance: RuntimeError # Issue 27806
evaluate_activation_test/scope: RuntimeError # Issue 27806
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index b845d01..e946179 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -30,24 +30,6 @@
dart/data_uri_import_test/none: SkipByDesign
-[ $mode == debug && $arch != ia32 && $system != windows ]
-cc/Profiler_ArrayAllocation: Fail # 28304
-cc/Profiler_BasicSourcePosition: Fail # 28304
-cc/Profiler_BasicSourcePositionOptimized: Fail, Crash # 28304, # 28282
-cc/Profiler_BinaryOperatorSourcePosition: Fail # 28304
-cc/Profiler_BinaryOperatorSourcePositionOptimized: Fail # 28304
-cc/Profiler_ChainedSamples: Fail # 28304
-cc/Profiler_ClosureAllocation: Fail # 28304
-cc/Profiler_CodeTicks: Fail # 28304
-cc/Profiler_ContextAllocation: Fail # 28304
-cc/Profiler_FunctionInline: Fail # 28304
-cc/Profiler_FunctionTicks: Fail # 28304
-cc/Profiler_SourcePosition: Fail # 28304
-cc/Profiler_SourcePositionOptimized: Fail # 28304
-cc/Profiler_ToggleRecordAllocation: Fail # 28304
-cc/Profiler_TrivialRecordAllocation: Fail # 28304
-cc/Profiler_TypedArrayAllocation: Fail # 28304
-
[ $mode == debug ]
# This is a benchmark that is not informative in debug mode.
cc/CorelibIsolateStartup: Skip
@@ -168,18 +150,6 @@
cc/CodeImmutability: Fail,OK # Address Sanitizer turns a crash into a failure.
[ $builder_tag == asan && $arch == x64 ]
-cc/Service_Profile: Fail # Issue 28342
-cc/Service_PersistentHandles: Fail # Issue 28342
-cc/Service_EmbedderIsolateHandler: Fail # Issue 28342
-cc/Service_LocalVarDescriptors: Fail # Issue 28342
-cc/Service_Code: Fail # Issue 28342
-cc/Service_EmbedderRootHandler: Fail # Issue 28342
-cc/Service_TokenStream: Fail # Issue 28342
-cc/Service_PcDescriptors: Fail # Issue 28342
-cc/Service_Address: Fail # Issue 28342
-
-cc/EmbeddedScript: Fail # Issue 28345
-
cc/Log_Basic: Fail # Issue 28347
cc/Log_Block: Fail # Issue 28347
cc/Log_Macro: Fail # Issue 28347
@@ -256,9 +226,9 @@
# StackTraces in precompilation omit inlined frames.
dart/inline_stack_frame_test: Pass, RuntimeError
dart/optimized_stacktrace_test: Pass, RuntimeError
+dart/data_uri_spawn_test: SkipByDesign # Isolate.spawnUri
[ $compiler == app_jit || $compiler == precompiler ]
-dart/data_uri_spawn_test: SkipByDesign # Isolate.spawnUri
dart/optimized_stacktrace_test: SkipByDesign # Requires line numbers
[ $runtime == vm && $mode == product ]
diff --git a/runtime/vm/benchmark_test.h b/runtime/vm/benchmark_test.h
index b51c64c..c304326 100644
--- a/runtime/vm/benchmark_test.h
+++ b/runtime/vm/benchmark_test.h
@@ -26,7 +26,7 @@
// isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
// snapshot otherwise it is initialized to NULL.
-extern const uint8_t* isolate_snapshot_buffer;
+extern const uint8_t* core_isolate_snapshot_buffer;
}
// The BENCHMARK macros are used for benchmarking a specific functionality
@@ -110,7 +110,7 @@
class BenchmarkIsolateScope {
public:
explicit BenchmarkIsolateScope(Benchmark* benchmark) : benchmark_(benchmark) {
- benchmark_->CreateIsolate(bin::isolate_snapshot_buffer);
+ benchmark_->CreateIsolate(bin::core_isolate_snapshot_buffer);
Dart_EnterScope(); // Create a Dart API scope for unit benchmarks.
}
~BenchmarkIsolateScope() {
diff --git a/runtime/vm/branch_optimizer.cc b/runtime/vm/branch_optimizer.cc
index 62fdb47..f68bbca 100644
--- a/runtime/vm/branch_optimizer.cc
+++ b/runtime/vm/branch_optimizer.cc
@@ -83,7 +83,6 @@
ComparisonInstr* new_comparison =
comparison->CopyWithNewOperands(new_left, new_right);
BranchInstr* new_branch = new (zone) BranchInstr(new_comparison);
- new_branch->set_is_checked(branch->is_checked());
return new_branch;
}
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index be24a41..c319f1f 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -516,6 +516,13 @@
}
ASSERT(!type_class.IsTypedefClass() ||
(type.signature() != Function::null()));
+
+ // Replace FutureOr<T> type of async library with dynamic.
+ if ((type_class.library() == Library::AsyncLibrary()) &&
+ (type_class.Name() == Symbols::FutureOr().raw())) {
+ Type::Cast(type).set_type_class(Class::Handle(Object::dynamic_class()));
+ type.set_arguments(Object::null_type_arguments());
+ }
}
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index 22e2391..50c30ce 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -1581,7 +1581,9 @@
isolate_snapshot_buffer, ApiReallocate,
NULL /* instructions_writer */);
writer.WriteFullSnapshot();
- *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
+ if (vm_isolate_snapshot_buffer != NULL) {
+ *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
+ }
*isolate_snapshot_size = writer.IsolateSnapshotSize();
return Api::Success();
}
diff --git a/runtime/vm/dart_api_impl_test.cc b/runtime/vm/dart_api_impl_test.cc
index 6e1675a..037fb4b 100644
--- a/runtime/vm/dart_api_impl_test.cc
+++ b/runtime/vm/dart_api_impl_test.cc
@@ -3497,7 +3497,7 @@
intptr_t mydata = 12345;
char* err;
Dart_Isolate isolate =
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL,
reinterpret_cast<void*>(mydata), &err);
EXPECT(isolate != NULL);
EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateData()));
@@ -3528,7 +3528,7 @@
char* err;
Dart_Isolate isolate = Dart_CreateIsolate(
- NULL, NULL, bin::isolate_snapshot_buffer, &api_flags, NULL, &err);
+ NULL, NULL, bin::core_isolate_snapshot_buffer, &api_flags, NULL, &err);
if (isolate == NULL) {
OS::Print("Creation of isolate failed '%s'\n", err);
free(err);
@@ -7573,7 +7573,7 @@
MonitorLocker ml(sync);
char* error = NULL;
shared_isolate = Dart_CreateIsolate(
- NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, &error);
+ NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL, &error);
EXPECT(shared_isolate != NULL);
Dart_EnterScope();
Dart_Handle url = NewString(TestCase::url());
@@ -7624,7 +7624,7 @@
// Create an isolate.
char* err;
Dart_Isolate isolate = Dart_CreateIsolate(
- NULL, NULL, bin::isolate_snapshot_buffer, NULL, my_data, &err);
+ NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, my_data, &err);
if (isolate == NULL) {
OS::Print("Creation of isolate failed '%s'\n", err);
free(err);
@@ -7673,7 +7673,7 @@
// Create an isolate.
char* err;
Dart_Isolate isolate = Dart_CreateIsolate(
- NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, &err);
+ NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL, &err);
if (isolate == NULL) {
OS::Print("Creation of isolate failed '%s'\n", err);
free(err);
diff --git a/runtime/vm/dart_entry.cc b/runtime/vm/dart_entry.cc
index 6cd7b4f..195781c 100644
--- a/runtime/vm/dart_entry.cc
+++ b/runtime/vm/dart_entry.cc
@@ -32,7 +32,7 @@
class ScopedIsolateStackLimits : public ValueObject {
public:
- explicit ScopedIsolateStackLimits(Thread* thread)
+ explicit ScopedIsolateStackLimits(Thread* thread, uword current_sp)
: thread_(thread), saved_stack_limit_(0) {
ASSERT(thread != NULL);
// Set the thread's stack_base based on the current
@@ -41,7 +41,6 @@
// grows from high to low addresses).
OSThread* os_thread = thread->os_thread();
ASSERT(os_thread != NULL);
- uword current_sp = Thread::GetCurrentStackPointer();
if (current_sp > os_thread->stack_base()) {
os_thread->set_stack_base(current_sp);
}
@@ -87,13 +86,15 @@
RawObject* DartEntry::InvokeFunction(const Function& function,
const Array& arguments,
- const Array& arguments_descriptor) {
+ const Array& arguments_descriptor,
+ uword current_sp) {
// Get the entrypoint corresponding to the function specified, this
// will result in a compilation of the function if it is not already
// compiled.
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
ASSERT(thread->IsMutatorThread());
+ ScopedIsolateStackLimits stack_limit(thread, current_sp);
if (!function.HasCode()) {
const Error& error =
Error::Handle(zone, Compiler::CompileFunction(thread, function));
@@ -109,7 +110,6 @@
const Code& code = Code::Handle(zone, function.CurrentCode());
ASSERT(!code.IsNull());
ASSERT(thread->no_callback_scope_depth() == 0);
- ScopedIsolateStackLimits stack_limit(thread);
SuspendLongJumpScope suspend_long_jump_scope(thread);
TransitionToGenerated transition(thread);
#if defined(TARGET_ARCH_DBC)
diff --git a/runtime/vm/dart_entry.h b/runtime/vm/dart_entry.h
index 2a52eec..c2e8f92 100644
--- a/runtime/vm/dart_entry.h
+++ b/runtime/vm/dart_entry.h
@@ -126,9 +126,11 @@
// Invokes the specified instance, static, or closure function.
// On success, returns a RawInstance. On failure, a RawError.
- static RawObject* InvokeFunction(const Function& function,
- const Array& arguments,
- const Array& arguments_descriptor);
+ static RawObject* InvokeFunction(
+ const Function& function,
+ const Array& arguments,
+ const Array& arguments_descriptor,
+ uword current_sp = Thread::GetCurrentStackPointer());
// Invokes the closure object given as the first argument.
// On success, returns a RawInstance. On failure, a RawError.
diff --git a/runtime/vm/flow_graph_builder.cc b/runtime/vm/flow_graph_builder.cc
index 265c308..bf13562 100644
--- a/runtime/vm/flow_graph_builder.cc
+++ b/runtime/vm/flow_graph_builder.cc
@@ -991,23 +991,8 @@
}
-void TestGraphVisitor::MergeBranchWithComparison(ComparisonInstr* comp) {
- BranchInstr* branch;
- if (Token::IsStrictEqualityOperator(comp->kind())) {
- ASSERT(comp->IsStrictCompare());
- branch = new (Z) BranchInstr(comp);
- } else if (Token::IsEqualityOperator(comp->kind()) &&
- (comp->left()->BindsToConstantNull() ||
- comp->right()->BindsToConstantNull())) {
- branch = new (Z) BranchInstr(new (Z) StrictCompareInstr(
- comp->token_pos(),
- (comp->kind() == Token::kEQ) ? Token::kEQ_STRICT : Token::kNE_STRICT,
- comp->left(), comp->right(),
- false)); // No number check.
- } else {
- branch = new (Z) BranchInstr(comp);
- branch->set_is_checked(Isolate::Current()->type_checks());
- }
+void TestGraphVisitor::MergeBranchWithStrictCompare(StrictCompareInstr* comp) {
+ BranchInstr* branch = new (Z) BranchInstr(comp);
AddInstruction(branch);
CloseFragment();
true_successor_addresses_.Add(branch->true_successor_address());
@@ -1030,9 +1015,9 @@
void TestGraphVisitor::ReturnDefinition(Definition* definition) {
- ComparisonInstr* comp = definition->AsComparison();
+ StrictCompareInstr* comp = definition->AsStrictCompare();
if (comp != NULL) {
- MergeBranchWithComparison(comp);
+ MergeBranchWithStrictCompare(comp);
return;
}
if (!Isolate::Current()->type_checks()) {
diff --git a/runtime/vm/flow_graph_builder.h b/runtime/vm/flow_graph_builder.h
index 8db4aae..98819bc 100644
--- a/runtime/vm/flow_graph_builder.h
+++ b/runtime/vm/flow_graph_builder.h
@@ -544,7 +544,7 @@
// or adds the definition to the graph and returns a use of its value.
virtual void ReturnDefinition(Definition* definition);
- void MergeBranchWithComparison(ComparisonInstr* comp);
+ void MergeBranchWithStrictCompare(StrictCompareInstr* comp);
void MergeBranchWithNegate(BooleanNegateInstr* comp);
BlockEntryInstr* CreateSuccessorFor(
diff --git a/runtime/vm/flow_graph_type_propagator.cc b/runtime/vm/flow_graph_type_propagator.cc
index 928c533..782ea05 100644
--- a/runtime/vm/flow_graph_type_propagator.cc
+++ b/runtime/vm/flow_graph_type_propagator.cc
@@ -98,18 +98,6 @@
if (use_defn != NULL) {
AddToWorklist(use_defn);
}
-
- // If the value flow into a branch recompute type constrained by the
- // branch (if any). This ensures that correct non-nullable type will
- // flow downwards from the branch on the comparison with the null
- // constant.
- BranchInstr* branch = instr->AsBranch();
- if (branch != NULL) {
- ConstrainedCompileType* constrained_type = branch->constrained_type();
- if (constrained_type != NULL) {
- constrained_type->Update();
- }
- }
}
}
}
@@ -199,19 +187,6 @@
}
-ConstrainedCompileType* FlowGraphTypePropagator::MarkNonNullable(
- Definition* def) {
- CompileType* current = TypeOf(def);
- if (current->is_nullable() && (current->ToCid() != kNullCid)) {
- ConstrainedCompileType* constrained_type =
- new NotNullConstrainedCompileType(current);
- SetTypeOf(def, constrained_type->ToCompileType());
- return constrained_type;
- }
- return NULL;
-}
-
-
void FlowGraphTypePropagator::VisitValue(Value* value) {
CompileType* type = TypeOf(value->definition());
value->SetReachingType(type);
diff --git a/runtime/vm/flow_graph_type_propagator.h b/runtime/vm/flow_graph_type_propagator.h
index 0e23e5e..77be776 100644
--- a/runtime/vm/flow_graph_type_propagator.h
+++ b/runtime/vm/flow_graph_type_propagator.h
@@ -46,8 +46,6 @@
// Mark definition as having given class id in all dominated instructions.
void SetCid(Definition* value, intptr_t cid);
- ConstrainedCompileType* MarkNonNullable(Definition* value);
-
void AddToWorklist(Definition* defn);
Definition* RemoveLastFromWorklist();
diff --git a/runtime/vm/intermediate_language.cc b/runtime/vm/intermediate_language.cc
index 78675d9..007cb36 100644
--- a/runtime/vm/intermediate_language.cc
+++ b/runtime/vm/intermediate_language.cc
@@ -3611,7 +3611,7 @@
pieces.SetAt(store_index, Bool::Cast(obj).value() ? Symbols::True()
: Symbols::False());
} else if (obj.IsNull()) {
- pieces.SetAt(store_index, Symbols::Null());
+ pieces.SetAt(store_index, Symbols::null());
} else {
return this;
}
diff --git a/runtime/vm/intermediate_language.h b/runtime/vm/intermediate_language.h
index 8b843c9..82507f1 100644
--- a/runtime/vm/intermediate_language.h
+++ b/runtime/vm/intermediate_language.h
@@ -193,37 +193,6 @@
};
-// ConstrainedCompileType represents a compile type that is computed from
-// another compile type.
-class ConstrainedCompileType : public ZoneCompileType {
- public:
- virtual ~ConstrainedCompileType() {}
-
- // Recompute compile type.
- virtual void Update() = 0;
-
- protected:
- explicit ConstrainedCompileType(const CompileType& type)
- : ZoneCompileType(type) {}
-};
-
-
-// NotNullConstrainedCompileType represents not-null constraint applied to
-// the source compile type. Result is non-nullable version of the incoming
-// compile type. It is used to represent compile type propagated downwards
-// from strict comparison with the null constant.
-class NotNullConstrainedCompileType : public ConstrainedCompileType {
- public:
- explicit NotNullConstrainedCompileType(CompileType* source)
- : ConstrainedCompileType(source->CopyNonNullable()), source_(source) {}
-
- virtual void Update() { type_ = source_->CopyNonNullable(); }
-
- private:
- CompileType* source_;
-};
-
-
class EffectSet : public ValueObject {
public:
enum Effects {
@@ -2355,8 +2324,6 @@
explicit BranchInstr(ComparisonInstr* comparison)
: Instruction(Thread::Current()->GetNextDeoptId()),
comparison_(comparison),
- is_checked_(false),
- constrained_type_(NULL),
constant_target_(NULL) {
ASSERT(comparison->env() == NULL);
for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
@@ -2376,11 +2343,7 @@
virtual TokenPosition token_pos() const { return comparison_->token_pos(); }
- virtual bool CanDeoptimize() const {
- // Branches need a deoptimization info in checked mode if they
- // can throw a type check error.
- return comparison()->CanDeoptimize() || is_checked();
- }
+ virtual bool CanDeoptimize() const { return comparison()->CanDeoptimize(); }
virtual bool CanBecomeDeoptimizationTarget() const {
return comparison()->CanBecomeDeoptimizationTarget();
@@ -2391,9 +2354,6 @@
ComparisonInstr* comparison() const { return comparison_; }
void SetComparison(ComparisonInstr* comp);
- void set_is_checked(bool value) { is_checked_ = value; }
- bool is_checked() const { return is_checked_; }
-
virtual intptr_t DeoptimizationTarget() const {
return comparison()->DeoptimizationTarget();
}
@@ -2404,16 +2364,6 @@
virtual Instruction* Canonicalize(FlowGraph* flow_graph);
- // Set compile type constrained by the comparison of this branch.
- // FlowGraphPropagator propagates it downwards into either true or false
- // successor.
- void set_constrained_type(ConstrainedCompileType* type) {
- constrained_type_ = type;
- }
-
- // Return compile type constrained by the comparison of this branch.
- ConstrainedCompileType* constrained_type() const { return constrained_type_; }
-
void set_constant_target(TargetEntryInstr* target) {
ASSERT(target == true_successor() || target == false_successor());
constant_target_ = target;
@@ -2443,8 +2393,6 @@
TargetEntryInstr* true_successor_;
TargetEntryInstr* false_successor_;
ComparisonInstr* comparison_;
- bool is_checked_;
- ConstrainedCompileType* constrained_type_;
TargetEntryInstr* constant_target_;
DISALLOW_COPY_AND_ASSIGN(BranchInstr);
diff --git a/runtime/vm/isolate_test.cc b/runtime/vm/isolate_test.cc
index 5e71ed7..a7eab10 100644
--- a/runtime/vm/isolate_test.cc
+++ b/runtime/vm/isolate_test.cc
@@ -15,7 +15,7 @@
UNIT_TEST_CASE(IsolateCurrent) {
Dart_Isolate isolate = Dart_CreateIsolate(
- NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL, NULL);
+ NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL, NULL);
EXPECT_EQ(isolate, Dart_CurrentIsolate());
Dart_ShutdownIsolate();
EXPECT_EQ(reinterpret_cast<Dart_Isolate>(NULL), Dart_CurrentIsolate());
diff --git a/runtime/vm/kernel_reader.cc b/runtime/vm/kernel_reader.cc
index 11daaa3..f0be6f6 100644
--- a/runtime/vm/kernel_reader.cc
+++ b/runtime/vm/kernel_reader.cc
@@ -200,7 +200,7 @@
// Load all classes.
for (intptr_t i = 0; i < kernel_library->classes().length(); i++) {
Class* kernel_klass = kernel_library->classes()[i];
- classes.Add(ReadClass(library, kernel_klass), Heap::kOld);
+ classes.Add(ReadClass(library, toplevel_class, kernel_klass), Heap::kOld);
}
classes.Add(toplevel_class, Heap::kOld);
@@ -281,6 +281,7 @@
dart::Class& KernelReader::ReadClass(const dart::Library& library,
+ const dart::Class& toplevel_class,
Class* kernel_klass) {
// This will trigger a call to [ReadPreliminaryClass] if not already done.
dart::Class& klass = LookupClass(kernel_klass);
@@ -334,6 +335,11 @@
kernel_constructor->function(),
true, // is_method
false); // is_closure
+
+ if (FLAG_enable_mirrors) {
+ library.AddFunctionMetadata(function, TokenPosition::kNoSource,
+ kernel_constructor);
+ }
}
for (intptr_t i = 0; i < kernel_klass->procedures().length(); i++) {
@@ -346,6 +352,11 @@
klass.set_is_marked_for_parsing();
}
+ if (FLAG_enable_mirrors) {
+ library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
+ kernel_klass);
+ }
+
return klass;
}
@@ -422,6 +433,10 @@
H.DartProcedureName(kernel_procedure)))
.IsNull());
}
+ if (FLAG_enable_mirrors) {
+ library.AddFunctionMetadata(function, TokenPosition::kNoSource,
+ kernel_procedure);
+ }
}
const Object& KernelReader::ClassForScriptAt(const dart::Class& klass,
diff --git a/runtime/vm/kernel_reader.h b/runtime/vm/kernel_reader.h
index a483d38..3d20f90 100644
--- a/runtime/vm/kernel_reader.h
+++ b/runtime/vm/kernel_reader.h
@@ -70,7 +70,9 @@
friend class BuildingTranslationHelper;
void ReadPreliminaryClass(dart::Class* klass, Class* kernel_klass);
- dart::Class& ReadClass(const dart::Library& library, Class* kernel_klass);
+ dart::Class& ReadClass(const dart::Library& library,
+ const dart::Class& toplevel_class,
+ Class* kernel_klass);
void ReadProcedure(const dart::Library& library,
const dart::Class& owner,
Procedure* procedure,
diff --git a/runtime/vm/kernel_to_il.cc b/runtime/vm/kernel_to_il.cc
index 22299a8..1596243 100644
--- a/runtime/vm/kernel_to_il.cc
+++ b/runtime/vm/kernel_to_il.cc
@@ -756,7 +756,8 @@
outer_(builder->breakable_block_),
destination_(NULL),
outer_finally_(builder->try_finally_block_),
- context_depth_(builder->context_depth_) {
+ context_depth_(builder->context_depth_),
+ try_index_(builder->CurrentTryIndex()) {
builder_->breakable_block_ = this;
}
~BreakableBlock() { builder_->breakable_block_ = outer_; }
@@ -781,7 +782,7 @@
private:
JoinEntryInstr* EnsureDestination() {
if (destination_ == NULL) {
- destination_ = builder_->BuildJoinEntry();
+ destination_ = builder_->BuildJoinEntry(try_index_);
}
return destination_;
}
@@ -792,6 +793,7 @@
JoinEntryInstr* destination_;
TryFinallyBlock* outer_finally_;
intptr_t context_depth_;
+ intptr_t try_index_;
};
@@ -802,7 +804,8 @@
outer_(builder->switch_block_),
outer_finally_(builder->try_finally_block_),
switch_statement_(switch_stmt),
- context_depth_(builder->context_depth_) {
+ context_depth_(builder->context_depth_),
+ try_index_(builder->CurrentTryIndex()) {
builder_->switch_block_ = this;
}
~SwitchBlock() { builder_->switch_block_ = outer_; }
@@ -838,7 +841,7 @@
JoinEntryInstr* EnsureDestination(SwitchCase* switch_case) {
JoinEntryInstr* cached_inst = destinations_.Lookup(switch_case);
if (cached_inst == NULL) {
- JoinEntryInstr* inst = builder_->BuildJoinEntry();
+ JoinEntryInstr* inst = builder_->BuildJoinEntry(try_index_);
destinations_.Insert(switch_case, inst);
return inst;
}
@@ -867,6 +870,7 @@
TryFinallyBlock* outer_finally_;
SwitchStatement* switch_statement_;
intptr_t context_depth_;
+ intptr_t try_index_;
};
@@ -1319,10 +1323,11 @@
zone_(zone),
translation_helper_(*h),
type_translator_(*type_translator),
- script_(dart::Script::Handle(
+ script_(Script::Handle(
zone,
- builder_->parsed_function_->function().script())),
- result_(dart::Instance::Handle(zone)) {}
+ builder == NULL ? Script::null()
+ : builder_->parsed_function_->function().script())),
+ result_(Instance::Handle(zone)) {}
Instance& ConstantEvaluator::EvaluateExpression(Expression* expression) {
@@ -1468,6 +1473,8 @@
bool ConstantEvaluator::GetCachedConstant(TreeNode* node, Instance* value) {
+ if (builder_ == NULL) return false;
+
const Function& function = builder_->parsed_function_->function();
if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
// Don't cache constants in initializer expressions. They get
@@ -1497,6 +1504,8 @@
const Instance& value) {
ASSERT(Thread::Current()->IsMutatorThread());
+ if (builder_ == NULL) return;
+
const Function& function = builder_->parsed_function_->function();
if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
// Don't cache constants in initializer expressions. They get
@@ -2597,6 +2606,7 @@
Fragment FlowGraphBuilder::StoreInstanceField(
const dart::Field& field,
+ bool is_initialization_store,
StoreBarrierType emit_store_barrier) {
Value* value = Pop();
if (value->BindsToConstant()) {
@@ -2605,11 +2615,14 @@
StoreInstanceFieldInstr* store = new (Z)
StoreInstanceFieldInstr(MayCloneField(Z, field), Pop(), value,
emit_store_barrier, TokenPosition::kNoSource);
+ store->set_is_initialization(is_initialization_store);
return Fragment(store);
}
-Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(const dart::Field& field) {
+Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(
+ const dart::Field& field,
+ bool is_initialization_store) {
Fragment instructions;
const dart::Field& field_clone = MayCloneField(Z, field);
if (FLAG_use_field_guards) {
@@ -2619,7 +2632,7 @@
instructions += LoadLocal(store_expression);
instructions += GuardFieldLength(field_clone, H.thread()->GetNextDeoptId());
}
- instructions += StoreInstanceField(field_clone);
+ instructions += StoreInstanceField(field_clone, is_initialization_store);
return instructions;
}
@@ -2691,7 +2704,7 @@
instructions += AllocateObject(klass, 0);
LocalVariable* instance = MakeTemporary();
- // Call _AssertionError._create constructor.
+ // Call _TypeError._create constructor.
instructions += LoadLocal(instance);
instructions += PushArgument(); // this
@@ -3351,7 +3364,7 @@
if (is_method) {
body += LoadLocal(scopes_->this_variable);
body += LoadLocal(setter_value);
- body += StoreInstanceFieldGuarded(field);
+ body += StoreInstanceFieldGuarded(field, false);
} else {
body += LoadLocal(setter_value);
body += StoreStaticField(field);
@@ -3755,6 +3768,11 @@
}
+JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
+ return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
+}
+
+
JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
}
@@ -3779,7 +3797,7 @@
EnterScope(kernel_field);
instructions += LoadLocal(scopes_->this_variable);
instructions += TranslateExpression(init);
- instructions += StoreInstanceFieldGuarded(field);
+ instructions += StoreInstanceFieldGuarded(field, true);
ExitScope(kernel_field);
}
}
@@ -3799,7 +3817,7 @@
instructions += LoadLocal(scopes_->this_variable);
instructions += TranslateExpression(init->value());
- instructions += StoreInstanceFieldGuarded(field);
+ instructions += StoreInstanceFieldGuarded(field, true);
} else if (initializer->IsSuperInitializer()) {
SuperInitializer* init = SuperInitializer::Cast(initializer);
@@ -5368,7 +5386,7 @@
body_fragment += AllocateObject(klass, 0);
LocalVariable* instance = MakeTemporary();
- // Call _AssertionError._create constructor.
+ // Call _FallThroughError._create constructor.
body_fragment += LoadLocal(instance);
body_fragment += PushArgument(); // this
@@ -5559,7 +5577,7 @@
node->message() != NULL
? TranslateExpression(node->message())
: Constant(H.DartString("<no message>", Heap::kOld));
- otherwise_fragment += PushArgument(); // message
+ otherwise_fragment += PushArgument(); // failedAssertion
otherwise_fragment += Constant(url);
otherwise_fragment += PushArgument(); // url
@@ -5570,7 +5588,10 @@
otherwise_fragment += IntConstant(0);
otherwise_fragment += PushArgument(); // column
- otherwise_fragment += StaticCall(TokenPosition::kNoSource, constructor, 5);
+ otherwise_fragment += Constant(H.DartString("<no message>", Heap::kOld));
+ otherwise_fragment += PushArgument(); // message
+
+ otherwise_fragment += StaticCall(TokenPosition::kNoSource, constructor, 6);
otherwise_fragment += Drop();
// Throw _AssertionError exception.
@@ -5917,6 +5938,116 @@
}
+RawObject* EvaluateMetadata(TreeNode* const kernel_node) {
+ LongJumpScope jump;
+ if (setjmp(*jump.Set()) == 0) {
+ Thread* thread = Thread::Current();
+ Zone* zone_ = thread->zone();
+
+ List<Expression>* metadata_expressions = NULL;
+ if (kernel_node->IsClass()) {
+ metadata_expressions = &Class::Cast(kernel_node)->annotations();
+ } else if (kernel_node->IsProcedure()) {
+ metadata_expressions = &Procedure::Cast(kernel_node)->annotations();
+ } else if (kernel_node->IsField()) {
+ metadata_expressions = &Field::Cast(kernel_node)->annotations();
+ } else if (kernel_node->IsConstructor()) {
+ metadata_expressions = &Constructor::Cast(kernel_node)->annotations();
+ } else {
+ FATAL1("No support for metadata on this type of kernel node %p\n",
+ kernel_node);
+ }
+
+ TranslationHelper translation_helper(thread);
+ DartTypeTranslator type_translator(&translation_helper, NULL, true);
+ ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
+ &translation_helper, &type_translator);
+
+ const Array& metadata_values =
+ Array::Handle(Z, Array::New(metadata_expressions->length()));
+
+ for (intptr_t i = 0; i < metadata_expressions->length(); i++) {
+ const Instance& value =
+ constant_evaluator.EvaluateExpression((*metadata_expressions)[i]);
+ metadata_values.SetAt(i, value);
+ }
+
+ return metadata_values.raw();
+ } else {
+ Thread* thread = Thread::Current();
+ Error& error = Error::Handle();
+ error = thread->sticky_error();
+ thread->clear_sticky_error();
+ return error.raw();
+ }
+}
+
+
+RawObject* BuildParameterDescriptor(TreeNode* const kernel_node) {
+ LongJumpScope jump;
+ if (setjmp(*jump.Set()) == 0) {
+ FunctionNode* function_node = NULL;
+
+ if (kernel_node->IsProcedure()) {
+ function_node = Procedure::Cast(kernel_node)->function();
+ } else if (kernel_node->IsConstructor()) {
+ function_node = Constructor::Cast(kernel_node)->function();
+ } else if (kernel_node->IsFunctionNode()) {
+ function_node = FunctionNode::Cast(kernel_node);
+ } else {
+ UNIMPLEMENTED();
+ return NULL;
+ }
+
+ Thread* thread = Thread::Current();
+ Zone* zone_ = thread->zone();
+ TranslationHelper translation_helper(thread);
+ DartTypeTranslator type_translator(&translation_helper, NULL, true);
+ ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
+ &translation_helper, &type_translator);
+
+
+ intptr_t param_count = function_node->positional_parameters().length() +
+ function_node->named_parameters().length();
+ const Array& param_descriptor = Array::Handle(
+ Array::New(param_count * Parser::kParameterEntrySize, Heap::kOld));
+ for (intptr_t i = 0; i < param_count; ++i) {
+ VariableDeclaration* variable;
+ if (i < function_node->positional_parameters().length()) {
+ variable = function_node->positional_parameters()[i];
+ } else {
+ variable = function_node->named_parameters()[i];
+ }
+
+ param_descriptor.SetAt(
+ i + Parser::kParameterIsFinalOffset,
+ variable->IsFinal() ? Bool::True() : Bool::False());
+
+ if (variable->initializer() != NULL) {
+ param_descriptor.SetAt(
+ i + Parser::kParameterDefaultValueOffset,
+ constant_evaluator.EvaluateExpression(variable->initializer()));
+ } else {
+ param_descriptor.SetAt(i + Parser::kParameterDefaultValueOffset,
+ Object::null_instance());
+ }
+
+ param_descriptor.SetAt(i + Parser::kParameterMetadataOffset,
+ /* Issue(28434): Missing parameter metadata. */
+ Object::null_instance());
+ }
+ return param_descriptor.raw();
+ } else {
+ Thread* thread = Thread::Current();
+ Error& error = Error::Handle();
+ error = thread->sticky_error();
+ thread->clear_sticky_error();
+ return error.raw();
+ }
+}
+
+
} // namespace kernel
} // namespace dart
+
#endif // !defined(DART_PRECOMPILED_RUNTIME)
diff --git a/runtime/vm/kernel_to_il.h b/runtime/vm/kernel_to_il.h
index b82216a..e518cee 100644
--- a/runtime/vm/kernel_to_il.h
+++ b/runtime/vm/kernel_to_il.h
@@ -721,6 +721,7 @@
TargetEntryInstr* BuildTargetEntry();
JoinEntryInstr* BuildJoinEntry();
+ JoinEntryInstr* BuildJoinEntry(intptr_t try_index);
Fragment TranslateArguments(Arguments* node, Array* argument_names);
ArgumentArray GetArguments(int count);
@@ -815,9 +816,11 @@
intptr_t argument_count,
const Array& argument_names);
Fragment StoreIndexed(intptr_t class_id);
- Fragment StoreInstanceFieldGuarded(const dart::Field& field);
+ Fragment StoreInstanceFieldGuarded(const dart::Field& field,
+ bool is_initialization_store);
Fragment StoreInstanceField(
const dart::Field& field,
+ bool is_initialization_store,
StoreBarrierType emit_store_barrier = kEmitStoreBarrier);
Fragment StoreInstanceField(
intptr_t offset,
@@ -947,6 +950,24 @@
friend class TryFinallyBlock;
};
+RawObject* EvaluateMetadata(TreeNode* const kernel_node);
+RawObject* BuildParameterDescriptor(TreeNode* const kernel_node);
+
+
+} // namespace kernel
+} // namespace dart
+
+#else // !defined(DART_PRECOMPILED_RUNTIME)
+
+#include "vm/object.h"
+#include "vm/kernel.h"
+
+namespace dart {
+namespace kernel {
+
+RawObject* EvaluateMetadata(TreeNode* const kernel_node);
+RawObject* BuildParameterDescriptor(TreeNode* const kernel_node);
+
} // namespace kernel
} // namespace dart
diff --git a/runtime/vm/metrics_test.cc b/runtime/vm/metrics_test.cc
index 77a762f..3a559ba 100644
--- a/runtime/vm/metrics_test.cc
+++ b/runtime/vm/metrics_test.cc
@@ -16,7 +16,7 @@
#ifndef PRODUCT
UNIT_TEST_CASE(Metric_Simple) {
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
{
Metric metric;
@@ -45,7 +45,7 @@
};
UNIT_TEST_CASE(Metric_OnDemand) {
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
{
Thread* thread = Thread::Current();
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 3675bfb..7f85580 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -29,6 +29,7 @@
#include "vm/heap.h"
#include "vm/intrinsifier.h"
#include "vm/isolate_reload.h"
+#include "vm/kernel_to_il.h"
#include "vm/object_store.h"
#include "vm/parser.h"
#include "vm/precompiler.h"
@@ -9681,7 +9682,8 @@
void Library::AddMetadata(const Object& owner,
const String& name,
- TokenPosition token_pos) const {
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node) const {
Thread* thread = Thread::Current();
ASSERT(thread->IsMutatorThread());
Zone* zone = thread->zone();
@@ -9694,6 +9696,7 @@
field.SetFieldType(Object::dynamic_type());
field.set_is_reflectable(false);
field.SetStaticValue(Array::empty_array(), true);
+ field.set_kernel_field(kernel_node);
GrowableObjectArray& metadata =
GrowableObjectArray::Handle(zone, this->metadata());
metadata.Add(field, Heap::kOld);
@@ -9702,34 +9705,37 @@
void Library::AddClassMetadata(const Class& cls,
const Object& tl_owner,
- TokenPosition token_pos) const {
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node) const {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
// We use the toplevel class as the owner of a class's metadata field because
// a class's metadata is in scope of the library, not the class.
AddMetadata(tl_owner,
String::Handle(zone, MakeClassMetaName(thread, zone, cls)),
- token_pos);
+ token_pos, kernel_node);
}
void Library::AddFieldMetadata(const Field& field,
- TokenPosition token_pos) const {
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node) const {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
AddMetadata(Object::Handle(zone, field.RawOwner()),
String::Handle(zone, MakeFieldMetaName(thread, zone, field)),
- token_pos);
+ token_pos, kernel_node);
}
void Library::AddFunctionMetadata(const Function& func,
- TokenPosition token_pos) const {
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node) const {
Thread* thread = Thread::Current();
Zone* zone = thread->zone();
AddMetadata(Object::Handle(zone, func.RawOwner()),
String::Handle(zone, MakeFunctionMetaName(thread, zone, func)),
- token_pos);
+ token_pos, kernel_node);
}
@@ -9801,7 +9807,14 @@
Object& metadata = Object::Handle();
metadata = field.StaticValue();
if (field.StaticValue() == Object::empty_array().raw()) {
- metadata = Parser::ParseMetadata(field);
+ kernel::TreeNode* kernel_node =
+ reinterpret_cast<kernel::TreeNode*>(field.kernel_field());
+
+ if (kernel_node != NULL) {
+ metadata = kernel::EvaluateMetadata(kernel_node);
+ } else {
+ metadata = Parser::ParseMetadata(field);
+ }
if (metadata.IsArray()) {
ASSERT(Array::Cast(metadata).raw() != Object::empty_array().raw());
field.SetStaticValue(Array::Cast(metadata), true);
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 61a8051..cf302d8 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -31,6 +31,7 @@
// Forward declarations.
namespace kernel {
class Program;
+class TreeNode;
}
#define DEFINE_FORWARD_DECLARATION(clazz) class clazz;
@@ -3762,9 +3763,14 @@
void AddClassMetadata(const Class& cls,
const Object& tl_owner,
- TokenPosition token_pos) const;
- void AddFieldMetadata(const Field& field, TokenPosition token_pos) const;
- void AddFunctionMetadata(const Function& func, TokenPosition token_pos) const;
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node = NULL) const;
+ void AddFieldMetadata(const Field& field,
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node = NULL) const;
+ void AddFunctionMetadata(const Function& func,
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node = NULL) const;
void AddLibraryMetadata(const Object& tl_owner,
TokenPosition token_pos) const;
void AddTypeParameterMetadata(const TypeParameter& param,
@@ -3931,7 +3937,8 @@
RawField* GetMetadataField(const String& metaname) const;
void AddMetadata(const Object& owner,
const String& name,
- TokenPosition token_pos) const;
+ TokenPosition token_pos,
+ kernel::TreeNode* kernel_node = NULL) const;
FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index 667280a..f0e9b3f 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -2485,6 +2485,8 @@
script.TokenRangeAtLine(1000, &first_idx, &last_idx);
EXPECT_EQ(-1, first_idx.value());
EXPECT_EQ(-1, last_idx.value());
+
+ free(src_chars);
}
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index afa023a..9235268 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -12045,6 +12045,13 @@
parameterized_type.set_signature(
Function::Handle(Z, resolved_type_class.signature_function()));
}
+ // Replace FutureOr<T> type of async library with dynamic.
+ if ((resolved_type_class.library() == Library::AsyncLibrary()) &&
+ (resolved_type_class.Name() == Symbols::FutureOr().raw())) {
+ parameterized_type.set_type_class(
+ Class::Handle(Object::dynamic_class()));
+ parameterized_type.set_arguments(Object::null_type_arguments());
+ }
} else if (finalization >= ClassFinalizer::kCanonicalize) {
ClassFinalizer::FinalizeMalformedType(
Error::Handle(Z), // No previous error.
diff --git a/runtime/vm/service/service.md b/runtime/vm/service/service.md
index b9cdf81..1c9bb72 100644
--- a/runtime/vm/service/service.md
+++ b/runtime/vm/service/service.md
@@ -37,7 +37,7 @@
- [getVersion](#getversion)
- [getVM](#getvm)
- [pause](#pause)
- - [reloadSources](#reloadSources)
+ - [reloadSources](#reloadsources)
- [removeBreakpoint](#removebreakpoint)
- [resume](#resume)
- [setExceptionPauseMode](#setexceptionpausemode)
@@ -2183,7 +2183,7 @@
```
class ReloadReport extends Response {
// Did the reload succeed or fail?
- bool status;
+ bool success;
}
```
diff --git a/runtime/vm/service_test.cc b/runtime/vm/service_test.cc
index 0bbed74..d0d488a 100644
--- a/runtime/vm/service_test.cc
+++ b/runtime/vm/service_test.cc
@@ -33,6 +33,7 @@
MessageStatus HandleMessage(Message* message) {
if (_msg != NULL) {
free(_msg);
+ _msg = NULL;
}
// Parse the message.
@@ -58,6 +59,8 @@
_msg = strdup(reinterpret_cast<char*>(response.DataAddr(0)));
}
+ delete message;
+
return kOK;
}
diff --git a/runtime/vm/simulator_arm64.cc b/runtime/vm/simulator_arm64.cc
index 4e8fde2..3c0c99b 100644
--- a/runtime/vm/simulator_arm64.cc
+++ b/runtime/vm/simulator_arm64.cc
@@ -2261,7 +2261,8 @@
value &= kWRegMask;
}
return (static_cast<uint64_t>(value) >> amount) |
- ((value & ((1L << amount) - 1L)) << (reg_size - amount));
+ ((static_cast<uint64_t>(value) & ((1ULL << amount) - 1ULL))
+ << (reg_size - amount));
}
default:
UNIMPLEMENTED();
@@ -2673,12 +2674,12 @@
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);
+ uint64_t alu_out;
+ UnsignedMultiply128(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);
+ const unsigned __int128 res = static_cast<unsigned __int128>(rn_val) *
+ static_cast<unsigned __int128>(rm_val);
+ const uint64_t alu_out = static_cast<uint64_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) &&
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index c7f3a0c..8a0a161 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -127,6 +127,7 @@
V(AwaitContextVar, ":await_ctx_var") \
V(AwaitJumpVar, ":await_jump_var") \
V(Future, "Future") \
+ V(FutureOr, "FutureOr") \
V(FutureMicrotask, "Future.microtask") \
V(FutureValue, "Future.value") \
V(FutureThen, "then") \
@@ -141,6 +142,7 @@
V(Native, "native") \
V(Class, "Class") \
V(Null, "Null") \
+ V(null, "null") \
V(Dynamic, "dynamic") \
V(UnresolvedClass, "UnresolvedClass") \
V(Type, "_Type") \
diff --git a/runtime/vm/thread_test.cc b/runtime/vm/thread_test.cc
index 8002e39..058ed3f 100644
--- a/runtime/vm/thread_test.cc
+++ b/runtime/vm/thread_test.cc
@@ -15,7 +15,7 @@
UNIT_TEST_CASE(Mutex) {
// This unit test case needs a running isolate.
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Mutex* mutex = new Mutex();
@@ -37,7 +37,7 @@
UNIT_TEST_CASE(Monitor) {
// This unit test case needs a running isolate.
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
OSThread* thread = OSThread::Current();
// Thread interrupter interferes with this test, disable interrupts.
@@ -389,13 +389,13 @@
char* orig_str = orig_zone->PrintToString("foo");
Dart_ExitIsolate();
// Create and enter a new isolate.
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Zone* zone0 = Thread::Current()->zone();
EXPECT(zone0 != orig_zone);
Dart_ShutdownIsolate();
// Create and enter yet another isolate.
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
{
// Create a stack resource this time, and exercise it.
diff --git a/runtime/vm/unit_test.h b/runtime/vm/unit_test.h
index c08f36e..f0c0fcc 100644
--- a/runtime/vm/unit_test.h
+++ b/runtime/vm/unit_test.h
@@ -247,7 +247,7 @@
// isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
// snapshot otherwise it is initialized to NULL.
-extern const uint8_t* isolate_snapshot_buffer;
+extern const uint8_t* core_isolate_snapshot_buffer;
}
@@ -295,7 +295,7 @@
return CreateIsolate(buffer, name);
}
static Dart_Isolate CreateTestIsolate(const char* name = NULL) {
- return CreateIsolate(bin::isolate_snapshot_buffer, name);
+ return CreateIsolate(bin::core_isolate_snapshot_buffer, name);
}
static Dart_Handle library_handler(Dart_LibraryTag tag,
Dart_Handle library,
diff --git a/runtime/vm/zone_test.cc b/runtime/vm/zone_test.cc
index 38726ad..cb7b0c4 100644
--- a/runtime/vm/zone_test.cc
+++ b/runtime/vm/zone_test.cc
@@ -14,7 +14,7 @@
#if defined(DEBUG)
FLAG_trace_zones = true;
#endif
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Thread* thread = Thread::Current();
EXPECT(thread->zone() == NULL);
@@ -76,7 +76,7 @@
#if defined(DEBUG)
FLAG_trace_zones = true;
#endif
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Thread* thread = Thread::Current();
EXPECT(thread->zone() == NULL);
@@ -100,7 +100,7 @@
#if defined(DEBUG)
FLAG_trace_zones = true;
#endif
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Thread* thread = Thread::Current();
EXPECT(thread->zone() == NULL);
@@ -119,7 +119,7 @@
#if defined(DEBUG)
FLAG_trace_zones = true;
#endif
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Thread* thread = Thread::Current();
EXPECT(thread->zone() == NULL);
@@ -175,7 +175,7 @@
#if defined(DEBUG)
FLAG_trace_zones = true;
#endif
- Dart_CreateIsolate(NULL, NULL, bin::isolate_snapshot_buffer, NULL, NULL,
+ Dart_CreateIsolate(NULL, NULL, bin::core_isolate_snapshot_buffer, NULL, NULL,
NULL);
Thread* thread = Thread::Current();
EXPECT(thread->zone() == NULL);
diff --git a/sdk/lib/_internal/js_runtime/lib/js_helper.dart b/sdk/lib/_internal/js_runtime/lib/js_helper.dart
index 638a31c..86e80d8 100644
--- a/sdk/lib/_internal/js_runtime/lib/js_helper.dart
+++ b/sdk/lib/_internal/js_runtime/lib/js_helper.dart
@@ -3409,8 +3409,8 @@
* Normal cast error caused by a failed type cast.
*/
CastErrorImplementation(Object actualType, Object expectedType)
- : message = "CastError: Casting value of type $actualType to"
- " incompatible type $expectedType";
+ : message = "CastError: Casting value of type '$actualType' to"
+ " incompatible type '$expectedType'";
String toString() => message;
}
@@ -3514,7 +3514,7 @@
/// returns true if [this] is a supertype of [expression].
@NoInline() @NoSideEffects()
bool _isTest(expression) {
- var functionTypeObject = _extractFunctionTypeObjectFrom(expression);
+ var functionTypeObject = extractFunctionTypeObjectFrom(expression);
return functionTypeObject == null
? false
: isFunctionSubtype(functionTypeObject, toRti());
@@ -3542,12 +3542,12 @@
if (expression == null) return null;
if (_isTest(expression)) return expression;
- var self = new FunctionTypeInfoDecoderRing(toRti()).toString();
+ var self = runtimeTypeToString(toRti());
if (isCast) {
- var functionTypeObject = _extractFunctionTypeObjectFrom(expression);
+ var functionTypeObject = extractFunctionTypeObjectFrom(expression);
var pretty;
if (functionTypeObject != null) {
- pretty = new FunctionTypeInfoDecoderRing(functionTypeObject).toString();
+ pretty = runtimeTypeToString(functionTypeObject);
} else {
pretty = Primitives.objectTypeName(expression);
}
@@ -3558,14 +3558,6 @@
}
}
- _extractFunctionTypeObjectFrom(o) {
- var interceptor = getInterceptor(o);
- var signatureName = JS_GET_NAME(JsGetName.SIGNATURE_NAME);
- return JS('bool', '# in #', signatureName, interceptor)
- ? JS('', '#[#]()', interceptor, JS_GET_NAME(JsGetName.SIGNATURE_NAME))
- : null;
- }
-
toRti() {
var result = createDartFunctionTypeRti();
if (isVoid) {
@@ -3657,6 +3649,14 @@
}
}
+extractFunctionTypeObjectFrom(o) {
+ var interceptor = getInterceptor(o);
+ var signatureName = JS_GET_NAME(JsGetName.SIGNATURE_NAME);
+ return JS('bool', '# in #', signatureName, interceptor)
+ ? JS('', '#[#]()', interceptor, signatureName)
+ : null;
+}
+
RuntimeFunctionType buildFunctionType(returnType,
parameterTypes,
optionalParameterTypes) {
@@ -3816,58 +3816,8 @@
return const DynamicRuntimeType();
}
- String _convert(type) {
- String result = runtimeTypeToString(type);
- if (result != null) return result;
- // Currently the [runtimeTypeToString] method doesn't handle function rtis.
- if (JS('bool', '"func" in #', type)) {
- return new FunctionTypeInfoDecoderRing(type).toString();
- } else {
- throw 'bad type';
- }
- }
-
String toString() {
- if (_cachedToString != null) return _cachedToString;
- var s = "(";
- var sep = '';
- if (_hasArguments) {
- for (var argument in _arguments) {
- s += sep;
- s += _convert(argument);
- sep = ', ';
- }
- }
- if (_hasOptionalArguments) {
- s += '$sep[';
- sep = '';
- for (var argument in _optionalArguments) {
- s += sep;
- s += _convert(argument);
- sep = ', ';
- }
- s += ']';
- }
- if (_hasNamedArguments) {
- s += '$sep{';
- sep = '';
- for (var name in extractKeys(_namedArguments)) {
- s += sep;
- s += '$name: ';
- s += _convert(JS('', '#[#]', _namedArguments, name));
- sep = ', ';
- }
- s += '}';
- }
- s += ') -> ';
- if (_isVoid) {
- s += 'void';
- } else if (_hasReturnType) {
- s += _convert(_returnType);
- } else {
- s += 'dynamic';
- }
- return _cachedToString = "$s";
+ return _cachedToString ??= runtimeTypeToString(_typeData);
}
}
diff --git a/sdk/lib/_internal/js_runtime/lib/js_mirrors.dart b/sdk/lib/_internal/js_runtime/lib/js_mirrors.dart
index 7489b21..36924db 100644
--- a/sdk/lib/_internal/js_runtime/lib/js_mirrors.dart
+++ b/sdk/lib/_internal/js_runtime/lib/js_mirrors.dart
@@ -2803,6 +2803,10 @@
DeclarationMirror owner, var /*int|List|JsFunction|TypeImpl*/ type) {
// TODO(ahe): This method might benefit from using convertRtiToRuntimeType
// instead of working on strings.
+ if (type == null) {
+ return JsMirrorSystem._dynamicType;
+ }
+
ClassMirror ownerClass;
DeclarationMirror context = owner;
while (context != null) {
@@ -2816,9 +2820,7 @@
}
String representation;
- if (type == null) {
- return JsMirrorSystem._dynamicType;
- } else if (type is TypeImpl) {
+ if (type is TypeImpl) {
return reflectType(type);
} else if (ownerClass == null) {
representation = runtimeTypeToString(type);
@@ -2876,10 +2878,10 @@
getMangledTypeName(createRuntimeType(representation)));
}
String typedefPropertyName = JS_GET_NAME(JsGetName.TYPEDEF_TAG);
- if (type != null && JS('', '#[#]', type, typedefPropertyName) != null) {
+ if (JS('', '#[#]', type, typedefPropertyName) != null) {
return typeMirrorFromRuntimeTypeRepresentation(
owner, JS('', '#[#]', type, typedefPropertyName));
- } else if (type != null && isDartFunctionType(type)) {
+ } else if (isDartFunctionType(type)) {
return new JsFunctionTypeMirror(type, owner);
}
return reflectClass(Function);
diff --git a/sdk/lib/_internal/js_runtime/lib/js_rti.dart b/sdk/lib/_internal/js_runtime/lib/js_rti.dart
index f9cd698..2ba517c 100644
--- a/sdk/lib/_internal/js_runtime/lib/js_rti.dart
+++ b/sdk/lib/_internal/js_runtime/lib/js_rti.dart
@@ -159,22 +159,95 @@
String runtimeTypeToString(var rti, {String onTypeVariable(int i)}) {
if (rti == null) {
return 'dynamic';
- } else if (isJsArray(rti)) {
+ }
+ if (isJsArray(rti)) {
// A list representing a type with arguments.
return getRuntimeTypeAsString(rti, onTypeVariable: onTypeVariable);
- } else if (isJsFunction(rti)) {
+ }
+ if (isJsFunction(rti)) {
// A reference to the constructor.
return rawRtiToJsConstructorName(rti);
- } else if (rti is int) {
+ }
+ if (rti is int) {
if (onTypeVariable == null) {
return rti.toString();
} else {
return onTypeVariable(rti);
}
- } else {
- // TODO(ahe): Handle function types, and be sure to always return a string.
- return null;
}
+ if (JS('bool', 'typeof #.func != "undefined"', rti)) {
+ // If the RTI has typedef equivalence info (via mirrors), use that since the
+ // mirrors helpers will re-parse the generated string.
+
+ String typedefPropertyName = JS_GET_NAME(JsGetName.TYPEDEF_TAG);
+ var typedefInfo = JS('', '#[#]', rti, typedefPropertyName);
+ if (typedefInfo != null) {
+ return runtimeTypeToString(typedefInfo, onTypeVariable: onTypeVariable);
+ }
+ return _functionRtiToString(rti, onTypeVariable);
+ }
+ // We should not get here.
+ return 'unknown-reified-type';
+}
+
+String _functionRtiToString(var rti, String onTypeVariable(int i)) {
+ String returnTypeText;
+ if (JS('bool', '!!#.v', rti)) {
+ returnTypeText = 'void';
+ } else {
+ var returnRti = JS('', '#.ret', rti);
+ returnTypeText =
+ runtimeTypeToString(returnRti, onTypeVariable: onTypeVariable);
+ }
+
+ String argumentsText = '';
+ String sep = '';
+
+ bool hasArguments = JS('bool', '"args" in #', rti);
+ if (hasArguments) {
+ List arguments = JS('JSFixedArray', '#.args', rti);
+ for (var argument in arguments) {
+ argumentsText += sep;
+ argumentsText +=
+ runtimeTypeToString(argument, onTypeVariable: onTypeVariable);
+ sep = ', ';
+ }
+ }
+
+ bool hasOptionalArguments = JS('bool', '"opt" in #', rti);
+ if (hasOptionalArguments) {
+ List optionalArguments = JS('JSFixedArray', '#.opt', rti);
+ argumentsText += '$sep[';
+ sep = '';
+ for (var argument in optionalArguments) {
+ argumentsText += sep;
+ argumentsText +=
+ runtimeTypeToString(argument, onTypeVariable: onTypeVariable);
+ sep = ', ';
+ }
+ argumentsText += ']';
+ }
+
+ bool hasNamedArguments = JS('bool', '"named" in #', rti);
+ if (hasNamedArguments) {
+ var namedArguments = JS('', '#.named', rti);
+ argumentsText += '$sep{';
+ sep = '';
+ for (String name in extractKeys(namedArguments)) {
+ argumentsText += sep;
+ argumentsText += runtimeTypeToString(JS('', '#[#]', namedArguments, name),
+ onTypeVariable: onTypeVariable);
+ argumentsText += ' $name';
+ sep = ', ';
+ }
+ argumentsText += '}';
+ }
+
+ // TODO(sra): Below is the same format as the VM. Change to:
+ //
+ // '${returnTypeText} Function(${argumentsText})';
+ //
+ return '(${argumentsText}) => ${returnTypeText}';
}
/**
@@ -210,6 +283,10 @@
* In minified mode does *not* use unminified identifiers (even when present).
*/
String getRuntimeTypeString(var object) {
+ // Check for function type first, since non-tearoff closures look like classes
+ // due to closure conversion.
+ var functionRti = extractFunctionTypeObjectFrom(object);
+ if (functionRti != null) return runtimeTypeToString(functionRti);
String className = getClassName(object);
if (object == null) return className;
var rti = JS('var', r'#.$ti', object);
diff --git a/sdk/lib/core/list.dart b/sdk/lib/core/list.dart
index 33e011c..9dc6610 100644
--- a/sdk/lib/core/list.dart
+++ b/sdk/lib/core/list.dart
@@ -415,12 +415,15 @@
* Returns an [Iterable] that iterates over the objects in the range
* [start] inclusive to [end] exclusive.
*
- * An error occurs if [end] is before [start].
+ * The provide range, given by [start] and [end], must be valid at the time
+ * of the call.
*
- * An error occurs if the [start] and [end] are not valid ranges at the time
- * of the call to this method. The returned [Iterable] behaves like
- * `skip(start).take(end - start)`. That is, it does not throw exceptions
- * if `this` changes size.
+ * A range from [start] to [end] is valid if `0 <= start <= end <= len`, where
+ * `len` is this list's `length`. The range starts at `start` and has length
+ * `end - start`. An empty range (with `end == start`) is valid.
+ *
+ * The returned [Iterable] behaves like `skip(start).take(end - start)`.
+ * That is, it does *not* throw if this list changes size.
*
* List<String> colors = ['red', 'green', 'blue', 'orange', 'pink'];
* Iterable<String> range = colors.getRange(1, 4);
@@ -441,15 +444,17 @@
* list1.setRange(1, 3, list2, 3);
* list1.join(', '); // '1, 8, 9, 4'
*
- * The [start] and [end] indices must satisfy `0 ≤ start ≤ end ≤ length`.
- * If [start] equals [end], this method has no effect.
+ * The provide range, given by [start] and [end], must be valid.
+ * A range from [start] to [end] is valid if `0 <= start <= end <= len`, where
+ * `len` is this list's `length`. The range starts at `start` and has length
+ * `end - start`. An empty range (with `end == start`) is valid.
*
* The [iterable] must have enough objects to fill the range from `start`
* to `end` after skipping [skipCount] objects.
*
- * If `iterable` is this list, the operation will copy the elements originally
- * in the range from `skipCount` to `skipCount + (end - start)` to the
- * range `start` to `end`, even if the two ranges overlap.
+ * If `iterable` is this list, the operation will copies the elements
+ * originally in the range from `skipCount` to `skipCount + (end - start)` to
+ * the range `start` to `end`, even if the two ranges overlap.
*
* If `iterable` depends on this list in some other way, no guarantees are
* made.
@@ -459,8 +464,10 @@
/**
* Removes the objects in the range [start] inclusive to [end] exclusive.
*
- * The [start] and [end] indices must be in the range
- * `0 ≤ index ≤ length`, and `start ≤ end`.
+ * The provide range, given by [start] and [end], must be valid.
+ * A range from [start] to [end] is valid if `0 <= start <= end <= len`, where
+ * `len` is this list's `length`. The range starts at `start` and has length
+ * `end - start`. An empty range (with `end == start`) is valid.
*
* Throws an [UnsupportedError] if this is a fixed-length list. In that case
* the list is not modified.
@@ -471,7 +478,10 @@
* Sets the objects in the range [start] inclusive to [end] exclusive
* to the given [fillValue].
*
- * An error occurs if [start]..[end] is not a valid range for `this`.
+ * The provide range, given by [start] and [end], must be valid.
+ * A range from [start] to [end] is valid if `0 <= start <= end <= len`, where
+ * `len` is this list's `length`. The range starts at `start` and has length
+ * `end - start`. An empty range (with `end == start`) is valid.
*/
void fillRange(int start, int end, [E fillValue]);
@@ -483,7 +493,10 @@
* list.replaceRange(1, 4, [6, 7]);
* list.join(', '); // '1, 6, 7, 5'
*
- * An error occurs if [start]..[end] is not a valid range for `this`.
+ * The provide range, given by [start] and [end], must be valid.
+ * A range from [start] to [end] is valid if `0 <= start <= end <= len`, where
+ * `len` is this list's `length`. The range starts at `start` and has length
+ * `end - start`. An empty range (with `end == start`) is valid.
*
* This method does not work on fixed-length lists, even when [replacement]
* has the same number of elements as the replaced range. In that case use
diff --git a/sdk/lib/core/string.dart b/sdk/lib/core/string.dart
index 78818b7..38df590 100644
--- a/sdk/lib/core/string.dart
+++ b/sdk/lib/core/string.dart
@@ -428,6 +428,9 @@
* except that the first match of [pattern], starting from [startIndex],
* is replaced by the result of calling [replace] with the match object.
*
+ * The optional [startIndex] is by default set to 0. If provided, it must be
+ * an integer in the range `[0 .. len]`, where `len` is this string's length.
+ *
* If the value returned by calling `replace` is not a [String], it
* is converted to a `String` using its `toString` method, which must
* then return a string.
diff --git a/sdk/lib/core/uri.dart b/sdk/lib/core/uri.dart
index fa7d01b..744bbe2 100644
--- a/sdk/lib/core/uri.dart
+++ b/sdk/lib/core/uri.dart
@@ -379,7 +379,7 @@
/**
* Returns the port part of the authority component.
*
- * Returns the defualt port if there is no port number in the authority
+ * Returns the default port if there is no port number in the authority
* component. That's 80 for http, 443 for https, and 0 for everything else.
*/
int get port;
@@ -505,7 +505,8 @@
* Returns the origin of the URI in the form scheme://host:port for the
* schemes http and https.
*
- * It is an error if the scheme is not "http" or "https".
+ * It is an error if the scheme is not "http" or "https", or if the host name
+ * is missing or empty.
*
* See: http://www.w3.org/TR/2011/WD-html5-20110405/origin-0.html#origin
*/
@@ -1470,7 +1471,8 @@
path = _makePath(path, 0, _stringOrNullLength(path), pathSegments,
scheme, hasAuthority);
if (scheme.isEmpty && host == null && !path.startsWith('/')) {
- path = _normalizeRelativePath(path, scheme.isNotEmpty || host != null);
+ bool allowScheme = scheme.isNotEmpty || host != null;
+ path = _normalizeRelativePath(path, allowScheme);
} else {
path = _removeDotSegments(path);
}
@@ -2520,13 +2522,17 @@
bool get hasAbsolutePath => _path.startsWith('/');
String get origin {
- if (scheme == "" || _host == null || _host == "") {
+ if (scheme == "") {
throw new StateError("Cannot use origin without a scheme: $this");
}
if (scheme != "http" && scheme != "https") {
throw new StateError(
"Origin is only applicable schemes http and https: $this");
}
+ if (_host == null || _host == "") {
+ throw new StateError(
+ "A $scheme: URI should have a non-empty host name: $this");
+ }
if (_port == null) return "$scheme://$_host";
return "$scheme://$_host:$_port";
}
@@ -4110,13 +4116,17 @@
String get origin {
// Check original behavior - W3C spec is wonky!
bool isHttp = _isHttp;
- if (_schemeEnd < 0 || _hostStart == _portStart) {
+ if (_schemeEnd < 0) {
throw new StateError("Cannot use origin without a scheme: $this");
}
if (!isHttp && !_isHttps) {
throw new StateError(
"Origin is only applicable schemes http and https: $this");
}
+ if (_hostStart == _portStart) {
+ throw new StateError(
+ "A $scheme: URI should have a non-empty host name: $this");
+ }
if (_hostStart == _schemeEnd + 3) {
return _uri.substring(0, _pathStart);
}
diff --git a/sdk/lib/isolate/isolate.dart b/sdk/lib/isolate/isolate.dart
index 1cc9d8e..5e3fe7f 100644
--- a/sdk/lib/isolate/isolate.dart
+++ b/sdk/lib/isolate/isolate.dart
@@ -389,7 +389,9 @@
* message, using the last response value that was added.
*
* If the isolate is already dead, no message will be sent.
- * If `response` cannot be sent to the isolate, then the request is ignored.
+ *
+ * The [response] object must follow the same restrictions as enforced by
+ * [SendPort.send].
* It is recommended to only use simple values that can be sent to all
* isolates, like `null`, booleans, numbers or strings.
*
@@ -464,6 +466,11 @@
/**
* Request that the isolate send [response] on the [responsePort].
*
+ * The [response] object must follow the same restrictions as enforced by
+ * [SendPort.send].
+ * It is recommended to only use simple values that can be sent to all
+ * isolates, like `null`, booleans, numbers or strings.
+ *
* If the isolate is alive, it will eventually send `response`
* (defaulting to `null`) on the response port.
*
@@ -478,10 +485,6 @@
* control returns to the event loop of the receiving isolate,
* after the current event, and any already scheduled control events,
* are completed.
- *
- * If `response` cannot be sent to the isolate, then the request is ignored.
- * It is recommended to only use simple values that can be sent to all
- * isolates, like `null`, booleans, numbers or strings.
*/
external void ping(SendPort responsePort, {Object response,
int priority: IMMEDIATE});
diff --git a/tests/co19/co19-kernel.status b/tests/co19/co19-kernel.status
index 14b67f9..55f7dcc 100644
--- a/tests/co19/co19-kernel.status
+++ b/tests/co19/co19-kernel.status
@@ -5,10 +5,27 @@
# Disable tests globally for kernel.
[ $compiler == dartk || $compiler == dartkp ]
Language/Libraries_and_Scripts/Imports/static_type_t01: Skip # No support for deferred libraries.
-Language/Metadata/*: Skip # No support for metadata ATM.
LibTest/async/DeferredLibrary/DeferredLibrary_A01_t01: Skip # No support for deferred libraries.
LibTest/isolate/*: Skip # No support for isolates ATM.
+Language/Metadata/before_export_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_import_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_library_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t02: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t03: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t04: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t05: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t06: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t07: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t08: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_param_t09: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_type_param_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_typedef_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_variable_t01: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+Language/Metadata/before_variable_t02: RuntimeError # Issue 28434: Kernel IR misses these annotations.
+
+
# Override tests marked as failing elsewhere.
[ $compiler == dartk || $compiler == dartkp ]
Language/Libraries_and_Scripts/Exports/reexport_t01: Pass
@@ -185,8 +202,6 @@
# dartk: precompilation failures
[ $compiler == dartkp && $runtime == dart_precompiled ]
-LibTest/core/StringBuffer/StringBuffer_A01_t02: RuntimeError
-LibTest/core/StringBuffer/write_A01_t02: RuntimeError
Language/Expressions/Constants/exception_t01: Crash
Language/Expressions/Constants/exception_t02: Crash
diff --git a/tests/co19/co19-runtime.status b/tests/co19/co19-runtime.status
index d2ef2f8..3e380ff 100644
--- a/tests/co19/co19-runtime.status
+++ b/tests/co19/co19-runtime.status
@@ -293,7 +293,7 @@
Language/Libraries_and_Scripts/Imports/invalid_uri_deferred_t01: Skip # Eager loading
Language/Libraries_and_Scripts/Imports/invalid_uri_deferred_t02: Skip # Eager loading
-[ $runtime == dart_precompiled || $compiler == app_jit ]
+[ $runtime == dart_precompiled ]
LibTest/isolate/Isolate/spawnUri*: SkipByDesign # Isolate.spawnUri
[ $compiler == precompiler ]
@@ -363,3 +363,6 @@
LibTest/isolate/Isolate/spawnUri_A01_t06: Pass, Fail # Timing dependent
LibTest/isolate/Isolate/spawnUri_A01_t07: Pass, Fail # Timing dependent
LibTest/isolate/ReceivePort/take_A01_t02: Skip # Issue 27773
+
+[ $runtime == vm && $mode == release && $system == linux && ($arch == x64 || $arch == ia32)]
+LibTest/isolate/Isolate/spawn_A04_t05: Pass, Slow
diff --git a/tests/compiler/dart2js/resolver_test.dart b/tests/compiler/dart2js/resolver_test.dart
index d1c90be..3035fbf 100644
--- a/tests/compiler/dart2js/resolver_test.dart
+++ b/tests/compiler/dart2js/resolver_test.dart
@@ -149,9 +149,8 @@
visitor.visit(definition.type);
ResolutionInterfaceType type =
visitor.registry.mapping.getType(definition.type);
- NominalTypeAnnotation annotation = definition.type;
Expect.equals(
- annotation.typeArguments.slowLength(), type.typeArguments.length);
+ definition.type.typeArguments.slowLength(), type.typeArguments.length);
int index = 0;
for (ResolutionDartType argument in type.typeArguments) {
Expect.equals(true, index < expectedElements.length);
@@ -701,8 +700,7 @@
Expect.equals(ElementKind.FIELD, element.kind);
VariableDefinitions node =
element.variables.parseNode(element, compiler.parsingContext);
- NominalTypeAnnotation annotation = node.type;
- Identifier typeName = annotation.typeName;
+ Identifier typeName = node.type.typeName;
Expect.equals(typeName.source, 'int');
compiler.parseScript("var b, c;");
diff --git a/tests/corelib/uri_test.dart b/tests/corelib/uri_test.dart
index d4ca36d..bcd0976 100644
--- a/tests/corelib/uri_test.dart
+++ b/tests/corelib/uri_test.dart
@@ -765,7 +765,7 @@
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
+ // This is an invalid path 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);
@@ -835,7 +835,7 @@
Expect.throws(
() => Uri.parse("http:").origin,
(e) { return e is StateError; },
- "origin for uri with empty host should fail");
+ "origin for URI with empty host should fail");
Expect.throws(
() => new Uri(
scheme: "http",
@@ -846,7 +846,7 @@
query: "query",
fragment: "fragment").origin,
(e) { return e is StateError; },
- "origin for uri with empty host should fail");
+ "origin for URI with empty host should fail");
Expect.throws(
() => new Uri(
scheme: null,
@@ -857,7 +857,7 @@
query: "query",
fragment: "fragment").origin,
(e) { return e is StateError; },
- "origin for uri with empty scheme should fail");
+ "origin for URI with empty scheme should fail");
Expect.throws(
() => new Uri(
scheme: "http",
@@ -868,11 +868,11 @@
query: "query",
fragment: "fragment").origin,
(e) { return e is StateError; },
- "origin for uri with empty host should fail");
+ "origin for URI with empty host should fail");
Expect.throws(
() => Uri.parse("http://:80").origin,
(e) { return e is StateError; },
- "origin for uri with empty host should fail");
+ "origin for URI with empty host should fail");
Expect.throws(
() => Uri.parse("file://localhost/test.txt").origin,
(e) { return e is StateError; },
diff --git a/tests/isolate/isolate.status b/tests/isolate/isolate.status
index 7d5e61ef..eb12d24 100644
--- a/tests/isolate/isolate.status
+++ b/tests/isolate/isolate.status
@@ -197,7 +197,7 @@
static_function_test: SkipByDesign
unresolved_ports_test: SkipByDesign
-[ $runtime == dart_precompiled || $compiler == app_jit ]
+[ $runtime == dart_precompiled ]
count_test: Skip # Isolate.spawnUri
cross_isolate_message_test: Skip # Isolate.spawnUri
deferred_in_isolate2_test: Skip # Isolate.spawnUri
diff --git a/tests/language/generalized_function_type_test.dart b/tests/language/generalized_function_type_test.dart
deleted file mode 100644
index a369241..0000000
--- a/tests/language/generalized_function_type_test.dart
+++ /dev/null
@@ -1,795 +0,0 @@
-// 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
deleted file mode 100644
index c6059c7..0000000
--- a/tests/language/generated_function_syntax_tests.dart
+++ /dev/null
@@ -1,75014 +0,0 @@
-// 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
deleted file mode 100644
index a5698bd..0000000
--- a/tests/language/generic_function_typedef2_test.dart
+++ /dev/null
@@ -1,42 +0,0 @@
-// 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
deleted file mode 100644
index eb8fb18..0000000
--- a/tests/language/generic_function_typedef_test.dart
+++ /dev/null
@@ -1,24 +0,0 @@
-// 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 4c42b55..869565b 100644
--- a/tests/language/language.status
+++ b/tests/language/language.status
@@ -53,11 +53,6 @@
async_star_regression_2238_test: CompileTimeError, RuntimeError # drt only runtime-errs.
-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,
# because the parsed type parameters are mapped to dynamic type.
@@ -216,7 +211,7 @@
implicit_closure_test: Skip # Incompatible flag: --use_slow_path
deopt_inlined_function_lazy_test: Skip # Incompatible flag: --deoptimize-alot
-[ $compiler == precompiler || $compiler == app_jit ]
+[ $runtime == dart_precompiled || $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
@@ -319,8 +314,3 @@
[$compiler == dart2analyzer]
vm/regress_27201_test: SkipByDesign # Loads bad library, so will always crash.
config_import_corelib_test: StaticWarning, OK
-
-null_bottom_test/none: StaticWarning, CompileTimeError # Issue 28025
-null_bottom_test/01: Pass, CompileTimeError # Issue 28025
-null_bottom_test/02: Pass, CompileTimeError # Issue 28025
-null_bottom_test/03: Pass, CompileTimeError # Issue 28025
diff --git a/tests/language/language_analyzer2.status b/tests/language/language_analyzer2.status
index 9925bfba6..1c2ebdb 100644
--- a/tests/language/language_analyzer2.status
+++ b/tests/language/language_analyzer2.status
@@ -72,15 +72,6 @@
const_for_in_variable_test/01: MissingCompileTimeError # Issue 25161
-null_is_bottom_type_test/01: StaticWarning # Issue 28027
-null_is_bottom_type_test/03: StaticWarning # Issue 28027
-null_is_bottom_type_test/06: StaticWarning # Issue 28027
-null_is_bottom_type_test/08: StaticWarning # Issue 28027
-null_is_bottom_type_test/10: StaticWarning # Issue 28027
-null_is_bottom_type_test/11: StaticWarning # Issue 28027
-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
diff --git a/tests/language/language_dart2js.status b/tests/language/language_dart2js.status
index fb1f295..08f95b1 100644
--- a/tests/language/language_dart2js.status
+++ b/tests/language/language_dart2js.status
@@ -39,12 +39,6 @@
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.
@@ -198,6 +192,7 @@
cyclic_type_test/0*: Fail # Issue 12605
cyclic_type2_test: Fail # Issue 12605
f_bounded_quantification4_test: Fail, OK # Issue 12605
+generic_closure_test: Fail # Issue 12605
mixin_generic_test: Fail # Issue 12605
mixin_mixin2_test: Fail # Issue 12605
mixin_mixin3_test: Fail # Issue 12605
@@ -232,7 +227,6 @@
modulo_test: RuntimeError # Issue 15246
truncdiv_test: RuntimeError # Issue 15246
invocation_mirror2_test: RuntimeError # Issue 6490 (wrong retval).
-generic_closure_test: RuntimeError # Issue 12605
const_switch_test/02: RuntimeError # Issue 17960
const_switch_test/04: RuntimeError # Issue 17960
diff --git a/tests/language/language_kernel.status b/tests/language/language_kernel.status
index 4dd9ab3..2a1aad7 100644
--- a/tests/language/language_kernel.status
+++ b/tests/language/language_kernel.status
@@ -17,6 +17,7 @@
conflicting_type_variable_and_setter_test: DartkCompileTimeError
const_for_in_variable_test/01: MissingCompileTimeError
constructor_duplicate_final_test/03: MissingCompileTimeError
+covariant_override_test: DartkCrash
deep_nesting1_negative_test: DartkCrash
deep_nesting2_negative_test: DartkCrash
deferred_closurize_load_library_test: DartkCrash
@@ -71,10 +72,7 @@
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
+covariant_override_test: DartkCompileTimeError # Issue 28166
# dartk: temporary failure
mixin_illegal_syntax_test/00: DartkCrash
@@ -104,7 +102,6 @@
accessor_conflict_import_prefixed2_test: RuntimeError
accessor_conflict_import_prefixed_test: RuntimeError
accessor_conflict_import_test: RuntimeError
-assertion_test: RuntimeError
bad_raw_string_negative_test: Fail
cha_deopt1_test: RuntimeError # Deferred Loading Issue 28335
cha_deopt2_test: RuntimeError # Deferred Loading Issue 28335
@@ -195,7 +192,6 @@
generic_closure_test: RuntimeError
generic_field_mixin4_test: RuntimeError
generic_method_types_test: Pass, RuntimeError
-generic_test: RuntimeError
getter_closure_execution_order_test: RuntimeError
getter_setter_in_lib_test: RuntimeError
inferrer_closure_test: RuntimeError
@@ -233,10 +229,8 @@
setter_no_getter_call_test/none: RuntimeError
static_setter_get_test/01: RuntimeError
switch7_negative_test: Fail
-switch_try_catch_test: RuntimeError
-try_catch_on_syntax_test/10: MissingRuntimeError
-try_catch_on_syntax_test/11: MissingRuntimeError
-try_finally_regress_25654_test: RuntimeError
+try_catch_on_syntax_test/10: MissingRuntimeError # Dartk Issue 28410
+try_catch_on_syntax_test/11: MissingRuntimeError # Dartk Issue 28410
type_checks_in_factory_method_test: RuntimeError
type_variable_function_type_test: RuntimeError
vm/type_cast_vm_test: RuntimeError
@@ -244,11 +238,9 @@
# dartk: JIT failures
[ $compiler == dartk && $runtime == vm ]
-const_evaluation_test/01: RuntimeError
const_locals_test: RuntimeError
constructor_named_arguments_test/01: Crash # Dartk Issue 28301
const_string_test: RuntimeError # Dartk Issue 28306
-instance_creation_in_function_annotation_test: RuntimeError
library_env_test/has_no_mirror_support: RuntimeError
redirecting_factory_reflection_test: RuntimeError
@@ -260,9 +252,39 @@
# dartk: precompilation failures
[ $compiler == dartkp && $runtime == dart_precompiled ]
if_null_assignment_static_test/35: Crash # Dartk Issue 28302
-string_interpolation7_test: RuntimeError # Dartk Issue 28306
# dartk: precompilation failures (debug)
[ $compiler == dartkp && $runtime == dart_precompiled && $mode == debug ]
constructor_named_arguments_test/01: Crash # Dartk Issue 28301
not_enough_positional_arguments_test/05: Crash # Dartk Issue 28301
+
+
+# New failures after respecting VMOptions in test files
+[ $compiler == dartk || $compiler == dartkp ]
+vm/regress_27671_test: RuntimeError
+
+# New failures after respecting VMOptions in test files
+[ $compiler == dartk && $runtime == vm && $mode == debug]
+hello_dart_test: Crash
+
+# New failures after respecting VMOptions in test files
+[ $compiler == dartk && $runtime == vm ]
+hello_dart_test: CompileTimeError
+ct_const2_test: Pass, CompileTimeError # Multitest via multiple VMOptions!
+disassemble_test: Pass, Crash # Multitest via multiple VMOptions!
+
+# Failures during Gardening shift: To be triaged!
+[ $compiler == dartk || $compiler == dartkp ]
+runtime_type_function_test: RuntimeError
+
+# Failures during Gardening shift: To be triaged!
+[ $compiler == dartkp && $runtime == dart_precompiled ]
+assert_with_type_test_or_cast_test: Pass, Crash # Multitest via multiple VMOptions.
+named_parameters_type_test/01: Crash
+named_parameters_type_test/02: Crash
+named_parameters_type_test/03: Crash
+positional_parameters_type_test/01: Crash
+positional_parameters_type_test/02: Crash
+type_checks_in_factory_method_test: Crash
+vm/regress_27671_test: Crash
+vm/type_vm_test: Crash
diff --git a/tests/language/null_bottom_test.dart b/tests/language/null_bottom_test.dart
index bea4dab..53e866a 100644
--- a/tests/language/null_bottom_test.dart
+++ b/tests/language/null_bottom_test.dart
@@ -113,7 +113,7 @@
// If type promotion succeeds, the static type is int->Null, otherwise
// it's Null->int.
fun2(42); // Should not give a warning after type promotion.
- fun2(null).abs(); /// 03: static type warning, runtime error
+ fun2(null).abs(); /// 03: runtime error
}
}
@@ -125,9 +125,9 @@
}
class T2 extends T1 {
- Null foo(Null x) => null; /// 01: static type warning
+ Null foo(Null x) => null;
Null bar(Null x) => null;
- int baz(int x) => x; /// 02: static type warning
+ int baz(int x) => x;
int qux(int x) => x;
}
diff --git a/tests/language/runtime_type_function_test.dart b/tests/language/runtime_type_function_test.dart
new file mode 100644
index 0000000..8d7e980
--- /dev/null
+++ b/tests/language/runtime_type_function_test.dart
@@ -0,0 +1,80 @@
+// 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:expect/expect.dart";
+
+typedef String F(String returns, String arguments);
+F fn;
+
+String form1(String returns, String arguments) => '$arguments => $returns';
+String form2(String returns, String arguments) => '$returns Function$arguments';
+
+F detectForm() {
+ var s = main.runtimeType.toString();
+ if (s.contains('=>')) return form1;
+ if (s.contains('Function')) return form2;
+ Expect.fail('"$s" contains neither "=>" nor "Function"');
+}
+
+main() {
+ fn = detectForm();
+
+ // Types that do not use class names - these can be checked on dart2js in
+ // minified mode.
+
+ check(fn('dynamic', '()'), main); // Top-level tear-off.
+ check(fn('void', '()'), Xyzzy.foo); // Class static member tear-off.
+ check(fn('void', '(dynamic)'), [].add); // Instance tear-off.
+ check(fn('dynamic', '()'), ()=>1); // closure.
+
+ var s = new Xyzzy().runtimeType.toString();
+ if (s.length <= 3) return; // dart2js --minify has minified names.
+
+ Expect.equals('Xyzzy', s, 'runtime type of plain class prints as class name');
+
+ check(fn('void', '(String, dynamic)'), check);
+
+ // Class static member tear-offs.
+ check(fn('String', '(String, [String, dynamic])'), Xyzzy.opt);
+ check(fn('String', '(String, {String a, dynamic b})'), Xyzzy.nam);
+
+ // Instance method tear-offs.
+ check(fn('void', '(String)'), <String>[].add);
+ check(fn('void', '(int)'), <int>[].add);
+
+ check(fn('String', '(int)'), new G<String, int>().foo);
+
+ // Instance method with function parameter.
+ var string2int = fn('int', '(String)');
+ check(fn('String', '($string2int)'), new G<String, int>().moo);
+
+ // Closures.
+ String localFunc(String a, String b) => a + b;
+ void localFunc2(int a) { print(a); }
+ Expect.isTrue(localFunc is F);
+ check(fn('String', '(String, String)'), localFunc);
+ check(fn('void', '(int)'), localFunc2);
+}
+
+void check(String text, var thing) {
+ var type = thing.runtimeType.toString();
+ if (type == text) return;
+ Expect.fail("""
+Type print string does not match expectation
+ Expected: '$text'
+ Actual: '$type'
+""");
+}
+
+
+class Xyzzy {
+ static void foo() {}
+ static String opt(String x, [String a, b]) {}
+ static String nam(String x, {String a, b}) {}
+}
+
+class G<U, V> {
+ U foo(V x) => null;
+ U moo(V f(U x)) => null;
+}
diff --git a/tests/language_strong/checked_covariant_overrides_test.dart b/tests/language_strong/covariant_override/runtime_check_test.dart
similarity index 100%
rename from tests/language_strong/checked_covariant_overrides_test.dart
rename to tests/language_strong/covariant_override/runtime_check_test.dart
diff --git a/tests/language_strong/covariant_override/tear_off_type_test.dart b/tests/language_strong/covariant_override/tear_off_type_test.dart
new file mode 100644
index 0000000..6ed1d09
--- /dev/null
+++ b/tests/language_strong/covariant_override/tear_off_type_test.dart
@@ -0,0 +1,158 @@
+// 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:expect/expect.dart";
+import 'package:meta/meta.dart' show checked;
+
+// If a parameter is directly or indirectly a covariant override, its type in
+// the method tear-off should become Object.
+
+typedef void TakeInts(int a, int b, int c, int d, int e);
+typedef void TakeObjectsAndInts(Object a, int b, Object c, int d, int e);
+typedef void TakeObjects(Object a, Object b, Object c, Object d, Object e);
+
+typedef void TakeOptionalInts([int a, int b, int c, int d]);
+typedef void TakeOptionalObjectsAndInts([Object a, int b, Object c, int d]);
+
+typedef void TakeNamedInts({int a, int b, int c, int d});
+typedef void TakeNamedObjectsAndInts({Object a, int b, Object c, int d});
+
+class M1 {
+ method(@checked int a, int b) {}
+}
+
+class M2 {
+ method(int a, @checked int b) {}
+}
+
+class C extends Object with M1, M2 {}
+
+class Direct {
+ void positional(@checked int a, int b, @checked int c, int d, int e) {}
+ void optional([@checked int a, int b, @checked int c, int d]) {}
+ void named({@checked int a, int b, @checked int c, int d}) {}
+}
+
+class Inherited extends Direct {}
+
+// ---
+
+class Override1 {
+ void method(@checked int a, int b, int c, int d, int e) {}
+}
+
+class Override2 extends Override1 {
+ void method(int a, int b, @checked int c, int d, int e) {}
+}
+
+class Override3 extends Override2 {
+ void method(int a, int b, int c, int d, int e) {}
+}
+
+// ---
+
+abstract class Implement1 {
+ void method(@checked int a, int b, int c, int d, int e) {}
+}
+
+class Implement2 {
+ void method(int a, @checked int b, int c, int d, int e) {}
+}
+
+class Implement3 {
+ void method(int a, int b, @checked int c, int d, int e) {}
+}
+
+class Implement4 implements Implement3 {
+ void method(int a, int b, int c, @checked int d, int e) {}
+}
+
+class Implement5 implements Implement1, Implement2, Implement4 {
+ void method(int a, int b, int c, int d, @checked int e) {}
+}
+
+// ---
+
+class Interface1 {
+ void method(@checked int a, int b, int c, int d, int e) {}
+}
+
+class Interface2 {
+ void method(int a, @checked int b, int c, int d, int e) {}
+}
+
+class Mixin1 {
+ void method(int a, int b, @checked int c, int d, int e) {}
+}
+
+class Mixin2 {
+ void method(int a, int b, int c, @checked int d, int e) {}
+}
+
+class Superclass {
+ void method(int a, int b, int c, int d, @checked int e) {}
+}
+
+class Mixed extends Superclass
+ with Mixin1, Mixin2
+ implements Interface1, Interface2 {}
+
+void main() {
+ testDirect();
+ testInherited();
+ testOverriden();
+ testImplemented();
+ testMixed();
+}
+
+void testDirect() {
+ var positional = new Direct().positional;
+ Expect.isTrue(positional is TakeInts);
+ Expect.isTrue(positional is TakeObjectsAndInts);
+
+ var optional = new Direct().optional;
+ Expect.isTrue(optional is TakeOptionalInts);
+ Expect.isTrue(optional is TakeOptionalObjectsAndInts);
+
+ var named = new Direct().named;
+ Expect.isTrue(named is TakeNamedInts);
+ Expect.isTrue(named is TakeNamedObjectsAndInts);
+}
+
+void testInherited() {
+ var positional = new Inherited().positional;
+ Expect.isTrue(positional is TakeInts);
+ Expect.isTrue(positional is TakeObjectsAndInts);
+
+ var optional = new Inherited().optional;
+ Expect.isTrue(optional is TakeOptionalInts);
+ Expect.isTrue(optional is TakeOptionalObjectsAndInts);
+
+ var named = new Inherited().named;
+ Expect.isTrue(named is TakeNamedInts);
+ Expect.isTrue(named is TakeNamedObjectsAndInts);
+}
+
+void testOverriden() {
+ var method2 = new Override2().method;
+ Expect.isTrue(method2 is TakeInts);
+ Expect.isTrue(method2 is TakeObjectsAndInts);
+
+ var method3 = new Override3().method;
+ Expect.isTrue(method3 is TakeInts);
+ Expect.isTrue(method3 is TakeObjectsAndInts);
+}
+
+void testImplemented() {
+ var method = new Implement5().method;
+ Expect.isTrue(method is TakeInts);
+ Expect.isTrue(method is TakeObjects);
+}
+
+void testMixed() {
+ // TODO(rnystrom): https://github.com/dart-lang/sdk/issues/28395
+ // var method = new Mixed().method;
+ // Expect.isTrue(method is TakeInts);
+ // Expect.isTrue(method is TakeObjects);
+}
diff --git a/tests/language_strong/covariant_subtyping_unsafe_call1_test.dart b/tests/language_strong/covariant_subtyping_unsafe_call1_test.dart
new file mode 100644
index 0000000..79fced2
--- /dev/null
+++ b/tests/language_strong/covariant_subtyping_unsafe_call1_test.dart
@@ -0,0 +1,14 @@
+// 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:expect/expect.dart';
+
+class Foo<T> {
+ method(T x) {}
+}
+
+main() {
+ Foo<int> intFoo = new Foo<int>();
+ Foo<num> numFoo = intFoo;
+ Expect.throws(() => numFoo.method(2.5));
+}
diff --git a/tests/language_strong/covariant_subtyping_unsafe_call2_test.dart b/tests/language_strong/covariant_subtyping_unsafe_call2_test.dart
new file mode 100644
index 0000000..ea59203
--- /dev/null
+++ b/tests/language_strong/covariant_subtyping_unsafe_call2_test.dart
@@ -0,0 +1,21 @@
+// 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:expect/expect.dart';
+
+class Implementation {
+ method(int x) {}
+}
+
+abstract class Interface<T> {
+ method(T x);
+}
+
+class Subclass extends Implementation implements Interface<int> {}
+
+main() {
+ Subclass subclass = new Subclass();
+ Interface<int> intInterface = subclass;
+ Interface<num> numInterface = intInterface;
+ Expect.throws(() => numInterface.method(2.5));
+}
diff --git a/tests/language_strong/language_strong_kernel.status b/tests/language_strong/language_strong_kernel.status
index 7858270..559b419 100644
--- a/tests/language_strong/language_strong_kernel.status
+++ b/tests/language_strong/language_strong_kernel.status
@@ -28,7 +28,6 @@
cha_deopt1_test: RuntimeError
cha_deopt2_test: RuntimeError
cha_deopt3_test: RuntimeError
-checked_covariant_overrides_test: RuntimeError
closure_type_variable_test: RuntimeError
closures_initializer_test: RuntimeError
compile_time_constant12_test: Crash
@@ -38,6 +37,7 @@
const_locals_test: RuntimeError
const_nested_test: RuntimeError
const_string_test: RuntimeError
+covariant_override/runtime_check_test: RuntimeError
custom_await_stack_trace_test: RuntimeError
cyclic_type2_test: CompileTimeError
cyclic_type_test/00: RuntimeError
diff --git a/tests/lib/lib.status b/tests/lib/lib.status
index 6ea31a2..e15fd0e 100644
--- a/tests/lib/lib.status
+++ b/tests/lib/lib.status
@@ -279,10 +279,6 @@
mirrors/mirrors_used*: SkipByDesign # Invalid tests. MirrorsUsed does not have a specification, and dart:mirrors is not required to hide declarations that are not covered by any MirrorsUsed annotation.
-async/future_or_bad_type_test/00: RuntimeError # Issue 28010
-async/future_or_bad_type_test/01: RuntimeError # Issue 28010
-async/future_or_bad_type_test/implements: Fail # Issue 28010
-async/future_or_non_strong_test: RuntimeError # Issue 28010
async/future_or_strong_test: RuntimeError, OK
[ $compiler == none && ($runtime == drt || $runtime == dartium) ]
diff --git a/tests/lib/mirrors/hierarchy_invariants_test.dart b/tests/lib/mirrors/hierarchy_invariants_test.dart
index e35a076..e2b73ca 100644
--- a/tests/lib/mirrors/hierarchy_invariants_test.dart
+++ b/tests/lib/mirrors/hierarchy_invariants_test.dart
@@ -24,7 +24,9 @@
}
Expect.isTrue(classMirror.superinterfaces is List);
if (classMirror.superclass == null) {
- Expect.equals(reflectClass(Object), classMirror);
+ Expect.isTrue(classMirror == reflectClass(Object) ||
+ // Type FutureOr is mapped to dynamic in the VM.
+ classMirror.toString() == "ClassMirror on 'FutureOr'");
} else {
checkClass(classMirror.superclass);
}
diff --git a/tests/standalone/io/named_pipe_script_test.dart b/tests/standalone/io/named_pipe_script_test.dart
index 83df737..ed5a659 100644
--- a/tests/standalone/io/named_pipe_script_test.dart
+++ b/tests/standalone/io/named_pipe_script_test.dart
@@ -6,27 +6,53 @@
import "dart:convert";
import "dart:io";
+import "package:async_helper/async_helper.dart";
import "package:expect/expect.dart";
-main() {
+main() async {
+ asyncStart();
// Reading a script from a named pipe is only supported on Linux and MacOS.
if (!Platform.isLinux && !Platform.isMacOS) {
+ print("This test is only supported on Linux and MacOS.");
+ asyncEnd();
return;
}
- final String script = 'int main() {print("Hello, World!");}';
+ final String script = 'main() { print("Hello, World!"); }';
final String stdinPipePath = '/dev/fd/0';
+
+ // If there's no file system access to the pipe, then we can't do a meaningful
+ // test.
+ if (!await (new File(stdinPipePath).exists())) {
+ print("Couldn't find $stdinPipePath.");
+ asyncEnd();
+ return;
+ }
+
StringBuffer output = new StringBuffer();
- Process.start(Platform.executable, [stdinPipePath]).then((Process process) {
- process.stdout.transform(UTF8.decoder).listen(output.write);
- process.stderr.transform(UTF8.decoder).listen((data) {
+ Process process =
+ await Process.start(Platform.executable, [stdinPipePath]);
+ bool stdinWriteFailed = false;
+ process.stdout.transform(UTF8.decoder).listen(output.write);
+ process.stderr.transform(UTF8.decoder).listen((data) {
+ if (!stdinWriteFailed) {
Expect.fail(data);
- });
- process.stdin.writeln(script);
- process.stdin.close();
- process.exitCode.then((int status) {
- Expect.equals(0, status);
- Expect.equals("Hello, World!\n", output.toString());
- });
+ process.kill();
+ }
});
+ process.stdin.done.catchError((e) {
+ // If the write to stdin fails, then give up. We can't test the thing we
+ // wanted to test.
+ stdinWriteFailed = true;
+ process.kill();
+ });
+ process.stdin.writeln(script);
+ process.stdin.close();
+
+ int status = await process.exitCode;
+ if (!stdinWriteFailed) {
+ Expect.equals(0, status);
+ Expect.equals("Hello, World!\n", output.toString());
+ }
+ asyncEnd();
}
diff --git a/tests/standalone/io/process_start_exception_test.dart b/tests/standalone/io/process_start_exception_test.dart
index a1f891e..2bf38cc 100644
--- a/tests/standalone/io/process_start_exception_test.dart
+++ b/tests/standalone/io/process_start_exception_test.dart
@@ -8,26 +8,38 @@
import 'dart:async';
import 'dart:io';
+// ENOENT and ERROR_FILE_NOT_FOUND on Windows both have the same value.
+// Note: we are setting PATH to an empty string in tests below because on
+// POSIX systems if target binary name does not contain `/` then it is
+// searched through PATH and if it is not found anywhere in the PATH
+// but some folder in PATH is inaccessible then underlying execvp(...)
+// call will return EACCES (13) instead of ENOENT.
+// For example on some Android devices PATH would include /sbin with is
+// inaccessible - so this test will fail.
+const ENOENT = 2;
+
testStartError() {
Future<Process> processFuture =
Process.start("__path_to_something_that_should_not_exist__",
- const []);
+ const [],
+ environment: {"PATH": ""});
processFuture.then((p) => Expect.fail('got process despite start error'))
.catchError((error) {
Expect.isTrue(error is ProcessException);
- Expect.equals(2, error.errorCode, error.toString());
+ Expect.equals(ENOENT, error.errorCode, error.toString());
});
}
testRunError() {
Future<ProcessResult> processFuture =
Process.run("__path_to_something_that_should_not_exist__",
- const []);
+ const [],
+ environment: {"PATH": ""});
processFuture.then((result) => Expect.fail("exit handler called"))
.catchError((error) {
Expect.isTrue(error is ProcessException);
- Expect.equals(2, error.errorCode, error.toString());
+ Expect.equals(ENOENT, error.errorCode, error.toString());
});
}
diff --git a/tests/standalone/standalone.status b/tests/standalone/standalone.status
index f76dc04..daef69f 100644
--- a/tests/standalone/standalone.status
+++ b/tests/standalone/standalone.status
@@ -63,6 +63,9 @@
io/http_proxy_test: Skip
io/secure_builtin_roots_test: Skip
+# This test might be slow on an opt counter threshold bot.
+io/http_basic_test: Pass, Slow
+
[ $compiler == none && ($runtime == drt || $runtime == dartium) ]
typed_array_test: RuntimeError, OK # Uses Isolate.spawn
@@ -358,6 +361,9 @@
io/https_bad_certificate_test: RuntimeError
io/secure_server_closing_test: RuntimeError
+[ $system == android && $runtime == dart_precompiled && $mode == release && $arch == arm]
+io/stdout_stderr_non_blocking_test: Pass, Timeout # Issue 28426
+
[ $runtime == vm || $runtime == dart_precompiled ]
deferred_transitive_import_error_test: Skip # Contains intentional errors.
@@ -379,10 +385,11 @@
io/socket_info_ipv6_test: SkipByDesign
[ $builder_tag == asan && $arch == x64 ]
+io/process_detached_test: Pass, Slow
+
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
diff --git a/tools/VERSION b/tools/VERSION
index 93e6780..eaf108ed 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 1
MINOR 22
PATCH 0
-PRERELEASE 8
+PRERELEASE 9
PRERELEASE_PATCH 0
diff --git a/tools/bots/ddc_tests.py b/tools/bots/ddc_tests.py
index c7fe10d..5d66bef 100644
--- a/tools/bots/ddc_tests.py
+++ b/tools/bots/ddc_tests.py
@@ -28,6 +28,7 @@
bot.RunProcess([dart_exe, 'tool/build_pkgs.dart', 'test'])
bot.RunProcess([dart_exe, 'test/all_tests.dart'])
+ # TODO(vsm): Our bots do not have node / npm installed.
# These mirror pkg/dev_compiler/tool/browser_test.sh.
- bot.RunProcess(['npm', 'install'])
- bot.RunProcess(['npm', 'test'])
+ # bot.RunProcess(['npm', 'install'])
+ # bot.RunProcess(['npm', 'test'], {'CHROME_BIN': 'chrome'})
diff --git a/tools/dom/scripts/css_code_generator.py b/tools/dom/scripts/css_code_generator.py
index ef7555a..b3b9f21 100644
--- a/tools/dom/scripts/css_code_generator.py
+++ b/tools/dom/scripts/css_code_generator.py
@@ -112,6 +112,11 @@
return style;
}
+ /// Returns the value of the property if the provided *CSS* property
+ /// name is supported on this element and if the value is set. Otherwise
+ /// returns an empty string.
+ ///
+ /// Please note the property name uses camelCase, not-hyphens.
String getPropertyValue(String propertyName) {
var propValue = _getPropertyValueHelper(propertyName);
return propValue != null ? propValue : '';
diff --git a/tools/testing/dart/browser_controller.dart b/tools/testing/dart/browser_controller.dart
index cacdd2a..9b1a5db 100644
--- a/tools/testing/dart/browser_controller.dart
+++ b/tools/testing/dart/browser_controller.dart
@@ -699,21 +699,23 @@
static const String viewAction = 'android.intent.action.VIEW';
static const String mainAction = 'android.intent.action.MAIN';
static const String chromePackage = 'com.android.chrome';
+ static const String chromeActivity = '.Main';
static const String browserPackage = 'com.android.browser';
+ static const String browserActivity = '.BrowserActivity';
static const String firefoxPackage = 'org.mozilla.firefox';
+ static const String firefoxActivity = '.App';
static const String turnScreenOnPackage = 'com.google.dart.turnscreenon';
+ static const String turnScreenOnActivity = '.Main';
AdbDevice _adbDevice;
AndroidChrome(this._adbDevice);
Future<bool> start(String url) {
- var browserIntent =
- new Intent(viewAction, browserPackage, '.BrowserActivity', url);
- var chromeIntent = new Intent(viewAction, chromePackage, '.Main', url);
- var firefoxIntent = new Intent(viewAction, firefoxPackage, '.App', url);
+ var chromeIntent =
+ new Intent(viewAction, chromePackage, chromeActivity, url);
var turnScreenOnIntent =
- new Intent(mainAction, turnScreenOnPackage, '.Main');
+ new Intent(mainAction, turnScreenOnPackage, turnScreenOnActivity);
var testing_resources_dir =
new Path('third_party/android_testing_resources');
@@ -1551,7 +1553,7 @@
// Object that holds the state of an HTML test
var html_test;
-
+
function newTaskHandler() {
if (this.readyState == this.DONE) {
if (this.status == 200) {
@@ -1577,7 +1579,7 @@
}
} else {
html_test = null;
- }
+ }
run(url);
}
} else {
@@ -1611,10 +1613,10 @@
function childError(message, filename, lineno, colno, error) {
sendStatusUpdate();
if (error) {
- reportMessage('FAIL:' + filename + ':' + lineno +
+ reportMessage('FAIL:' + filename + ':' + lineno +
':' + colno + ':' + message + '\\n' + error.stack, false, false);
} else if (filename) {
- reportMessage('FAIL:' + filename + ':' + lineno +
+ reportMessage('FAIL:' + filename + ':' + lineno +
':' + colno + ':' + message, false, false);
} else {
reportMessage('FAIL: ' + message, false, false);
@@ -1806,7 +1808,7 @@
html_test.found_messages[msg]++;
if (html_test.found_messages[msg] == 1) {
html_test.found_message_count++;
- } else {
+ } else {
html_test.double_received_messages.push(msg);
sendStatusUpdate();
}
diff --git a/tools/testing/dart/compiler_configuration.dart b/tools/testing/dart/compiler_configuration.dart
index f78b916..aeb7fae 100644
--- a/tools/testing/dart/compiler_configuration.dart
+++ b/tools/testing/dart/compiler_configuration.dart
@@ -7,11 +7,20 @@
import 'dart:io' show Platform;
import 'runtime_configuration.dart' show RuntimeConfiguration;
-
+import 'runtime_configuration.dart' show DartPrecompiledAdbRuntimeConfiguration;
import 'test_runner.dart' show Command, CommandBuilder, CompilationCommand;
-
import 'test_suite.dart' show TestInformation, TestUtils;
+List<String> replaceDartFileWith(List<String> list, String replacement) {
+ var copy = new List<String>.from(list);
+ for (var i = 0; i < copy.length; i++) {
+ if (copy[i].endsWith(".dart")) {
+ copy[i] = replacement;
+ }
+ }
+ return copy;
+}
+
/// Grouping of a command with its expected result.
class CommandArtifact {
final List<Command> commands;
@@ -91,12 +100,14 @@
isAndroid: configuration['system'] == 'android');
case 'dartk':
return ComposedCompilerConfiguration.createDartKConfiguration(
+ isChecked: isChecked,
isHostChecked: isHostChecked,
useSdk: useSdk,
verify: verifyKernel,
strong: isStrong);
case 'dartkp':
return ComposedCompilerConfiguration.createDartKPConfiguration(
+ isChecked: isChecked,
isHostChecked: isHostChecked,
arch: configuration['arch'],
useBlobs: useBlobs,
@@ -218,9 +229,10 @@
class DartKCompilerConfiguration extends CompilerConfiguration {
final bool verify, strong;
- DartKCompilerConfiguration({bool isHostChecked, bool useSdk, this.verify,
- this.strong})
- : super._subclass(isHostChecked: isHostChecked, useSdk: useSdk);
+ DartKCompilerConfiguration({bool isChecked, bool isHostChecked, bool useSdk,
+ this.verify, this.strong})
+ : super._subclass(isChecked: isChecked, isHostChecked: isHostChecked,
+ useSdk: useSdk);
@override
String computeCompilerPath(String buildDir) {
@@ -264,6 +276,29 @@
CommandBuilder.instance, arguments, environmentOverrides)
], '$tempDir/out.dill', 'application/dart');
}
+
+ List<String> computeRuntimeArguments(
+ RuntimeConfiguration runtimeConfiguration,
+ String buildDir,
+ TestInformation info,
+ List<String> vmOptions,
+ List<String> sharedOptions,
+ List<String> originalArguments,
+ CommandArtifact artifact) {
+ List<String> args = [];
+ if (isChecked) {
+ args.add('--enable_asserts');
+ args.add('--enable_type_checks');
+ }
+
+ var newOriginalArguments = replaceDartFileWith(
+ originalArguments, artifact.filename);
+
+ return args
+ ..addAll(vmOptions)
+ ..addAll(sharedOptions)
+ ..addAll(newOriginalArguments);
+ }
}
typedef List<String> CompilerArgumentsFunction(
@@ -301,7 +336,7 @@
return new PipelineCommand._(conf, (List<String> globalArguments,
String previousOutput) {
assert(previousOutput.endsWith('.dill'));
- return [previousOutput];
+ return replaceDartFileWith(globalArguments, previousOutput);
});
}
@@ -313,10 +348,8 @@
class ComposedCompilerConfiguration extends CompilerConfiguration {
final List<PipelineCommand> pipelineCommands;
- final bool isPrecompiler;
- ComposedCompilerConfiguration(this.pipelineCommands, {this.isPrecompiler: false})
- : super._subclass();
+ ComposedCompilerConfiguration(this.pipelineCommands) : super._subclass();
CommandArtifact computeCompilationArtifact(
String buildDir,
@@ -353,7 +386,7 @@
List<String> computeCompilerArguments(vmOptions, sharedOptions, args) {
// The result will be passed as an input to [extractArguments]
// (i.e. the arguments to the [PipelineCommand]).
- return new List<String>.from(sharedOptions)..addAll(args);
+ return <String>[]..addAll(vmOptions)..addAll(sharedOptions)..addAll(args);
}
List<String> computeRuntimeArguments(
@@ -364,38 +397,45 @@
List<String> sharedOptions,
List<String> originalArguments,
CommandArtifact artifact) {
- final String suffix = isPrecompiler ? "/out.aotsnapshot" : "";
- return <String>["${artifact.filename}${suffix}"];
+ CompilerConfiguration lastCompilerConfiguration =
+ pipelineCommands.last.compilerConfiguration;
+ return lastCompilerConfiguration.computeRuntimeArguments(
+ runtimeConfiguration, buildDir, info, vmOptions, sharedOptions,
+ originalArguments, artifact);
}
static ComposedCompilerConfiguration createDartKPConfiguration(
- {bool isHostChecked, String arch, bool useBlobs, bool isAndroid,
- bool useSdk, bool verify, bool strong}) {
+ {bool isChecked, bool isHostChecked, String arch, bool useBlobs,
+ bool isAndroid, bool useSdk, bool verify, bool strong}) {
var nested = [];
// Compile with dartk.
nested.add(new PipelineCommand.runWithGlobalArguments(
- new DartKCompilerConfiguration(isHostChecked: isHostChecked,
- useSdk: useSdk, verify: verify, strong: strong)));
+ new DartKCompilerConfiguration(isChecked: isChecked,
+ isHostChecked: isHostChecked, useSdk: useSdk, verify: verify,
+ strong: strong)));
// Run the normal precompiler.
nested.add(new PipelineCommand.runWithPreviousKernelOutput(
new PrecompilerCompilerConfiguration(
- arch: arch, useBlobs: useBlobs, isAndroid: isAndroid)));
+ isChecked: isChecked, arch: arch, useBlobs: useBlobs,
+ isAndroid: isAndroid)));
- return new ComposedCompilerConfiguration(nested, isPrecompiler: true);
+ return new ComposedCompilerConfiguration(nested);
}
static ComposedCompilerConfiguration createDartKConfiguration(
- {bool isHostChecked, bool useSdk, bool verify, bool strong}) {
+ {bool isChecked, bool isHostChecked, bool useSdk, bool verify,
+ bool strong}) {
var nested = [];
// Compile with dartk.
nested.add(new PipelineCommand.runWithGlobalArguments(
- new DartKCompilerConfiguration(isHostChecked: isHostChecked,
- useSdk: useSdk, verify: verify, strong: strong)));
+ new DartKCompilerConfiguration(isChecked: isChecked,
+ isHostChecked: isHostChecked, useSdk: useSdk,
+ verify: verify, strong: strong)));
- return new ComposedCompilerConfiguration(nested, isPrecompiler: false);
+ return new ComposedCompilerConfiguration(nested);
}
}
@@ -697,6 +737,16 @@
args.add('--enable_asserts');
args.add('--enable_type_checks');
}
+
+ var dir = artifact.filename;
+ if (runtimeConfiguration is DartPrecompiledAdbRuntimeConfiguration) {
+ // On android the precompiled snapshot will be pushed to a different
+ // directory on the device, use that one instead.
+ dir = DartPrecompiledAdbRuntimeConfiguration.DeviceTestDir;
+ }
+ originalArguments = replaceDartFileWith(
+ originalArguments, "$dir/out.aotsnapshot");
+
return args
..addAll(vmOptions)
..addAll(sharedOptions)
diff --git a/tools/testing/dart/pubspec.yaml b/tools/testing/dart/pubspec.yaml
new file mode 100644
index 0000000..0bcb25f
--- /dev/null
+++ b/tools/testing/dart/pubspec.yaml
@@ -0,0 +1,6 @@
+# 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.
+
+# This file is only here that so certain Dart editors recognize this is a Dart
+# project.
diff --git a/tools/testing/dart/runtime_configuration.dart b/tools/testing/dart/runtime_configuration.dart
index 5fb1007..c077e7d 100644
--- a/tools/testing/dart/runtime_configuration.dart
+++ b/tools/testing/dart/runtime_configuration.dart
@@ -280,23 +280,20 @@
throw "dart_precompiled cannot run files of type '$type'.";
}
- var args = new List();
- args.addAll(arguments);
- for (var i = 0; i < args.length; i++) {
- if (args[i].endsWith(".dart")) {
- args[i] = "${artifact.filename}/out.aotsnapshot";
- }
- }
-
return <Command>[
commandBuilder.getVmCommand(suite.dartPrecompiledBinaryFileName,
- args, environmentOverrides)
+ arguments, environmentOverrides)
];
}
}
class DartPrecompiledAdbRuntimeConfiguration
extends DartVmRuntimeConfiguration {
+ static const String DeviceDir =
+ '/data/local/tmp/precompilation-testing';
+ static const String DeviceTestDir =
+ '/data/local/tmp/precompilation-testing/test';
+
final bool useBlobs;
DartPrecompiledAdbRuntimeConfiguration({bool useBlobs}) : useBlobs = useBlobs;
diff --git a/tools/testing/dart/test_options.dart b/tools/testing/dart/test_options.dart
index e83c670..194f834 100644
--- a/tools/testing/dart/test_options.dart
+++ b/tools/testing/dart/test_options.dart
@@ -1015,6 +1015,7 @@
}
print('Unknown test option $name');
exit(1);
+ return null; // Unreachable.
}
List<_TestOptionSpecification> _options;
diff --git a/tools/testing/dart/test_progress.dart b/tools/testing/dart/test_progress.dart
index f09372a..6eb4bab 100644
--- a/tools/testing/dart/test_progress.dart
+++ b/tools/testing/dart/test_progress.dart
@@ -694,6 +694,6 @@
return new BuildbotProgressIndicator(startTime);
default:
assert(false);
- break;
+ return null;
}
}
diff --git a/tools/testing/dart/test_runner.dart b/tools/testing/dart/test_runner.dart
index 471e061..ac80516 100644
--- a/tools/testing/dart/test_runner.dart
+++ b/tools/testing/dart/test_runner.dart
@@ -22,14 +22,15 @@
import 'package:yaml/yaml.dart';
import 'android.dart';
-import 'dependency_graph.dart' as dgraph;
import "browser_controller.dart";
+import 'dependency_graph.dart' as dgraph;
import "path.dart";
+import 'record_and_replay.dart';
+import "runtime_configuration.dart";
import "status_file_parser.dart";
import "test_progress.dart";
import "test_suite.dart";
import "utils.dart";
-import 'record_and_replay.dart';
const int CRASHING_BROWSER_EXITCODE = -10;
const int SLOW_TIMEOUT_MULTIPLIER = 4;
@@ -2700,8 +2701,8 @@
var processTest = command.processTestFilename;
var testdir = command.precompiledTestDirectory;
var arguments = command.arguments;
- var devicedir = '/data/local/tmp/precompilation-testing';
- var deviceTestDir = '/data/local/tmp/precompilation-testing/test';
+ var devicedir = DartPrecompiledAdbRuntimeConfiguration.DeviceDir;
+ var deviceTestDir = DartPrecompiledAdbRuntimeConfiguration.DeviceTestDir;
// We copy all the files which the vm precompiler puts into the test
// directory.
@@ -2733,18 +2734,10 @@
.runAdbCommand(['push', '$testdir/$file', '$deviceTestDir/$file']));
}
- var args = new List();
- args.addAll(arguments);
- for (var i = 0; i < args.length; i++) {
- if (args[i].endsWith(".dart")) {
- args[i] = "$deviceTestDir/out.aotsnapshot";
- }
- }
-
steps.add(() => device.runAdbShellCommand(
[
'$devicedir/dart_precompiled_runtime',
- ]..addAll(args),
+ ]..addAll(arguments),
timeout: timeoutDuration));
var stopwatch = new Stopwatch()..start();
@@ -3139,7 +3132,7 @@
});
// Queue commands as they become "runnable"
- var commandEnqueuer = new CommandEnqueuer(_graph);
+ new CommandEnqueuer(_graph);
// CommandExecutor will execute commands
var executor;
diff --git a/tools/testing/dart/test_suite.dart b/tools/testing/dart/test_suite.dart
index 4aa99f4..a3b3092 100644
--- a/tools/testing/dart/test_suite.dart
+++ b/tools/testing/dart/test_suite.dart
@@ -1079,7 +1079,6 @@
List<String> otherResources = info.optionsFromFile['otherResources'];
for (String name in otherResources) {
Path namePath = new Path(name);
- String fileName = namePath.filename;
Path fromPath = info.filePath.directoryPath.join(namePath);
new File('$tempDir/$name').parent.createSync(recursive: true);
new File(fromPath.toNativePath()).copySync('$tempDir/$name');
@@ -1171,6 +1170,7 @@
// Unreachable
print("Cannot create URL for path $file. Not in build or dart directory.");
exit(1);
+ return null;
}
Uri _getUriForBrowserTest(String pathComponent, String subtestName) {
@@ -1829,7 +1829,7 @@
}
List<List<String>> getVmOptions(Map optionsFromFile) {
- var COMPILERS = const ['none', 'precompiler', 'app_jit'];
+ var COMPILERS = const ['none', 'dartk', 'dartkp', 'precompiler', 'app_jit'];
var RUNTIMES = const [
'none',
'dart_precompiled',
diff --git a/tools/testing/dart/utils.dart b/tools/testing/dart/utils.dart
index fd2245e..28eccbe 100644
--- a/tools/testing/dart/utils.dart
+++ b/tools/testing/dart/utils.dart
@@ -14,9 +14,9 @@
const Duration MAX_STDIO_DELAY = const Duration(seconds: 30);
String MAX_STDIO_DELAY_PASSED_MESSAGE =
- """Not waiting for stdout/stderr from subprocess anymore
-($MAX_STDIO_DELAY passed). Please note that this could be an indicator
-that there is a hanging process which we were unable to kill.""";
+ """Not waiting for stdout/stderr from subprocess anymore
+ ($MAX_STDIO_DELAY passed). Please note that this could be an indicator
+ that there is a hanging process which we were unable to kill.""";
class DebugLogger {
static IOSink _sink;
diff --git a/utils/application_snapshot.gni b/utils/application_snapshot.gni
index ffc0653..8899703e 100644
--- a/utils/application_snapshot.gni
+++ b/utils/application_snapshot.gni
@@ -49,48 +49,3 @@
] + 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 ab4da0a..33cea34 100644
--- a/utils/pub/BUILD.gn
+++ b/utils/pub/BUILD.gn
@@ -4,7 +4,7 @@
import("../application_snapshot.gni")
-script_snapshot("pub") {
+application_snapshot("pub") {
main_dart = "../../third_party/pkg/pub/bin/pub.dart"
training_args = [ "--help" ]
deps = [
