From bf0f72ae1469069c108b286ffe04ed5ac3b333f9 Mon Sep 17 00:00:00 2001 From: Konstantin Shcheglov Date: Fri, 24 Apr 2026 09:21:11 -0700 Subject: [PATCH] CQ. Refactor test type construction to use parseType(). Replace manual type construction utilities in type system tests with a unified string-based type parser. This simplifies test code, improves readability, and enables more expressive type scenarios. Key changes: - Introduce TypeSpecParser and TypeParsingScope to parse types, function types, records, and type parameters from strings. - Add parseType() and related helpers to AbstractTypeSystemTest, replacing ElementsTypesMixin usage. - Remove ElementsTypesMixin and migrate all tests to use parsed types instead of manually constructed TypeImpl instances. - Extend _SpecParser to support: - Promoted type parameter bounds (`T & int`) - Parenthesized vs record types disambiguation - Additional built-in types (InvalidType, UnknownInferredType) - Variance in generic function types - Covariant parameters - Refactor scope construction to use _Scope.forLibraries, reducing duplicated interface/type alias collection logic. - Add standalone materialization flow for type parameters to support parsing in isolation. Impact: - Tests become more declarative and closer to Dart syntax. - Eliminates boilerplate and reduces risk of inconsistencies in manual type construction. - Enables testing of newer type system features (promotion, variance, complex function types) via concise string specs. Change-Id: I85dd0aa88a37142356f14419d0d35350e38b9c8b Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/497680 Reviewed-by: Johnni Winther --- .../test_utilities/test_library_builder.dart | 301 +- .../test/generated/elements_types_mixin.dart | 442 -- .../test/generated/type_system_base.dart | 139 +- .../test/generated/type_system_test.dart | 41 +- .../has_type_parameter_reference_test.dart | 50 +- .../dart/element/always_exhaustive_test.dart | 75 +- .../src/dart/element/assignable_test.dart | 18 +- .../test/src/dart/element/element_test.dart | 198 +- .../src/dart/element/factor_type_test.dart | 94 +- .../src/dart/element/flatten_type_test.dart | 190 +- .../src/dart/element/function_type_test.dart | 456 +- .../src/dart/element/future_or_base_test.dart | 32 +- .../dart/element/future_value_type_test.dart | 66 +- .../dart/element/generic_inferrer_test.dart | 424 +- .../element/incompatible_with_await_test.dart | 63 +- .../test/src/dart/element/is_known_test.dart | 35 +- .../element/least_greatest_closure_test.dart | 153 +- .../least_upper_bound_helper_test.dart | 356 +- ...ovariant_type_parameter_position_test.dart | 139 +- .../src/dart/element/normalize_type_test.dart | 297 +- .../test/src/dart/element/nullable_test.dart | 468 +- .../dart/element/replace_top_bottom_test.dart | 67 +- .../dart/element/resolve_to_bound_test.dart | 99 +- .../element/runtime_type_equality_test.dart | 237 +- .../test/src/dart/element/string_types.dart | 367 +- .../test/src/dart/element/subtype_test.dart | 4847 ++++++----------- .../test/src/dart/element/top_merge_test.dart | 282 +- .../src/dart/element/type_algebra_test.dart | 455 +- .../src/dart/element/type_bounded_test.dart | 165 +- .../type_constraint_gatherer_test.dart | 1638 +++--- .../element/type_parameter_element_test.dart | 87 +- .../element/type_references_any_test.dart | 73 +- .../src/dart/element/type_system_test.dart | 30 +- .../src/dart/element/type_visitor_test.dart | 170 +- .../dart/element/upper_lower_bound_test.dart | 2748 ++++------ 35 files changed, 6094 insertions(+), 9208 deletions(-) delete mode 100644 pkg/analyzer/test/generated/elements_types_mixin.dart diff --git a/pkg/analyzer/lib/src/test_utilities/test_library_builder.dart b/pkg/analyzer/lib/src/test_utilities/test_library_builder.dart index f7a578fb4da..a88bfadc845 100644 --- a/pkg/analyzer/lib/src/test_utilities/test_library_builder.dart +++ b/pkg/analyzer/lib/src/test_utilities/test_library_builder.dart @@ -9,6 +9,7 @@ import 'package:analyzer/source/line_info.dart'; import 'package:analyzer/src/dart/analysis/session.dart'; import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/type.dart'; +import 'package:analyzer/src/dart/element/type_schema.dart'; import 'package:analyzer/src/generated/engine.dart' as engine; import 'package:analyzer/src/generated/utilities_dart.dart'; import 'package:analyzer/src/summary2/reference.dart'; @@ -116,6 +117,29 @@ class TypeAliasSpec { const TypeAliasSpec(this.header); } +final class TypeSpecParser { + final _Scope _scope; + + TypeSpecParser({ + required List libraries, + required List typeParameters, + }) : _scope = _Scope.forLibraries( + libraries: libraries, + typeParameters: typeParameters, + ); + + TypeImpl parse(String input) { + return _SpecParser.parseType(input).materialize(_scope); + } + + List parseTypeParameters(String input) { + var declarations = _TypeParameterDeclarations( + _SpecParser.parseTypeParameters(input), + ); + return declarations.materializeStandalone(_Scope.child(_scope)); + } +} + class _ClassDeclaration { final ClassSpec spec; @@ -348,7 +372,7 @@ class _FormalParameterDeclaration { name: parsed.name, nameOffset: 0, parameterKind: parsed.kind, - ); + )..isExplicitlyCovariant = parsed.isCovariant; } void resolve(_Scope scope) { @@ -436,46 +460,19 @@ class _LibraryBuilder { } _Scope _scopeFor(LibrarySpec spec) { - var interfaces = {}; - var typeAliases = {}; - - void addInterfaces(LibraryElementImpl library) { - for (var element in library.classes) { - interfaces[element.name!] = element; - } - for (var element in library.enums) { - interfaces[element.name!] = element; - } - for (var element in library.extensionTypes) { - interfaces[element.name!] = element; - } - for (var element in library.mixins) { - interfaces[element.name!] = element; - } - } - - void addTypeAliases(LibraryElementImpl library) { - for (var element in library.typeAliases) { - typeAliases[element.name!] = element; - } - } + var libraries = []; for (var importUri in spec.imports) { if (externalLibraries[importUri] case var externalLibrary?) { - addInterfaces(externalLibrary); - addTypeAliases(externalLibrary); + libraries.add(externalLibrary); } if (_libraryElements[importUri] case var builtLibrary?) { - addInterfaces(builtLibrary); - addTypeAliases(builtLibrary); + libraries.add(builtLibrary); } } - var self = _libraryElements[spec.uri]!; - addInterfaces(self); - addTypeAliases(self); - - return _Scope.root(interfaces: interfaces, typeAliases: typeAliases); + libraries.add(_libraryElements[spec.uri]!); + return _Scope.forLibraries(libraries: libraries); } } @@ -768,14 +765,16 @@ class _ParsedExtensionTypeHeader { } class _ParsedFormalParameter { + final bool isCovariant; final ParameterKind kind; final String? name; final _ParsedType type; _ParsedFormalParameter({ - required this.type, - required this.name, + required this.isCovariant, required this.kind, + required this.name, + required this.type, }); } @@ -795,8 +794,7 @@ class _ParsedFunctionType implements _ParsedType { var functionScope = _Scope.child(scope); var typeParameters = _TypeParameterDeclarations(this.typeParameters); - typeParameters.createFragments(); - typeParameters.resolve(functionScope); + typeParameters.materializeStandalone(functionScope); var formalParameters = _FormalParameterDeclarations(this.formalParameters); formalParameters.createFragments(); @@ -870,6 +868,26 @@ class _ParsedNullableType implements _ParsedType { } } +class _ParsedPromotedType implements _ParsedType { + final _ParsedType base; + final _ParsedType promotedBound; + + _ParsedPromotedType({required this.base, required this.promotedBound}); + + @override + TypeImpl materialize(_Scope scope) { + var baseType = base.materialize(scope); + if (baseType is! TypeParameterTypeImpl) { + throw StateError('Cannot promote a non-type-parameter type: $baseType'); + } + return TypeParameterTypeImpl( + element: baseType.element, + nullabilitySuffix: baseType.nullabilitySuffix, + promotedBound: promotedBound.materialize(scope), + ); + } +} + class _ParsedRecordType implements _ParsedType { final List<({String name, _ParsedType type})> namedFields; final List<_ParsedType> positionalFields; @@ -949,6 +967,48 @@ class _Scope { : _interfaces = parent._interfaces, _typeAliases = parent._typeAliases; + factory _Scope.forLibraries({ + required List libraries, + List typeParameters = const [], + }) { + var interfaces = {}; + var typeAliases = {}; + + for (var library in libraries) { + for (var element in library.classes) { + if (element.name case var name?) { + interfaces[name] = element; + } + } + for (var element in library.enums) { + if (element.name case var name?) { + interfaces[name] = element; + } + } + for (var element in library.extensionTypes) { + if (element.name case var name?) { + interfaces[name] = element; + } + } + for (var element in library.mixins) { + if (element.name case var name?) { + interfaces[name] = element; + } + } + for (var element in library.typeAliases) { + if (element.name case var name?) { + typeAliases[name] = element; + } + } + } + + var scope = _Scope.root(interfaces: interfaces, typeAliases: typeAliases); + for (var typeParameter in typeParameters) { + scope.addTypeParameter(typeParameter); + } + return scope; + } + /// Creates a root scope containing all known interfaces. _Scope.root({ required Map interfaces, @@ -1143,6 +1203,7 @@ class _SpecParser { kind = ParameterKind.NAMED_REQUIRED; } + var isCovariant = _stream.match('covariant'); var type = _parseType(); String? name; @@ -1150,7 +1211,12 @@ class _SpecParser { name = _stream.consume(); } - return _ParsedFormalParameter(type: type, name: name, kind: kind); + return _ParsedFormalParameter( + isCovariant: isCovariant, + type: type, + name: name, + kind: kind, + ); } List<_ParsedFormalParameter> _parseFormalParameters() { @@ -1276,44 +1342,17 @@ class _SpecParser { return _parseTypeParametersRest(context: context); } - _ParsedType _parsePrimaryType() { - if (_stream.peekIs('(')) { - return _parseRecordType(); - } - - var name = _stream.consume(); - switch (name) { - case 'dynamic': - return _ParsedExplicitType(type: DynamicTypeImpl.instance); - case 'Never': - return _ParsedExplicitType(type: NeverTypeImpl.instance); - case 'void': - return _ParsedExplicitType(type: VoidTypeImpl.instance); - } - - var args = <_ParsedType>[]; - if (_stream.match('<')) { - while (!_stream.isAtEnd && !_stream.peekIs('>')) { - args.add(_parseType()); - _stream.match(','); - } - _stream.expect('>'); - } - return _ParsedNamedType(name: name, args: args); - } - - _ParsedRecordType _parseRecordType() { + _ParsedType _parseParenthesizedOrRecordType() { _stream.expect('('); var positionalFields = <_ParsedType>[]; var namedFields = <({String name, _ParsedType type})>[]; + var hasComma = false; while (!_stream.isAtEnd && !_stream.peekIsAnyOf(const {')', '{'})) { positionalFields.add(_parseType()); - if (!_stream.match(',')) { - break; - } - if (_stream.peekIsAnyOf(const {')', '{'})) { + hasComma = _stream.match(','); + if (!hasComma) { break; } } @@ -1329,34 +1368,82 @@ class _SpecParser { } _stream.expect(')'); + + // If there is exactly one positional field, no trailing comma, and no + // named fields, it is a parenthesized type, not a record type. + // Example: `(int)` is parenthesized, but `(int,)` is a record. + if (positionalFields.length == 1 && !hasComma && namedFields.isEmpty) { + return positionalFields[0]; + } + return _ParsedRecordType( positionalFields: positionalFields, namedFields: namedFields, ); } + _ParsedType _parsePrimaryType() { + if (_stream.peekIs('(')) { + return _parseParenthesizedOrRecordType(); + } + + var name = _stream.consume(); + switch (name) { + case 'dynamic': + return _ParsedExplicitType(type: DynamicTypeImpl.instance); + case 'InvalidType': + return _ParsedExplicitType(type: InvalidTypeImpl.instance); + case 'Never': + return _ParsedExplicitType(type: NeverTypeImpl.instance); + case 'UnknownInferredType': + return _ParsedExplicitType(type: UnknownInferredType.instance); + case 'void': + return _ParsedExplicitType(type: VoidTypeImpl.instance); + } + + var args = <_ParsedType>[]; + if (_stream.match('<')) { + while (!_stream.isAtEnd && !_stream.peekIs('>')) { + args.add(_parseType()); + _stream.match(','); + } + _stream.expect('>'); + } + return _ParsedNamedType(name: name, args: args); + } + _ParsedType _parseType() { var type = _parsePrimaryType(); - if (_stream.match('Function')) { - var typeParameters = _parseOptionalTypeParameters( - context: _TypeParameterContext.genericFunctionType, - ); + while (true) { + if (_stream.match('?')) { + type = _ParsedNullableType(inner: type); + continue; + } - _stream.expect('('); - var formalParameters = _parseFormalParameters(); - _stream.expect(')'); - type = _ParsedFunctionType( - returnType: type, - formalParameters: formalParameters, - typeParameters: typeParameters, - ); - } + if (_stream.match('Function')) { + var typeParameters = _parseOptionalTypeParameters( + context: _TypeParameterContext.genericFunctionType, + ); - if (_stream.match('?')) { - return _ParsedNullableType(inner: type); + _stream.expect('('); + var formalParameters = _parseFormalParameters(); + _stream.expect(')'); + type = _ParsedFunctionType( + returnType: type, + formalParameters: formalParameters, + typeParameters: typeParameters, + ); + continue; + } + + if (_stream.match('&')) { + type = _ParsedPromotedType(base: type, promotedBound: _parseType()); + continue; + } + + return type; } - return type; } _ParsedTypeAliasHeader _parseTypeAliasHeader() { @@ -1466,10 +1553,32 @@ class _SpecParser { )._parseExecutableHeader(_ExecutableHeaderContext.topLevelFunction); } + static _ParsedType parseType(String input) { + var parser = _SpecParser._(input); + var type = parser._parseType(); + parser._expectEnd('Unexpected trailing tokens in type.'); + return type; + } + static _ParsedTypeAliasHeader parseTypeAliasHeader(String input) { return _SpecParser._(input)._parseTypeAliasHeader(); } + static List<_ParsedTypeParameter> parseTypeParameters(String input) { + input = input.trim(); + if (!input.startsWith('<')) { + input = '<$input>'; + } + + var parser = _SpecParser._(input); + parser._stream.expect('<'); + var typeParameters = parser._parseTypeParametersRest( + context: _TypeParameterContext.classDeclaration, + ); + parser._expectEnd('Unexpected trailing tokens in type parameters.'); + return typeParameters; + } + static Variance? _varianceForKeyword(String keyword) { switch (keyword) { case 'out': @@ -1485,7 +1594,7 @@ class _SpecParser { class _TokenStream { static final RegExp _tokenizer = RegExp( - r'[a-zA-Z_]\w*|<|>|\+|-|\*|/|%|~|&|\||\^|,|\?|\(|\)|\{|\}|\[|\]|=|;', + r'[$a-zA-Z_][$\w]*|<|>|\+|-|\*|/|%|~|&|\||\^|,|\?|\(|\)|\{|\}|\[|\]|=|;', ); final List _tokens; @@ -1612,7 +1721,7 @@ class _TypeAliasDeclaration { enum _TypeParameterContext { classDeclaration(allowsVariance: true), extensionTypeDeclaration(allowsVariance: true), - genericFunctionType(allowsVariance: false), + genericFunctionType(allowsVariance: true), methodDeclaration(allowsVariance: false), mixinDeclaration(allowsVariance: true), topLevelFunctionDeclaration(allowsVariance: false), @@ -1625,13 +1734,16 @@ enum _TypeParameterContext { class _TypeParameterDeclaration { final _ParsedTypeParameter parsed; - late final TypeParameterFragmentImpl fragment; _TypeParameterDeclaration(this.parsed); TypeParameterElementImpl get element => fragment.element; + void createElement() { + TypeParameterElementImpl(firstFragment: fragment); + } + TypeParameterFragmentImpl createFragment() { return fragment = TypeParameterFragmentImpl(name: parsed.name); } @@ -1658,12 +1770,25 @@ class _TypeParameterDeclarations { for (var declaration in _declarations) declaration.element, ]; + void createElements() { + for (var declaration in _declarations) { + declaration.createElement(); + } + } + List createFragments() { return [ for (var declaration in _declarations) declaration.createFragment(), ]; } + List materializeStandalone(_Scope scope) { + createFragments(); + createElements(); + resolve(scope); + return elements; + } + void resolve(_Scope scope) { for (var declaration in _declarations) { scope.addTypeParameter(declaration.element); diff --git a/pkg/analyzer/test/generated/elements_types_mixin.dart b/pkg/analyzer/test/generated/elements_types_mixin.dart deleted file mode 100644 index 45bdfe4fcdf..00000000000 --- a/pkg/analyzer/test/generated/elements_types_mixin.dart +++ /dev/null @@ -1,442 +0,0 @@ -// Copyright (c) 2019, 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:_fe_analyzer_shared/src/types/shared_type.dart'; -import 'package:analyzer/dart/element/nullability_suffix.dart'; -import 'package:analyzer/src/dart/element/element.dart'; -import 'package:analyzer/src/dart/element/type.dart'; -import 'package:analyzer/src/dart/element/type_provider.dart'; -import 'package:analyzer/src/dart/element/type_schema.dart'; -import 'package:analyzer/src/generated/utilities_dart.dart'; - -mixin ElementsTypesMixin { - InterfaceTypeImpl get boolNone { - var element = typeProvider.boolElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get boolQuestion { - var element = typeProvider.boolElement; - return interfaceTypeQuestion(element); - } - - InterfaceTypeImpl get doubleNone { - var element = typeProvider.doubleElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get doubleQuestion { - var element = typeProvider.doubleElement; - return interfaceTypeQuestion(element); - } - - TypeImpl get dynamicType => DynamicTypeImpl.instance; - - InterfaceTypeImpl get functionNone { - var element = typeProvider.functionElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get functionQuestion { - var element = typeProvider.functionElement; - return interfaceTypeQuestion(element); - } - - InterfaceTypeImpl get intNone { - var element = typeProvider.intElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get intQuestion { - var element = typeProvider.intElement; - return interfaceTypeQuestion(element); - } - - TypeImpl get invalidType => InvalidTypeImpl.instance; - - NeverTypeImpl get neverNone => NeverTypeImpl.instance; - - NeverTypeImpl get neverQuestion => NeverTypeImpl.instanceNullable; - - InterfaceTypeImpl get nullNone { - var element = typeProvider.nullElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get numNone { - var element = typeProvider.numElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get numQuestion { - var element = typeProvider.numElement; - return interfaceTypeQuestion(element); - } - - InterfaceTypeImpl get objectNone { - var element = typeProvider.objectElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get objectQuestion { - var element = typeProvider.objectElement; - return interfaceTypeQuestion(element); - } - - InterfaceTypeImpl get recordNone { - var element = typeProvider.recordElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get stringNone { - var element = typeProvider.stringElement; - return interfaceTypeNone(element); - } - - InterfaceTypeImpl get stringQuestion { - var element = typeProvider.stringElement; - return interfaceTypeQuestion(element); - } - - LibraryElementImpl get testLibrary => throw UnimplementedError(); - - TypeProviderImpl get typeProvider; - - TypeImpl get unknownInferredType => UnknownInferredType.instance; - - VoidTypeImpl get voidNone => VoidTypeImpl.instance; - - InterfaceTypeImpl comparableNone(TypeImpl type) { - var coreLibrary = typeProvider.intElement.library; - var element = coreLibrary.getClass('Comparable')!; - return element.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl comparableQuestion(TypeImpl type) { - var coreLibrary = typeProvider.intElement.library; - var element = coreLibrary.getClass('Comparable')!; - return element.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - FunctionTypeImpl functionType({ - required List typeParameters, - required List formalParameters, - required TypeImpl returnType, - required NullabilitySuffix nullabilitySuffix, - }) { - return FunctionTypeImpl.v2( - typeParameters: typeParameters, - formalParameters: formalParameters, - returnType: returnType, - nullabilitySuffix: nullabilitySuffix, - ); - } - - FunctionTypeImpl functionTypeNone({ - List typeParameters = const [], - List formalParameters = const [], - required TypeImpl returnType, - }) { - return functionType( - typeParameters: typeParameters, - formalParameters: formalParameters, - returnType: returnType, - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - FunctionTypeImpl functionTypeQuestion({ - List typeParameters = const [], - List formalParameters = const [], - required TypeImpl returnType, - }) { - return functionType( - typeParameters: typeParameters, - formalParameters: formalParameters, - returnType: returnType, - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - InterfaceTypeImpl futureNone(TypeImpl type) { - return typeProvider.futureElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl futureOrNone(TypeImpl type) { - return typeProvider.futureOrElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl futureOrQuestion(TypeImpl type) { - return typeProvider.futureOrElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - InterfaceTypeImpl futureQuestion(TypeImpl type) { - return typeProvider.futureElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - InterfaceTypeImpl interfaceTypeNone( - InterfaceElementImpl element, { - List typeArguments = const [], - }) { - return element.instantiateImpl( - typeArguments: typeArguments, - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl interfaceTypeQuestion( - InterfaceElementImpl element, { - List typeArguments = const [], - }) { - return element.instantiateImpl( - typeArguments: typeArguments, - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - InterfaceTypeImpl iterableNone(TypeImpl type) { - return typeProvider.iterableElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl iterableQuestion(TypeImpl type) { - return typeProvider.iterableElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - InterfaceTypeImpl listNone(TypeImpl type) { - return typeProvider.listElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl listQuestion(TypeImpl type) { - return typeProvider.listElement.instantiateImpl( - typeArguments: [type], - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - InterfaceTypeImpl mapNone(TypeImpl key, TypeImpl value) { - return typeProvider.mapElement.instantiateImpl( - typeArguments: [key, value], - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - InterfaceTypeImpl mapQuestion(TypeImpl key, TypeImpl value) { - return typeProvider.mapElement.instantiateImpl( - typeArguments: [key, value], - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - FormalParameterElementImpl namedParameter({ - required String name, - required TypeImpl type, - bool isCovariant = false, - }) { - var fragment = FormalParameterFragmentImpl( - name: name, - nameOffset: 0, - parameterKind: ParameterKind.NAMED, - ); - fragment.isExplicitlyCovariant = isCovariant; - return FormalParameterElementImpl(fragment)..type = type; - } - - FormalParameterElementImpl namedRequiredParameter({ - required String name, - required TypeImpl type, - bool isCovariant = false, - }) { - var fragment = FormalParameterFragmentImpl( - name: name, - nameOffset: 0, - parameterKind: ParameterKind.NAMED_REQUIRED, - ); - fragment.isExplicitlyCovariant = isCovariant; - return FormalParameterElementImpl(fragment)..type = type; - } - - FormalParameterElementImpl positionalParameter({ - String? name, - required TypeImpl type, - bool isCovariant = false, - }) { - var fragment = FormalParameterFragmentImpl( - name: name, - nameOffset: 0, - parameterKind: ParameterKind.POSITIONAL, - ); - fragment.isExplicitlyCovariant = isCovariant; - return FormalParameterElementImpl(fragment)..type = type; - } - - TypeParameterTypeImpl promotedTypeParameterType({ - required TypeParameterElementImpl element, - required NullabilitySuffix nullabilitySuffix, - required TypeImpl promotedBound, - }) { - return TypeParameterTypeImpl( - element: element, - nullabilitySuffix: nullabilitySuffix, - promotedBound: promotedBound, - ); - } - - TypeParameterTypeImpl promotedTypeParameterTypeNone( - TypeParameterElementImpl element, - TypeImpl promotedBound, - ) { - return promotedTypeParameterType( - element: element, - nullabilitySuffix: NullabilitySuffix.none, - promotedBound: promotedBound, - ); - } - - TypeParameterTypeImpl promotedTypeParameterTypeQuestion( - TypeParameterElementImpl element, - TypeImpl promotedBound, - ) { - return promotedTypeParameterType( - element: element, - nullabilitySuffix: NullabilitySuffix.question, - promotedBound: promotedBound, - ); - } - - RecordTypeImpl recordType({ - List positionalTypes = const [], - Map namedTypes = const {}, - required NullabilitySuffix nullabilitySuffix, - }) { - return RecordTypeImpl( - positionalFields: positionalTypes.map((type) { - return RecordTypePositionalFieldImpl(type: type); - }).toList(), - namedFields: namedTypes.entries.map((entry) { - return RecordTypeNamedFieldImpl(name: entry.key, type: entry.value); - }).toList(), - nullabilitySuffix: nullabilitySuffix, - ); - } - - RecordTypeImpl recordTypeNone({ - List positionalTypes = const [], - Map namedTypes = const {}, - }) { - return recordType( - positionalTypes: positionalTypes, - namedTypes: namedTypes, - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - RecordTypeImpl recordTypeQuestion({ - List positionalTypes = const [], - Map namedTypes = const {}, - }) { - return recordType( - positionalTypes: positionalTypes, - namedTypes: namedTypes, - nullabilitySuffix: NullabilitySuffix.question, - ); - } - - FormalParameterElementImpl requiredParameter({ - String? name, - required TypeImpl type, - bool isCovariant = false, - }) { - var fragment = FormalParameterFragmentImpl( - name: name, - nameOffset: 0, - parameterKind: ParameterKind.REQUIRED, - ); - fragment.isExplicitlyCovariant = isCovariant; - return FormalParameterElementImpl(fragment)..type = type; - } - - TypeImpl typeAliasTypeNone( - TypeAliasElementImpl element, { - List typeArguments = const [], - }) { - return element.instantiateImpl( - typeArguments: typeArguments, - nullabilitySuffix: NullabilitySuffix.none, - ); - } - - TypeParameterElementImpl typeParameter( - String name, { - TypeImpl? bound, - Variance? variance, - }) { - var fragment = TypeParameterFragmentImpl(name: name); - - var element = TypeParameterElementImpl(firstFragment: fragment); - element.bound = bound; - element.variance = variance; - return element; - } - - TypeParameterTypeImpl typeParameterType( - TypeParameterElementImpl element, { - required NullabilitySuffix nullabilitySuffix, - TypeImpl? promotedBound, - }) { - return TypeParameterTypeImpl( - element: element, - nullabilitySuffix: nullabilitySuffix, - promotedBound: promotedBound, - ); - } - - TypeParameterTypeImpl typeParameterTypeNone( - TypeParameterElementImpl element, { - TypeImpl? promotedBound, - }) { - return typeParameterType( - element, - nullabilitySuffix: NullabilitySuffix.none, - promotedBound: promotedBound, - ); - } - - TypeParameterTypeImpl typeParameterTypeQuestion( - TypeParameterElementImpl element, { - TypeImpl? promotedBound, - }) { - return typeParameterType( - element, - nullabilitySuffix: NullabilitySuffix.question, - promotedBound: promotedBound, - ); - } -} diff --git a/pkg/analyzer/test/generated/type_system_base.dart b/pkg/analyzer/test/generated/type_system_base.dart index ef153b11925..cb274a4ae35 100644 --- a/pkg/analyzer/test/generated/type_system_base.dart +++ b/pkg/analyzer/test/generated/type_system_base.dart @@ -3,23 +3,23 @@ // BSD-style license that can be found in the LICENSE file. import 'package:analyzer/src/dart/element/element.dart'; +import 'package:analyzer/src/dart/element/type.dart'; import 'package:analyzer/src/dart/element/type_provider.dart'; import 'package:analyzer/src/dart/element/type_system.dart'; import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart'; import 'package:analyzer/src/test_utilities/test_library_builder.dart'; -import 'elements_types_mixin.dart'; import 'test_analysis_context.dart'; -abstract class AbstractTypeSystemTest with ElementsTypesMixin { +abstract class AbstractTypeSystemTest { static const _testLibraryUri = 'package:test/test.dart'; + bool _hasTestLibrary = false; + late TestAnalysisContext analysisContext; - @override late LibraryElementImpl testLibrary; - @override late TypeProviderImpl typeProvider; late TypeSystemImpl typeSystem; @@ -73,6 +73,7 @@ abstract class AbstractTypeSystemTest with ElementsTypesMixin { typeAliases: typeAliases, ), }, externalLibraries: externalLibraries)[_testLibraryUri]!; + _hasTestLibrary = true; return testLibrary; } @@ -92,8 +93,43 @@ abstract class AbstractTypeSystemTest with ElementsTypesMixin { return testLibrary.getMixin(name)!; } + FunctionTypeImpl parseFunctionType( + String input, { + List? libraries, + }) { + return _typeParsingScope(libraries: libraries).parseFunctionType(input); + } + + InterfaceTypeImpl parseInterfaceType( + String input, { + List? libraries, + }) { + return _typeParsingScope(libraries: libraries).parseInterfaceType(input); + } + + RecordTypeImpl parseRecordType( + String input, { + List? libraries, + }) { + return _typeParsingScope(libraries: libraries).parseRecordType(input); + } + + TypeImpl parseType(String input, {List? libraries}) { + return _typeParsingScope(libraries: libraries).parseType(input); + } + + TypeParameterTypeImpl parseTypeParameterType( + String input, { + List? libraries, + }) { + return _typeParsingScope( + libraries: libraries, + ).parseTypeParameterType(input); + } + void setUp() { analysisContext = TestAnalysisContext(); + _hasTestLibrary = false; typeProvider = analysisContext.typeProvider; typeSystem = analysisContext.typeSystem; typeSystemOperations = TypeSystemOperations( @@ -105,4 +141,99 @@ abstract class AbstractTypeSystemTest with ElementsTypesMixin { TypeAliasElementImpl typeAliasElement(String name) { return testLibrary.getTypeAlias(name)! as TypeAliasElementImpl; } + + R withTypeParameterScope( + String spec, + R Function(TypeParsingScope scope) operation, { + List? libraries, + List typeParameters = const [], + }) { + return _typeParsingScope( + libraries: libraries, + typeParameters: typeParameters, + ).withTypeParameterScope(spec, operation); + } + + TypeParsingScope _typeParsingScope({ + List? libraries, + List typeParameters = const [], + }) { + return TypeParsingScope( + libraries: + libraries ?? + [ + analysisContext.coreLibrary, + analysisContext.asyncLibrary, + if (_hasTestLibrary) testLibrary, + ], + typeParameters: typeParameters, + ); + } +} + +/// Parses test type specs against a fixed library and type-parameter scope. +class TypeParsingScope { + final List _libraries; + final List _typeParameters; + + TypeParsingScope({ + required List libraries, + required List typeParameters, + }) : _libraries = List.unmodifiable(libraries), + _typeParameters = List.unmodifiable(typeParameters); + + FunctionTypeImpl parseFunctionType(String input) { + return parseType(input); + } + + InterfaceTypeImpl parseInterfaceType(String input) { + return parseType(input); + } + + RecordTypeImpl parseRecordType(String input) { + return parseType(input); + } + + T parseType(String input) { + var type = TypeSpecParser( + libraries: _libraries, + typeParameters: _typeParameters, + ).parse(input); + + if (type is T) { + return type; + } + throw StateError('Expected $T for "$input", got: $type'); + } + + TypeParameterTypeImpl parseTypeParameterType(String input) { + return parseType(input); + } + + TypeParameterElementImpl typeParameter(String name) { + for (var i = _typeParameters.length - 1; i >= 0; i--) { + var element = _typeParameters[i]; + if (element.name == name) { + return element; + } + } + throw StateError('Unknown type parameter: $name'); + } + + R withTypeParameterScope( + String spec, + R Function(TypeParsingScope scope) operation, + ) { + var newTypeParameters = TypeSpecParser( + libraries: _libraries, + typeParameters: _typeParameters, + ).parseTypeParameters(spec); + + return operation( + TypeParsingScope( + libraries: _libraries, + typeParameters: [..._typeParameters, ...newTypeParameters], + ), + ); + } } diff --git a/pkg/analyzer/test/generated/type_system_test.dart b/pkg/analyzer/test/generated/type_system_test.dart index a9f3303dea3..b2588a4d950 100644 --- a/pkg/analyzer/test/generated/type_system_test.dart +++ b/pkg/analyzer/test/generated/type_system_test.dart @@ -30,14 +30,14 @@ class TryPromoteToTest extends AbstractTypeSystemTest { } test_interface() { - promotes(intNone, intNone); - promotes(intQuestion, intNone); + promotes(parseType('int'), parseType('int')); + promotes(parseType('int?'), parseType('int')); - promotes(numNone, intNone); - promotes(numQuestion, intNone); + promotes(parseType('num'), parseType('int')); + promotes(parseType('num?'), parseType('int')); - notPromotes(intNone, doubleNone); - notPromotes(intNone, intQuestion); + notPromotes(parseType('int'), parseType('double')); + notPromotes(parseType('int'), parseType('int?')); } test_typeParameter() { @@ -49,15 +49,16 @@ class TryPromoteToTest extends AbstractTypeSystemTest { expect(type.getDisplayString(), expected); } - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); - var T_question = typeParameterTypeQuestion(T); + withTypeParameterScope('T', (scope) { + var T_none = scope.parseTypeParameterType('T'); + var T_question = scope.parseTypeParameterType('T?'); - check(tryPromote(numNone, T_none), 'T & num'); - check(tryPromote(numQuestion, T_none), 'T & num?'); + check(tryPromote(parseType('num'), T_none), 'T & num'); + check(tryPromote(parseType('num?'), T_none), 'T & num?'); - check(tryPromote(numNone, T_question), 'T & num'); - check(tryPromote(numQuestion, T_question), '(T & num?)?'); + check(tryPromote(parseType('num'), T_question), 'T & num'); + check(tryPromote(parseType('num?'), T_question), '(T & num?)?'); + }); } test_typeParameter_twice() { @@ -76,13 +77,15 @@ class TryPromoteToTest extends AbstractTypeSystemTest { expect(type.promotedBound, promotedBound); } - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var T_none = scope.parseTypeParameterType('T'); - var T1 = tryPromote(numNone, T_none); - check(T1, T, NullabilitySuffix.none, numNone); + var T1 = tryPromote(parseType('num'), T_none); + check(T1, T, NullabilitySuffix.none, parseType('num')); - var T2 = tryPromote(intNone, T1); - check(T2, T, NullabilitySuffix.none, intNone); + var T2 = tryPromote(parseType('int'), T1); + check(T2, T, NullabilitySuffix.none, parseType('int')); + }); } } diff --git a/pkg/analyzer/test/src/dart/constant/has_type_parameter_reference_test.dart b/pkg/analyzer/test/src/dart/constant/has_type_parameter_reference_test.dart index 6293a1d4c89..4832fa79552 100644 --- a/pkg/analyzer/test/src/dart/constant/has_type_parameter_reference_test.dart +++ b/pkg/analyzer/test/src/dart/constant/has_type_parameter_reference_test.dart @@ -18,51 +18,39 @@ main() { @reflectiveTest class HasTypeParameterReferenceTest extends AbstractTypeSystemTest { test_dynamic() { - _checkFalse(dynamicType); + _checkFalse(parseType('dynamic')); } test_functionType() { - _checkFalse(functionTypeNone(returnType: voidNone)); + _checkFalse(parseType('void Function()')); - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); - - _checkTrue(functionTypeNone(returnType: T_none)); - - _checkTrue( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ), - ); - - _checkTrue( - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('S', bound: T_none)], - ), - ); + withTypeParameterScope('T', (scope) { + _checkTrue(scope.parseType('T Function()')); + _checkTrue(scope.parseType('void Function(T)')); + _checkTrue(scope.parseType('void Function()')); + }); } test_interfaceType() { - _checkFalse(intNone); - _checkFalse(intQuestion); + _checkFalse(parseType('int')); + _checkFalse(parseType('int?')); - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); - _checkTrue(listNone(T_none)); - _checkTrue(mapNone(T_none, intNone)); - _checkTrue(mapNone(intNone, T_none)); + withTypeParameterScope('T', (scope) { + _checkTrue(scope.parseType('List')); + _checkTrue(scope.parseType('Map')); + _checkTrue(scope.parseType('Map')); + }); } test_typeParameter() { - var T = typeParameter('T'); - _checkTrue(typeParameterTypeNone(T)); - _checkTrue(typeParameterTypeQuestion(T)); + withTypeParameterScope('T', (scope) { + _checkTrue(scope.parseType('T')); + _checkTrue(scope.parseType('T?')); + }); } test_void() { - _checkFalse(voidNone); + _checkFalse(parseType('void')); } void _checkFalse(DartType type) { diff --git a/pkg/analyzer/test/src/dart/element/always_exhaustive_test.dart b/pkg/analyzer/test/src/dart/element/always_exhaustive_test.dart index 57d61b42225..13cdea734e4 100644 --- a/pkg/analyzer/test/src/dart/element/always_exhaustive_test.dart +++ b/pkg/analyzer/test/src/dart/element/always_exhaustive_test.dart @@ -26,92 +26,85 @@ class IsAlwaysExhaustiveTest extends AbstractTypeSystemTest { } test_class_bool() { - isAlwaysExhaustive(boolNone); - isAlwaysExhaustive(boolQuestion); + isAlwaysExhaustive(parseType('bool')); + isAlwaysExhaustive(parseType('bool?')); } test_class_int() { - isNotAlwaysExhaustive(intNone); - isNotAlwaysExhaustive(intQuestion); + isNotAlwaysExhaustive(parseType('int')); + isNotAlwaysExhaustive(parseType('int?')); } test_class_Null() { - isAlwaysExhaustive(nullNone); + isAlwaysExhaustive(parseType('Null')); } test_class_sealed() { buildTestLibrary(classes: [ClassSpec('sealed class A')]); - var A = classElement('A'); - isAlwaysExhaustive(interfaceTypeNone(A)); - isAlwaysExhaustive(interfaceTypeQuestion(A)); + isAlwaysExhaustive(parseType('A')); + isAlwaysExhaustive(parseType('A?')); } test_enum() { buildTestLibrary(enums: [EnumSpec('enum E')]); - var E = enumElement('E'); - isAlwaysExhaustive(interfaceTypeNone(E)); - isAlwaysExhaustive(interfaceTypeQuestion(E)); + isAlwaysExhaustive(parseType('E')); + isAlwaysExhaustive(parseType('E?')); } test_extensionType() { buildTestLibrary( extensionTypes: [ExtensionTypeSpec('extension type A(bool it)')], ); - isAlwaysExhaustive(interfaceTypeNone(extensionTypeElement('A'))); + isAlwaysExhaustive(parseType('A')); buildTestLibrary( extensionTypes: [ExtensionTypeSpec('extension type A(bool? it)')], ); - isAlwaysExhaustive(interfaceTypeNone(extensionTypeElement('A'))); + isAlwaysExhaustive(parseType('A')); buildTestLibrary( extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], ); - isNotAlwaysExhaustive(interfaceTypeNone(extensionTypeElement('A'))); + isNotAlwaysExhaustive(parseType('A')); } test_futureOr() { - isAlwaysExhaustive(futureOrNone(boolNone)); - isAlwaysExhaustive(futureOrQuestion(boolNone)); + isAlwaysExhaustive(parseType('FutureOr')); + isAlwaysExhaustive(parseType('FutureOr?')); - isAlwaysExhaustive(futureOrNone(boolQuestion)); - isAlwaysExhaustive(futureOrQuestion(boolQuestion)); + isAlwaysExhaustive(parseType('FutureOr')); + isAlwaysExhaustive(parseType('FutureOr?')); - isNotAlwaysExhaustive(futureOrNone(intNone)); - isNotAlwaysExhaustive(futureOrQuestion(intNone)); + isNotAlwaysExhaustive(parseType('FutureOr')); + isNotAlwaysExhaustive(parseType('FutureOr?')); } test_recordType() { - isAlwaysExhaustive(recordTypeNone(positionalTypes: [boolNone])); + isAlwaysExhaustive(parseType('(bool,)')); - isAlwaysExhaustive(recordTypeNone(namedTypes: {'f0': boolNone})); + isAlwaysExhaustive(parseType('({bool f0})')); - isNotAlwaysExhaustive(recordTypeNone(positionalTypes: [intNone])); + isNotAlwaysExhaustive(parseType('(int,)')); - isNotAlwaysExhaustive(recordTypeNone(positionalTypes: [boolNone, intNone])); + isNotAlwaysExhaustive(parseType('(bool, int)')); - isNotAlwaysExhaustive(recordTypeNone(namedTypes: {'f0': intNone})); + isNotAlwaysExhaustive(parseType('({int f0})')); - isNotAlwaysExhaustive( - recordTypeNone(namedTypes: {'f0': boolNone, 'f1': intNone}), - ); + isNotAlwaysExhaustive(parseType('({bool f0, int f1})')); } test_typeParameter() { - isAlwaysExhaustive( - typeParameterTypeNone(typeParameter('T', bound: boolNone)), - ); + withTypeParameterScope('T extends bool', (scope) { + isAlwaysExhaustive(scope.parseType('T')); + }); - isNotAlwaysExhaustive( - typeParameterTypeNone(typeParameter('T', bound: numNone)), - ); + withTypeParameterScope('T extends num', (scope) { + isNotAlwaysExhaustive(scope.parseType('T')); + }); - isAlwaysExhaustive( - typeParameterTypeNone(typeParameter('T'), promotedBound: boolNone), - ); - - isNotAlwaysExhaustive( - typeParameterTypeNone(typeParameter('T'), promotedBound: intNone), - ); + withTypeParameterScope('T', (scope) { + isAlwaysExhaustive(scope.parseType('T & bool')); + isNotAlwaysExhaustive(scope.parseType('T & int')); + }); } } diff --git a/pkg/analyzer/test/src/dart/element/assignable_test.dart b/pkg/analyzer/test/src/dart/element/assignable_test.dart index 7579a31046b..01270cb6848 100644 --- a/pkg/analyzer/test/src/dart/element/assignable_test.dart +++ b/pkg/analyzer/test/src/dart/element/assignable_test.dart @@ -33,21 +33,21 @@ class IsAssignableToTest extends AbstractTypeSystemTest { } test_dynamicType() { - isAssignable(dynamicType, dynamicType); - isAssignable(dynamicType, invalidType); - isAssignable(dynamicType, intNone); + isAssignable(parseType('dynamic'), parseType('dynamic')); + isAssignable(parseType('dynamic'), parseType('InvalidType')); + isAssignable(parseType('dynamic'), parseType('int')); } test_interfaceType() { - isAssignable(intNone, numNone); - isAssignable(doubleNone, numNone); + isAssignable(parseType('int'), parseType('num')); + isAssignable(parseType('double'), parseType('num')); - isNotAssignable(numNone, intNone); + isNotAssignable(parseType('num'), parseType('int')); } test_invalidType() { - isAssignable(invalidType, invalidType); - isAssignable(invalidType, dynamicType); - isAssignable(invalidType, intNone); + isAssignable(parseType('InvalidType'), parseType('InvalidType')); + isAssignable(parseType('InvalidType'), parseType('dynamic')); + isAssignable(parseType('InvalidType'), parseType('int')); } } diff --git a/pkg/analyzer/test/src/dart/element/element_test.dart b/pkg/analyzer/test/src/dart/element/element_test.dart index 86a4c424a8e..041d2327de1 100644 --- a/pkg/analyzer/test/src/dart/element/element_test.dart +++ b/pkg/analyzer/test/src/dart/element/element_test.dart @@ -2,6 +2,7 @@ // 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:_fe_analyzer_shared/src/types/shared_type.dart'; import 'package:analyzer/dart/constant/value.dart'; import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/type.dart'; @@ -74,121 +75,72 @@ class FunctionTypeImplTest extends AbstractTypeSystemTest { } void test_getNamedParameterTypes_namedParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [ - requiredParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: doubleNone), - namedParameter(name: 'c', type: stringNone), - ], - returnType: voidNone, - ); + var type = parseFunctionType('void Function(int a, {double b, String c})'); Map types = type.namedParameterTypes; expect(types, hasLength(2)); - expect(types['b'], doubleNone); - expect(types['c'], stringNone); + expect(types['b'], parseType('double')); + expect(types['c'], parseType('String')); } void test_getNamedParameterTypes_noNamedParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: doubleNone), - positionalParameter(type: stringNone), - ], - returnType: voidNone, - ); + var type = parseFunctionType('void Function(int, double, [String])'); Map types = type.namedParameterTypes; expect(types, hasLength(0)); } void test_getNamedParameterTypes_noParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [], - returnType: voidNone, - ); + var type = parseFunctionType('void Function()'); Map types = type.namedParameterTypes; expect(types, hasLength(0)); } void test_getNormalParameterTypes_noNormalParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: doubleNone), - ], - returnType: voidNone, - ); + var type = parseFunctionType('void Function([int, double])'); List types = type.normalParameterTypes; expect(types, hasLength(0)); } void test_getNormalParameterTypes_noParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [], - returnType: voidNone, - ); + var type = parseFunctionType('void Function()'); List types = type.normalParameterTypes; expect(types, hasLength(0)); } void test_getNormalParameterTypes_normalParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: doubleNone), - positionalParameter(type: stringNone), - ], - returnType: voidNone, - ); + var type = parseFunctionType('void Function(int, double, [String])'); List types = type.normalParameterTypes; expect(types, hasLength(2)); - expect(types[0], intNone); - expect(types[1], doubleNone); + expect(types[0], parseType('int')); + expect(types[1], parseType('double')); } void test_getOptionalParameterTypes_noOptionalParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [ - requiredParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: doubleNone), - ], - returnType: voidNone, - ); + var type = parseFunctionType('void Function(int a, {double b})'); List types = type.optionalParameterTypes; expect(types, hasLength(0)); } void test_getOptionalParameterTypes_noParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [], - returnType: voidNone, - ); + var type = parseFunctionType('void Function()'); List types = type.optionalParameterTypes; expect(types, hasLength(0)); } void test_getOptionalParameterTypes_optionalParameters() { - var type = functionTypeNone( - typeParameters: [], - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: doubleNone), - positionalParameter(type: stringNone), - ], - returnType: voidNone, - ); + var type = parseFunctionType('void Function(int, [double, String])'); List types = type.optionalParameterTypes; expect(types, hasLength(2)); - expect(types[0], doubleNone); - expect(types[1], stringNone); + expect(types[0], parseType('double')); + expect(types[1], parseType('String')); + } + + void test_typeParameters_variance() { + var type = parseFunctionType('void Function()'); + var typeParameters = type.typeParameters; + expect(typeParameters, hasLength(3)); + expect(typeParameters[0].variance, Variance.contravariant); + expect(typeParameters[1].variance, Variance.invariant); + expect(typeParameters[2].variance, Variance.covariant); } } @@ -481,59 +433,89 @@ class B extends A {} @reflectiveTest class TypeParameterTypeImplTest extends AbstractTypeSystemTest { void test_asInstanceOf_hasBound_element() { - var T = typeParameter('T', bound: listNone(intNone)); - _assert_asInstanceOf( - typeParameterTypeNone(T), - typeProvider.iterableElement, - 'Iterable', - ); + withTypeParameterScope('T extends List', (scope) { + _assert_asInstanceOf( + scope.parseType('T'), + typeProvider.iterableElement, + 'Iterable', + ); + }); } void test_asInstanceOf_hasBound_element_noMatch() { - var T = typeParameter('T', bound: numNone); - _assert_asInstanceOf( - typeParameterTypeNone(T), - typeProvider.iterableElement, - null, - ); + withTypeParameterScope('T extends num', (scope) { + _assert_asInstanceOf( + scope.parseType('T'), + typeProvider.iterableElement, + null, + ); + }); } void test_asInstanceOf_hasBound_promoted() { - var T = typeParameter('T'); - _assert_asInstanceOf( - typeParameterTypeNone(T, promotedBound: listNone(intNone)), - typeProvider.iterableElement, - 'Iterable', - ); + withTypeParameterScope('T', (scope) { + _assert_asInstanceOf( + scope.parseType('T & List'), + typeProvider.iterableElement, + 'Iterable', + ); + }); } void test_asInstanceOf_hasBound_promoted_noMatch() { - var T = typeParameter('T'); - _assert_asInstanceOf( - typeParameterTypeNone(T, promotedBound: numNone), - typeProvider.iterableElement, - null, - ); + withTypeParameterScope('T', (scope) { + _assert_asInstanceOf( + scope.parseType('T & num'), + typeProvider.iterableElement, + null, + ); + }); } void test_asInstanceOf_noBound() { - var T = typeParameter('T'); - _assert_asInstanceOf( - typeParameterTypeNone(T), - typeProvider.iterableElement, - null, - ); + withTypeParameterScope('T', (scope) { + _assert_asInstanceOf( + scope.parseType('T'), + typeProvider.iterableElement, + null, + ); + }); } void test_creation() { - var element = typeParameter('E'); - expect(typeParameterTypeNone(element), isNotNull); + withTypeParameterScope('E', (scope) { + var E = scope.typeParameter('E'); + expect(E, isNotNull); + expect(scope.parseTypeParameterType('E'), isNotNull); + }); } void test_getElement() { - var element = typeParameter('E'); - TypeParameterTypeImpl type = typeParameterTypeNone(element); - expect(type.element, element); + withTypeParameterScope('E', (scope) { + var E = scope.typeParameter('E'); + TypeParameterTypeImpl type = scope.parseTypeParameterType('E'); + expect(type.element, E); + }); + } + + void test_parse_promotedBound() { + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var type = scope.parseTypeParameterType('T & int'); + expect(type.element, same(T)); + expect(type.promotedBound, parseType('int')); + expect(type.getDisplayString(), 'T & int'); + }); + } + + void test_parse_promotedBound_question() { + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var type = scope.parseTypeParameterType('(T & int)?'); + expect(type.element, same(T)); + expect(type.promotedBound, parseType('int')); + expect(type.getDisplayString(), '(T & int)?'); + }); } void _assert_asInstanceOf( diff --git a/pkg/analyzer/test/src/dart/element/factor_type_test.dart b/pkg/analyzer/test/src/dart/element/factor_type_test.dart index 4deadbf63eb..90877622c33 100644 --- a/pkg/analyzer/test/src/dart/element/factor_type_test.dart +++ b/pkg/analyzer/test/src/dart/element/factor_type_test.dart @@ -2,15 +2,11 @@ // 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:_fe_analyzer_shared/src/flow_analysis/factory_type_test_helper.dart'; import 'package:analyzer/src/dart/element/type.dart'; -import 'package:analyzer/src/dart/element/type_provider.dart'; -import 'package:analyzer/src/dart/element/type_system.dart'; import 'package:test/test.dart' as test; import 'package:test_reflective_loader/test_reflective_loader.dart'; -import '../../../generated/elements_types_mixin.dart'; -import '../../../generated/test_analysis_context.dart'; +import '../../../generated/type_system_base.dart'; main() { defineReflectiveSuite(() { @@ -19,38 +15,72 @@ main() { } @reflectiveTest -class FactorTypeTest with FactorTypeTestMixin, ElementsTypesMixin { - @override - late final TypeProviderImpl typeProvider; - - late final TypeSystemImpl typeSystem; - - @override - TypeImpl get voidType => typeProvider.voidType; - - @override - void expect( - TypeImpl T, - TypeImpl S, - String actualResult, - String expectedResult, - ) { - test.expect(actualResult, expectedResult); +class FactorTypeTest extends AbstractTypeSystemTest { + void check(TypeImpl T, TypeImpl S, String expectedStr) { + TypeImpl result = typeSystem.factor(T, S); + String resultStr = result.getDisplayString(); + test.expect(resultStr, expectedStr); } - @override - TypeImpl factor(TypeImpl T, TypeImpl S) { - return typeSystem.factor(T, S); + void test_dynamic() { + check(parseType('dynamic'), parseType('int'), 'dynamic'); } - void setUp() { - var analysisContext = TestAnalysisContext(); - typeProvider = analysisContext.typeProvider; - typeSystem = analysisContext.typeSystem; + void test_futureOr() { + check(parseType('FutureOr'), parseType('int'), 'Future'); + check(parseType('FutureOr'), parseType('Future'), 'int'); + + check(parseType('FutureOr'), parseType('int'), 'FutureOr'); + check( + parseType('FutureOr'), + parseType('Future'), + 'FutureOr', + ); + check(parseType('FutureOr'), parseType('int?'), 'Future'); + check(parseType('FutureOr'), parseType('Future'), 'int?'); + + check(parseType('FutureOr'), parseType('num'), 'Future'); + check(parseType('FutureOr'), parseType('Future'), 'int'); } - @override - String typeString(covariant TypeImpl type) { - return type.getDisplayString(); + void test_object() { + check(parseType('Object'), parseType('Object'), 'Never'); + check(parseType('Object'), parseType('Object?'), 'Never'); + + check(parseType('Object'), parseType('int'), 'Object'); + check(parseType('Object'), parseType('int?'), 'Object'); + + check(parseType('Object?'), parseType('Object'), 'Never?'); + check(parseType('Object?'), parseType('Object?'), 'Never'); + + check(parseType('Object?'), parseType('int'), 'Object?'); + check(parseType('Object?'), parseType('int?'), 'Object'); + } + + void test_subtype() { + check(parseType('int'), parseType('int'), 'Never'); + check(parseType('int'), parseType('int?'), 'Never'); + + check(parseType('int?'), parseType('int'), 'Never?'); + check(parseType('int?'), parseType('int?'), 'Never'); + + check(parseType('int'), parseType('num'), 'Never'); + check(parseType('int'), parseType('num?'), 'Never'); + + check(parseType('int?'), parseType('num'), 'Never?'); + check(parseType('int?'), parseType('num?'), 'Never'); + + check(parseType('int'), parseType('Null'), 'int'); + check(parseType('int?'), parseType('Null'), 'int'); + + check(parseType('int'), parseType('String'), 'int'); + check(parseType('int?'), parseType('String'), 'int?'); + + check(parseType('int'), parseType('String?'), 'int'); + check(parseType('int?'), parseType('String?'), 'int'); + } + + void test_void() { + check(parseType('void'), parseType('int'), 'void'); } } diff --git a/pkg/analyzer/test/src/dart/element/flatten_type_test.dart b/pkg/analyzer/test/src/dart/element/flatten_type_test.dart index f363f239686..f3cf228f445 100644 --- a/pkg/analyzer/test/src/dart/element/flatten_type_test.dart +++ b/pkg/analyzer/test/src/dart/element/flatten_type_test.dart @@ -20,94 +20,81 @@ main() { @reflectiveTest class FlattenTypeTest extends AbstractTypeSystemTest { test_dynamic() { - _check(dynamicType, 'dynamic'); + _check(parseType('dynamic'), 'dynamic'); } test_interfaceType() { - _check(intNone, 'int'); - _check(intQuestion, 'int?'); + _check(parseType('int'), 'int'); + _check(parseType('int?'), 'int?'); } test_interfaceType_none_hasFutureType() { - _check(futureNone(intNone), 'int'); - _check(futureNone(intQuestion), 'int?'); + _check(parseType('Future'), 'int'); + _check(parseType('Future'), 'int?'); - _check(futureQuestion(intNone), 'int?'); - _check(futureQuestion(intQuestion), 'int?'); + _check(parseType('Future?'), 'int?'); + _check(parseType('Future?'), 'int?'); - _check(futureOrNone(intNone), 'int'); - _check(futureOrNone(intQuestion), 'int?'); + _check(parseType('FutureOr'), 'int'); + _check(parseType('FutureOr'), 'int?'); - _check(futureOrQuestion(intNone), 'int?'); - _check(futureOrQuestion(intQuestion), 'int?'); + _check(parseType('FutureOr?'), 'int?'); + _check(parseType('FutureOr?'), 'int?'); - _check(futureOrNone(futureNone(intNone)), 'Future'); - _check(futureOrNone(futureNone(intQuestion)), 'Future'); + _check(parseType('FutureOr>'), 'Future'); + _check(parseType('FutureOr>'), 'Future'); - _check(futureOrQuestion(futureNone(intNone)), 'Future?'); - _check(futureOrQuestion(futureNone(intQuestion)), 'Future?'); + _check(parseType('FutureOr>?'), 'Future?'); + _check(parseType('FutureOr>?'), 'Future?'); } test_interfaceType_question() { - _check(futureQuestion(intNone), 'int?'); - _check(futureQuestion(intQuestion), 'int?'); + _check(parseType('Future?'), 'int?'); + _check(parseType('Future?'), 'int?'); } test_typeParameterType_none() { // T extends Future - _check( - typeParameterTypeNone(typeParameter('T', bound: futureNone(intNone))), - 'int', - ); + withTypeParameterScope('T extends Future', (scope) { + _check(scope.parseType('T'), 'int'); + }); // T extends FutureOr - _check( - typeParameterTypeNone(typeParameter('T', bound: futureOrNone(intNone))), - 'int', - ); + withTypeParameterScope('T extends FutureOr', (scope) { + _check(scope.parseType('T'), 'int'); + }); // T & Future - _check( - typeParameterTypeNone( - typeParameter('T'), - promotedBound: futureNone(intNone), - ), - 'int', - ); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T & Future'), 'int'); + }); // T & FutureOr - _check( - typeParameterTypeNone( - typeParameter('T'), - promotedBound: futureOrNone(intNone), - ), - 'int', - ); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T & FutureOr'), 'int'); + }); // T extends int - _check(typeParameterTypeNone(typeParameter('T', bound: intNone)), 'T'); + withTypeParameterScope('T extends int', (scope) { + _check(scope.parseType('T'), 'T'); + }); // T & int - _check( - typeParameterTypeNone(typeParameter('T'), promotedBound: intNone), - 'T', - ); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T & int'), 'T'); + }); } test_typeParameterType_question() { // T extends Future - _check( - typeParameterTypeQuestion(typeParameter('T', bound: futureNone(intNone))), - 'int?', - ); + withTypeParameterScope('T extends Future', (scope) { + _check(scope.parseType('T?'), 'int?'); + }); // T extends FutureOr - _check( - typeParameterTypeQuestion( - typeParameter('T', bound: futureOrNone(intNone)), - ), - 'int?', - ); + withTypeParameterScope('T extends FutureOr', (scope) { + _check(scope.parseType('T?'), 'int?'); + }); } test_unknownInferredType() { @@ -124,11 +111,11 @@ class FlattenTypeTest extends AbstractTypeSystemTest { @reflectiveTest class FutureTypeTest extends AbstractTypeSystemTest { test_dynamic() { - _check(dynamicType, null); + _check(parseType('dynamic'), null); } test_functionType() { - _check(functionTypeNone(returnType: voidNone), null); + _check(parseType('void Function()'), null); } test_implements_Future() { @@ -136,82 +123,71 @@ class FutureTypeTest extends AbstractTypeSystemTest { imports: ['dart:core', 'dart:async'], classes: [ClassSpec('class A implements Future')], ); - var A = classElement('A'); - - _check(interfaceTypeNone(A), 'Future'); - _check(interfaceTypeQuestion(A), null); + _check(parseType('A'), 'Future'); + _check(parseType('A?'), null); } test_interfaceType() { - _check(objectNone, null); - _check(objectQuestion, null); + _check(parseType('Object'), null); + _check(parseType('Object?'), null); - _check(intNone, null); - _check(intQuestion, null); + _check(parseType('int'), null); + _check(parseType('int?'), null); - _check(listNone(intNone), null); - _check(listNone(intQuestion), null); + _check(parseType('List'), null); + _check(parseType('List'), null); - _check(listQuestion(intNone), null); - _check(listQuestion(intQuestion), null); + _check(parseType('List?'), null); + _check(parseType('List?'), null); - _check(futureNone(intNone), 'Future'); - _check(futureNone(intQuestion), 'Future'); + _check(parseType('Future'), 'Future'); + _check(parseType('Future'), 'Future'); - _check(futureQuestion(intNone), 'Future?'); - _check(futureQuestion(intQuestion), 'Future?'); + _check(parseType('Future?'), 'Future?'); + _check(parseType('Future?'), 'Future?'); - _check(futureOrNone(intNone), 'FutureOr'); - _check(futureOrNone(intQuestion), 'FutureOr'); + _check(parseType('FutureOr'), 'FutureOr'); + _check(parseType('FutureOr'), 'FutureOr'); - _check(futureOrQuestion(intNone), 'FutureOr?'); - _check(futureOrQuestion(intQuestion), 'FutureOr?'); + _check(parseType('FutureOr?'), 'FutureOr?'); + _check(parseType('FutureOr?'), 'FutureOr?'); - _check(futureNone(futureNone(intNone)), 'Future>'); - _check(futureNone(futureOrNone(intNone)), 'Future>'); - _check(futureOrNone(futureNone(intNone)), 'FutureOr>'); - _check(futureOrNone(futureOrNone(intNone)), 'FutureOr>'); + _check(parseType('Future>'), 'Future>'); + _check(parseType('Future>'), 'Future>'); + _check(parseType('FutureOr>'), 'FutureOr>'); + _check(parseType('FutureOr>'), 'FutureOr>'); } test_typeParameterType_none() { // T extends Future - _check( - typeParameterTypeNone(typeParameter('T', bound: futureNone(intNone))), - 'Future', - ); + withTypeParameterScope('T extends Future', (scope) { + _check(scope.parseType('T'), 'Future'); + }); // T extends FutureOr - _check( - typeParameterTypeNone(typeParameter('T', bound: futureOrNone(intNone))), - 'FutureOr', - ); + withTypeParameterScope('T extends FutureOr', (scope) { + _check(scope.parseType('T'), 'FutureOr'); + }); // T & Future - _check( - typeParameterTypeNone( - typeParameter('T'), - promotedBound: futureNone(intNone), - ), - 'Future', - ); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T & Future'), 'Future'); + }); // T & FutureOr - _check( - typeParameterTypeNone( - typeParameter('T'), - promotedBound: futureOrNone(intNone), - ), - 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T & FutureOr'), 'FutureOr'); + }); // T extends int - _check(typeParameterTypeNone(typeParameter('T', bound: intNone)), null); + withTypeParameterScope('T extends int', (scope) { + _check(scope.parseType('T'), null); + }); // T & int - _check( - typeParameterTypeNone(typeParameter('T'), promotedBound: intNone), - null, - ); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T & int'), null); + }); } test_unknownInferredType() { diff --git a/pkg/analyzer/test/src/dart/element/function_type_test.dart b/pkg/analyzer/test/src/dart/element/function_type_test.dart index 021654fb50e..b1bfc840aeb 100644 --- a/pkg/analyzer/test/src/dart/element/function_type_test.dart +++ b/pkg/analyzer/test/src/dart/element/function_type_test.dart @@ -5,7 +5,6 @@ import 'package:analyzer/dart/element/element.dart'; import 'package:analyzer/dart/element/nullability_suffix.dart'; import 'package:analyzer/dart/element/type.dart'; -import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/type.dart'; import 'package:analyzer/src/test_utilities/test_library_builder.dart'; import 'package:test/test.dart'; @@ -25,8 +24,6 @@ DynamicTypeImpl get dynamicType => DynamicTypeImpl.instance; class FunctionTypeTest extends AbstractTypeSystemTest { final Map _classTypes = {}; - InterfaceType get intType => typeProvider.intType; - ClassElement get listElement => typeProvider.listElement; ClassElement get mapElement => typeProvider.mapElement; @@ -36,7 +33,7 @@ class FunctionTypeTest extends AbstractTypeSystemTest { void basicChecks( FunctionType f, { displayName = 'dynamic Function()', - returnType, + returnType = 'dynamic', namedParameterTypes = isEmpty, normalParameterNames = isEmpty, normalParameterTypes = isEmpty, @@ -44,28 +41,45 @@ class FunctionTypeTest extends AbstractTypeSystemTest { optionalParameterTypes = isEmpty, parameters = isEmpty, typeFormals = isEmpty, - typeParameters = isEmpty, }) { // DartType properties expect(f.getDisplayString(), displayName, reason: 'displayName'); // FunctionType properties expect( - f.namedParameterTypes, + f.namedParameterTypes.map((name, type) { + return MapEntry(name, _typeStr(type)); + }), namedParameterTypes, reason: 'namedParameterTypes', ); expect( - f.normalParameterTypes, + f.formalParameters + .where((parameter) => parameter.isRequiredPositional) + .map((parameter) => parameter.name) + .toList(), + normalParameterNames, + reason: 'normalParameterNames', + ); + expect( + f.normalParameterTypes.map(_typeStr).toList(), normalParameterTypes, reason: 'normalParameterTypes', ); expect( - f.optionalParameterTypes, + f.formalParameters + .where((parameter) => parameter.isOptionalPositional) + .map((parameter) => parameter.name) + .toList(), + optionalParameterNames, + reason: 'optionalParameterNames', + ); + expect( + f.optionalParameterTypes.map(_typeStr).toList(), optionalParameterTypes, reason: 'optionalParameterTypes', ); expect(f.formalParameters, parameters, reason: 'parameters'); - expect(f.returnType, returnType ?? same(dynamicType), reason: 'returnType'); + expect(_typeStr(f.returnType), returnType, reason: 'returnType'); expect(f.typeParameters, typeFormals, reason: 'typeFormals'); } @@ -81,367 +95,160 @@ class FunctionTypeTest extends AbstractTypeSystemTest { ); test_equality_leftRequired_rightPositional() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - requiredParameter(name: 'a', type: typeProvider.intType), - ], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - positionalParameter(name: 'a', type: typeProvider.intType), - ], - ); + var f1 = parseFunctionType('void Function(int a)'); + var f2 = parseFunctionType('void Function([int a])'); expect(f1, isNot(equals(f2))); } test_equality_namedParameters_differentName() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'a', type: typeProvider.intType)], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'b', type: typeProvider.intType)], - ); + var f1 = parseFunctionType('void Function({int a})'); + var f2 = parseFunctionType('void Function({int b})'); expect(f1, isNot(equals(f2))); } test_equality_namedParameters_differentType() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'a', type: typeProvider.intType)], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedParameter(name: 'a', type: typeProvider.doubleType), - ], - ); + var f1 = parseFunctionType('void Function({int a})'); + var f2 = parseFunctionType('void Function({double a})'); expect(f1, isNot(equals(f2))); } test_equality_namedParameters_equal() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedParameter(name: 'a', type: typeProvider.intType), - namedParameter(name: 'b', type: typeProvider.doubleType), - ], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedParameter(name: 'a', type: typeProvider.intType), - namedParameter(name: 'b', type: typeProvider.doubleType), - ], - ); + var f1 = parseFunctionType('void Function({int a, double b})'); + var f2 = parseFunctionType('void Function({int a, double b})'); expect(f1, f2); } test_equality_namedParameters_extraLeft() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedParameter(name: 'a', type: typeProvider.intType), - namedParameter(name: 'b', type: typeProvider.doubleType), - ], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'a', type: typeProvider.intType)], - ); + var f1 = parseFunctionType('void Function({int a, double b})'); + var f2 = parseFunctionType('void Function({int a})'); expect(f1, isNot(equals(f2))); } test_equality_namedParameters_extraRight() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'a', type: typeProvider.intType)], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedParameter(name: 'a', type: typeProvider.intType), - namedParameter(name: 'b', type: typeProvider.doubleType), - ], - ); + var f1 = parseFunctionType('void Function({int a})'); + var f2 = parseFunctionType('void Function({int a, double b})'); expect(f1, isNot(equals(f2))); } test_equality_namedParameters_required_left() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedRequiredParameter(name: 'a', type: typeProvider.intType), - ], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'a', type: typeProvider.intType)], - ); + var f1 = parseFunctionType('void Function({required int a})'); + var f2 = parseFunctionType('void Function({int a})'); expect(f1, isNot(equals(f2))); } test_equality_namedParameters_required_right() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [namedParameter(name: 'a', type: typeProvider.intType)], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - namedRequiredParameter(name: 'a', type: typeProvider.intType), - ], - ); + var f1 = parseFunctionType('void Function({int a})'); + var f2 = parseFunctionType('void Function({required int a})'); expect(f1, isNot(equals(f2))); } test_equality_requiredParameters_extraLeft() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - requiredParameter(name: 'a', type: typeProvider.intType), - requiredParameter(name: 'b', type: typeProvider.doubleType), - ], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - requiredParameter(name: 'a', type: typeProvider.intType), - ], - ); + var f1 = parseFunctionType('void Function(int a, double b)'); + var f2 = parseFunctionType('void Function(int a)'); expect(f1, isNot(equals(f2))); } test_equality_requiredParameters_extraRight() { - var f1 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - requiredParameter(name: 'a', type: typeProvider.intType), - ], - ); - var f2 = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - requiredParameter(name: 'a', type: typeProvider.intType), - requiredParameter(name: 'b', type: typeProvider.doubleType), - ], - ); + var f1 = parseFunctionType('void Function(int a)'); + var f2 = parseFunctionType('void Function(int a, double b)'); expect(f1, isNot(equals(f2))); } test_hash_namedParameterOptionality() { _testHashesSometimesDifferPairwise( (i) => ( - FunctionTypeImpl( - typeParameters: const [], - parameters: [namedParameter(name: 'p$i', type: typeProvider.intType)], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - FunctionTypeImpl( - typeParameters: const [], - parameters: [ - namedRequiredParameter(name: 'p$i', type: typeProvider.intType), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), + parseFunctionType('void Function({int p$i})'), + parseFunctionType('void Function({required int p$i})'), ), ); } test_hash_nullabilitySuffix() { _testHashesSometimesDifferPairwise((i) { - var cType = _classType('C$i'); + _classType('C$i'); return ( - FunctionTypeImpl( - typeParameters: const [], - parameters: [requiredParameter(name: 'x', type: cType)], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - FunctionTypeImpl( - typeParameters: const [], - parameters: [requiredParameter(name: 'x', type: cType)], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.question, - ), + parseFunctionType('void Function(C$i x)'), + parseFunctionType('void Function(C$i x)?'), ); }); } test_hash_optionalNamedParameterName() { _testHashesSometimesDiffer( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [namedParameter(name: 'p$i', type: typeProvider.intType)], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), + (i) => parseFunctionType('void Function({int p$i})'), ); } test_hash_optionalNamedParameterType() { - _testHashesSometimesDiffer( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [namedParameter(name: 'x', type: _classType('C$i'))], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - ); + _testHashesSometimesDiffer((i) { + _classType('C$i'); + return parseFunctionType('void Function({C$i x})'); + }); } test_hash_optionalPositionalParameterName() { // Optional parameter names are irrelevant _testHashesAlwaysEqual( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [ - positionalParameter(name: 'p$i', type: typeProvider.intType), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), + (i) => parseFunctionType('void Function([int p$i])'), ); } test_hash_optionalPositionalParameterType() { - _testHashesAlwaysEqual( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [positionalParameter(name: 'x', type: _classType('C$i'))], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - ); + _testHashesAlwaysEqual((i) { + _classType('C$i'); + return parseFunctionType('void Function([C$i x])'); + }); } test_hash_positionalParameterOptionality() { _testHashesSometimesDifferPairwise( (i) => ( - FunctionTypeImpl( - typeParameters: const [], - parameters: [ - requiredParameter(name: 'p$i', type: typeProvider.intType), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - FunctionTypeImpl( - typeParameters: const [], - parameters: [ - positionalParameter(name: 'p$i', type: typeProvider.intType), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), + parseFunctionType('void Function(int p$i)'), + parseFunctionType('void Function([int p$i])'), ), ); } test_hash_requiredNamedParameterName() { _testHashesSometimesDiffer( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [ - namedRequiredParameter(name: 'p$i', type: typeProvider.intType), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), + (i) => parseFunctionType('void Function({required int p$i})'), ); } test_hash_requiredNamedParameterType() { - _testHashesSometimesDiffer( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [ - namedRequiredParameter(name: 'x', type: _classType('C$i')), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - ); + _testHashesSometimesDiffer((i) { + _classType('C$i'); + return parseFunctionType('void Function({required C$i x})'); + }); } test_hash_requiredPositionalParameterName() { // Required parameter names are irrelevant - _testHashesAlwaysEqual( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [ - requiredParameter(name: 'p$i', type: typeProvider.intType), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - ); + _testHashesAlwaysEqual((i) => parseFunctionType('void Function(int p$i)')); } test_hash_requiredPositionalParameterType() { - _testHashesAlwaysEqual( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: [requiredParameter(name: 'x', type: _classType('C$i'))], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ), - ); - } - - test_hash_returnType() { - _testHashesSometimesDiffer( - (i) => FunctionTypeImpl( - typeParameters: const [], - parameters: const [], - returnType: _classType('C$i'), - nullabilitySuffix: NullabilitySuffix.none, - ), - ); - } - - test_hash_typeFormalNames() { _testHashesAlwaysEqual((i) { - var t = TypeParameterElementImpl.synthetic(name: 'T$i'); - var u = TypeParameterElementImpl.synthetic(name: 'U$i'); - return FunctionTypeImpl( - typeParameters: [t, u], - parameters: [ - requiredParameter( - name: 'x', - type: TypeParameterTypeImpl( - element: t, - nullabilitySuffix: NullabilitySuffix.none, - ), - ), - requiredParameter( - name: 'y', - type: TypeParameterTypeImpl( - element: t, - nullabilitySuffix: NullabilitySuffix.none, - ), - ), - ], - returnType: typeProvider.voidType, - nullabilitySuffix: NullabilitySuffix.none, - ); + _classType('C$i'); + return parseFunctionType('void Function(C$i x)'); }); } - test_new_sortsNamedParameters() { - var f = functionTypeNone( - returnType: typeProvider.voidType, - formalParameters: [ - requiredParameter(name: 'a', type: typeProvider.intType), - namedParameter(name: 'c', type: typeProvider.intType), - namedParameter(name: 'b', type: typeProvider.intType), - ], + test_hash_returnType() { + _testHashesSometimesDiffer((i) { + _classType('C$i'); + return parseFunctionType('C$i Function()'); + }); + } + + test_hash_typeFormalNames() { + _testHashesAlwaysEqual( + (i) => parseFunctionType('void Function(T$i x, T$i y)'), ); + } + + test_new_sortsNamedParameters() { + var f = parseFunctionType('void Function(int a, {int c, int b})'); var parameters = f.formalParameters; expect(parameters, hasLength(3)); expect(parameters[0].name, 'a'); @@ -450,145 +257,91 @@ class FunctionTypeTest extends AbstractTypeSystemTest { } test_synthetic() { - FunctionType f = FunctionTypeImpl( - typeParameters: const [], - parameters: const [], - returnType: dynamicType, - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('dynamic Function()'); basicChecks(f); } test_synthetic_instantiate() { // T Function(T x) - var t = typeParameter('T'); - var x = requiredParameter(name: 'x', type: typeParameterTypeNone(t)); - FunctionType f = FunctionTypeImpl( - typeParameters: [t], - parameters: [x], - returnType: typeParameterTypeNone(t), - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('T Function(T x)'); FunctionType instantiated = f.instantiate([objectType]); basicChecks( instantiated, displayName: 'Object Function(Object)', - returnType: same(objectType), + returnType: 'Object', normalParameterNames: ['x'], - normalParameterTypes: [same(objectType)], + normalParameterTypes: ['Object'], parameters: hasLength(1), ); } test_synthetic_instantiate_argument_length_mismatch() { // dynamic Function() - var t = typeParameter('T'); - FunctionType f = FunctionTypeImpl( - typeParameters: [t], - parameters: const [], - returnType: dynamicType, - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('dynamic Function()'); expect(() => f.instantiate([]), throwsA(TypeMatcher())); } test_synthetic_instantiate_no_type_formals() { - FunctionType f = FunctionTypeImpl( - typeParameters: const [], - parameters: const [], - returnType: dynamicType, - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('dynamic Function()'); expect(f.instantiate([]), same(f)); } test_synthetic_namedParameter() { - var p = namedParameter(name: 'x', type: objectType); - FunctionType f = FunctionTypeImpl( - typeParameters: const [], - parameters: [p], - returnType: dynamicType, - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('dynamic Function({Object x})'); basicChecks( f, displayName: 'dynamic Function({Object x})', - namedParameterTypes: {'x': same(objectType)}, + namedParameterTypes: {'x': 'Object'}, parameters: hasLength(1), ); expect(f.formalParameters[0].isNamed, isTrue); expect(f.formalParameters[0].name, 'x'); - expect(f.formalParameters[0].type, same(objectType)); + expect(_typeStr(f.formalParameters[0].type), 'Object'); } test_synthetic_normalParameter() { - var p = requiredParameter(name: 'x', type: objectType); - FunctionType f = FunctionTypeImpl( - typeParameters: const [], - parameters: [p], - returnType: dynamicType, - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('dynamic Function(Object x)'); basicChecks( f, displayName: 'dynamic Function(Object)', normalParameterNames: ['x'], - normalParameterTypes: [same(objectType)], + normalParameterTypes: ['Object'], parameters: hasLength(1), ); expect(f.formalParameters[0].isRequiredPositional, isTrue); expect(f.formalParameters[0].name, 'x'); - expect(f.formalParameters[0].type, same(objectType)); + expect(_typeStr(f.formalParameters[0].type), 'Object'); } test_synthetic_optionalParameter() { - var p = positionalParameter(name: 'x', type: objectType); - FunctionType f = FunctionTypeImpl( - typeParameters: const [], - parameters: [p], - returnType: dynamicType, - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('dynamic Function([Object x])'); basicChecks( f, displayName: 'dynamic Function([Object])', optionalParameterNames: ['x'], - optionalParameterTypes: [same(objectType)], + optionalParameterTypes: ['Object'], parameters: hasLength(1), ); expect(f.formalParameters[0].isOptionalPositional, isTrue); expect(f.formalParameters[0].name, 'x'); - expect(f.formalParameters[0].type, same(objectType)); + expect(_typeStr(f.formalParameters[0].type), 'Object'); } test_synthetic_returnType() { - FunctionType f = FunctionTypeImpl( - typeParameters: const [], - parameters: const [], - returnType: objectType, - nullabilitySuffix: NullabilitySuffix.none, - ); - basicChecks( - f, - displayName: 'Object Function()', - returnType: same(objectType), - ); + FunctionType f = parseFunctionType('Object Function()'); + basicChecks(f, displayName: 'Object Function()', returnType: 'Object'); } test_synthetic_typeFormals() { - var t = typeParameter('T'); - FunctionType f = FunctionTypeImpl.v2( - typeParameters: [t], - formalParameters: const [], - returnType: typeParameterTypeNone(t), - nullabilitySuffix: NullabilitySuffix.none, - ); + FunctionType f = parseFunctionType('T Function()'); + var t = f.typeParameters.single; basicChecks( f, displayName: 'T Function()', - returnType: typeParameterTypeNone(t), + returnType: 'T', typeFormals: [same(t)], ); + expect((f.returnType as TypeParameterType).element, same(t)); } InterfaceTypeImpl _classType(String name) { @@ -650,8 +403,9 @@ class FunctionTypeTest extends AbstractTypeSystemTest { for (var i = 1; i < 10; i++) { var (x, y) = generate(i); if (x.hashCode != y.hashCode) return; - x = y; } fail('Hashes never differed'); } + + String _typeStr(DartType type) => type.getDisplayString(); } diff --git a/pkg/analyzer/test/src/dart/element/future_or_base_test.dart b/pkg/analyzer/test/src/dart/element/future_or_base_test.dart index c51d79f6ad7..ed20520e173 100644 --- a/pkg/analyzer/test/src/dart/element/future_or_base_test.dart +++ b/pkg/analyzer/test/src/dart/element/future_or_base_test.dart @@ -17,38 +17,34 @@ main() { @reflectiveTest class FutureOrBaseTest extends AbstractTypeSystemTest { test_dynamic() { - _check(dynamicType, 'dynamic'); + _check(parseType('dynamic'), 'dynamic'); } test_futureOr() { - void check(TypeImpl S, String expected) { - _check(futureOrNone(S), expected); - } + _check(parseType('FutureOr'), 'int'); + _check(parseType('FutureOr'), 'int?'); - check(intNone, 'int'); - check(intQuestion, 'int?'); + _check(parseType('FutureOr'), 'dynamic'); + _check(parseType('FutureOr'), 'void'); - check(dynamicType, 'dynamic'); - check(voidNone, 'void'); + _check(parseType('FutureOr'), 'Never'); + _check(parseType('FutureOr'), 'Never?'); - check(neverNone, 'Never'); - check(neverQuestion, 'Never?'); - - check(objectNone, 'Object'); - check(objectQuestion, 'Object?'); + _check(parseType('FutureOr'), 'Object'); + _check(parseType('FutureOr'), 'Object?'); } test_other() { - _check(intNone, 'int'); - _check(intQuestion, 'int?'); + _check(parseType('int'), 'int'); + _check(parseType('int?'), 'int?'); - _check(objectNone, 'Object'); - _check(objectQuestion, 'Object?'); + _check(parseType('Object'), 'Object'); + _check(parseType('Object?'), 'Object?'); } /// futureValueType(`void`) = `void`. test_void() { - _check(voidNone, 'void'); + _check(parseType('void'), 'void'); } void _check(TypeImpl T, String expected) { diff --git a/pkg/analyzer/test/src/dart/element/future_value_type_test.dart b/pkg/analyzer/test/src/dart/element/future_value_type_test.dart index eeb84802582..f430b8da8e3 100644 --- a/pkg/analyzer/test/src/dart/element/future_value_type_test.dart +++ b/pkg/analyzer/test/src/dart/element/future_value_type_test.dart @@ -18,73 +18,65 @@ main() { class FutureValueTypeTest extends AbstractTypeSystemTest { /// futureValueType(`dynamic`) = `dynamic`. test_dynamic() { - _check(dynamicType, 'dynamic'); + _check(parseType('dynamic'), 'dynamic'); } /// futureValueType(Future<`S`>) = `S`, for all `S`. test_future() { - void check(TypeImpl S, String expected) { - _check(futureNone(S), expected); - } + _check(parseType('Future'), 'int'); + _check(parseType('Future'), 'int?'); - check(intNone, 'int'); - check(intQuestion, 'int?'); + _check(parseType('Future'), 'dynamic'); + _check(parseType('Future'), 'void'); - check(dynamicType, 'dynamic'); - check(voidNone, 'void'); + _check(parseType('Future'), 'Never'); + _check(parseType('Future'), 'Never?'); - check(neverNone, 'Never'); - check(neverQuestion, 'Never?'); - - check(objectNone, 'Object'); - check(objectQuestion, 'Object?'); + _check(parseType('Future'), 'Object'); + _check(parseType('Future'), 'Object?'); } /// futureValueType(FutureOr<`S`>) = `S`, for all `S`. test_futureOr() { - void check(TypeImpl S, String expected) { - _check(futureOrNone(S), expected); - } + _check(parseType('FutureOr'), 'int'); + _check(parseType('FutureOr'), 'int?'); - check(intNone, 'int'); - check(intQuestion, 'int?'); + _check(parseType('FutureOr'), 'dynamic'); + _check(parseType('FutureOr'), 'void'); - check(dynamicType, 'dynamic'); - check(voidNone, 'void'); + _check(parseType('FutureOr'), 'Never'); + _check(parseType('FutureOr'), 'Never?'); - check(neverNone, 'Never'); - check(neverQuestion, 'Never?'); - - check(objectNone, 'Object'); - check(objectQuestion, 'Object?'); + _check(parseType('FutureOr'), 'Object'); + _check(parseType('FutureOr'), 'Object?'); } /// Otherwise, for all `S`, futureValueType(`S`) = `Object?`. test_other() { - _check(objectNone, 'Object?'); - _check(intNone, 'Object?'); + _check(parseType('Object'), 'Object?'); + _check(parseType('int'), 'Object?'); } /// futureValueType(`S?`) = futureValueType(`S`), for all `S`. test_suffix_question() { - _check(intQuestion, 'Object?'); + _check(parseType('int?'), 'Object?'); - _check(futureQuestion(intNone), 'int'); - _check(futureQuestion(intQuestion), 'int?'); + _check(parseType('Future?'), 'int'); + _check(parseType('Future?'), 'int?'); - _check(futureOrQuestion(intNone), 'int'); - _check(futureOrQuestion(intQuestion), 'int?'); + _check(parseType('FutureOr?'), 'int'); + _check(parseType('FutureOr?'), 'int?'); - _check(futureQuestion(objectNone), 'Object'); - _check(futureQuestion(objectQuestion), 'Object?'); + _check(parseType('Future?'), 'Object'); + _check(parseType('Future?'), 'Object?'); - _check(futureQuestion(dynamicType), 'dynamic'); - _check(futureQuestion(voidNone), 'void'); + _check(parseType('Future?'), 'dynamic'); + _check(parseType('Future?'), 'void'); } /// futureValueType(`void`) = `void`. test_void() { - _check(voidNone, 'void'); + _check(parseType('void'), 'void'); } void _check(TypeImpl T, String expected) { diff --git a/pkg/analyzer/test/src/dart/element/generic_inferrer_test.dart b/pkg/analyzer/test/src/dart/element/generic_inferrer_test.dart index d428cb909fd..947ff2e3593 100644 --- a/pkg/analyzer/test/src/dart/element/generic_inferrer_test.dart +++ b/pkg/analyzer/test/src/dart/element/generic_inferrer_test.dart @@ -2,7 +2,6 @@ // 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:_fe_analyzer_shared/src/types/shared_type.dart'; import 'package:analyzer/dart/ast/token.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:analyzer/error/listener.dart'; @@ -29,19 +28,12 @@ main() { class GenericFunctionInferenceTest extends AbstractTypeSystemTest { void test_boundedByAnotherTypeParameter() { // >(TFrom) -> TTo - var tFrom = typeParameter('TFrom'); - var tTo = typeParameter( - 'TTo', - bound: iterableNone(typeParameterTypeNone(tFrom)), + var cast = parseFunctionType( + 'TTo Function>(TFrom)', ); - var cast = functionTypeNone( - typeParameters: [tFrom, tTo], - formalParameters: [requiredParameter(type: typeParameterTypeNone(tFrom))], - returnType: typeParameterTypeNone(tTo), - ); - _assertTypes(_inferCall(cast, [stringNone]), [ - stringNone, - iterableNone(stringNone), + _assertTypes(_inferCall(cast, [parseType('String')]), [ + parseType('String'), + parseType('Iterable'), ]); } @@ -59,23 +51,16 @@ class GenericFunctionInferenceTest extends AbstractTypeSystemTest { ], ); - // class A {} - var A = classElement('A'); - var typeA = interfaceTypeNone(A); - // class B extends A {} - var B = classElement('B'); - var typeB = interfaceTypeNone(B); + var typeB = parseInterfaceType('B'); // class C { S m(S); } - var C = classElement('C'); - // C cOfObject; - var cOfObject = interfaceTypeNone(C, typeArguments: [objectNone]); + var cOfObject = parseInterfaceType('C'); // C cOfA; - var cOfA = interfaceTypeNone(C, typeArguments: [typeA]); + var cOfA = parseInterfaceType('C'); // C cOfB; - var cOfB = interfaceTypeNone(C, typeArguments: [typeB]); + var cOfB = parseInterfaceType('C'); // B b; // cOfB.m(b); // infer _assertType( @@ -108,25 +93,15 @@ class GenericFunctionInferenceTest extends AbstractTypeSystemTest { ], ); - // class A {} - var A = classElement('A'); - var typeA = interfaceTypeNone(A); - - // class B extends A {} - var B = classElement('B'); - var typeB = interfaceTypeNone(B); - // class C { S m>(S); } - var C = classElement('C'); - // C cOfObject; - var cOfObject = interfaceTypeNone(C, typeArguments: [objectNone]); + var cOfObject = parseInterfaceType('C'); // C cOfA; - var cOfA = interfaceTypeNone(C, typeArguments: [typeA]); + var cOfA = parseInterfaceType('C'); // C cOfB; - var cOfB = interfaceTypeNone(C, typeArguments: [typeB]); + var cOfB = parseInterfaceType('C'); // List b; - var listOfB = listNone(typeB); + var listOfB = parseType('List'); // cOfB.m(b); // infer _assertType( _inferCall2(cOfB.getMethod('m')!.type, [listOfB]), @@ -152,33 +127,23 @@ class GenericFunctionInferenceTest extends AbstractTypeSystemTest { ], ); - // class A> - var A = classElement('Cloneable'); + // class Cloneable> // class B extends A {} - var B = classElement('B'); - var typeB = interfaceTypeNone(B); - - // > - var S = typeParameter('S'); - var typeS = typeParameterTypeNone(S); - S.bound = interfaceTypeNone(A, typeArguments: [typeS]); + var typeB = parseInterfaceType('B'); // (S, S) -> S - var clone = functionTypeNone( - typeParameters: [S], - formalParameters: [ - requiredParameter(type: typeS), - requiredParameter(type: typeS), - ], - returnType: typeS, - ); + var clone = parseFunctionType('S Function>(S, S)'); _assertTypes(_inferCall(clone, [typeB, typeB]), [typeB]); // Something invalid... - _assertTypes(_inferCall(clone, [stringNone, numNone], expectError: true), [ - interfaceTypeNone(A, typeArguments: [objectQuestion]), - ]); + _assertTypes( + _inferCall(clone, [ + parseType('String'), + parseType('num'), + ], expectError: true), + [parseInterfaceType('Cloneable')], + ); } void test_buildTestLibrary_topLevelFunctionHeader() { @@ -203,360 +168,167 @@ class GenericFunctionInferenceTest extends AbstractTypeSystemTest { /// https://github.com/dart-lang/language/issues/1182#issuecomment-702272641 void test_demoteType() { // (T x) -> void - var T = typeParameter('T'); - var rawType = functionTypeNone( - typeParameters: [T], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: voidNone, - ); + var rawType = parseFunctionType('void Function(T)'); - var S = typeParameter('S'); - var S_and_int = typeParameterTypeNone(S, promotedBound: intNone); + withTypeParameterScope('S', (scope) { + var S = scope.typeParameter('S'); + var S_and_int = scope.parseTypeParameterType('S & int'); - var inferredTypes = _inferCall(rawType, [S_and_int]); - var inferredType = inferredTypes[0] as TypeParameterTypeImpl; - expect(inferredType.element, S); - expect(inferredType.promotedBound, isNull); + var inferredTypes = _inferCall(rawType, [S_and_int]); + var inferredType = inferredTypes[0] as TypeParameterTypeImpl; + expect(inferredType.element, S); + expect(inferredType.promotedBound, isNull); + }); } void test_genericCastFunction() { // (TFrom) -> TTo - var tFrom = typeParameter('TFrom'); - var tTo = typeParameter('TTo'); - var cast = functionTypeNone( - typeParameters: [tFrom, tTo], - formalParameters: [requiredParameter(type: typeParameterTypeNone(tFrom))], - returnType: typeParameterTypeNone(tTo), - ); - _assertTypes(_inferCall(cast, [intNone]), [intNone, dynamicType]); + var cast = parseFunctionType('TTo Function(TFrom)'); + _assertTypes(_inferCall(cast, [parseType('int')]), [ + parseType('int'), + parseType('dynamic'), + ]); } void test_genericCastFunctionWithUpperBound() { // (TFrom) -> TTo - var tFrom = typeParameter('TFrom'); - var tTo = typeParameter('TTo', bound: typeParameterTypeNone(tFrom)); - var cast = functionTypeNone( - typeParameters: [tFrom, tTo], - formalParameters: [requiredParameter(type: typeParameterTypeNone(tFrom))], - returnType: typeParameterTypeNone(tTo), + var cast = parseFunctionType( + 'TTo Function(TFrom)', ); - _assertTypes(_inferCall(cast, [intNone]), [intNone, intNone]); + _assertTypes(_inferCall(cast, [parseType('int')]), [ + parseType('int'), + parseType('int'), + ]); } void test_parameter_contravariantUseUpperBound() { // (T x, void Function(T) y) -> T // Generates constraints int <: T <: num. // Since T is contravariant, choose num. - var T = typeParameter('T', variance: Variance.contravariant); - var tFunction = functionTypeNone( - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: voidNone, - ); - var numFunction = functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: voidNone, - ); - var function = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - requiredParameter(type: tFunction), - ], - returnType: typeParameterTypeNone(T), - ); + var numFunction = parseFunctionType('void Function(num)'); + var function = parseFunctionType('T Function(T, void Function(T))'); - _assertTypes(_inferCall(function, [intNone, numFunction]), [numNone]); + _assertTypes(_inferCall(function, [parseType('int'), numFunction]), [ + parseType('num'), + ]); } void test_parameter_covariantUseLowerBound() { // (T x, void Function(T) y) -> T // Generates constraints int <: T <: num. // Since T is covariant, choose int. - var T = typeParameter('T', variance: Variance.covariant); - var tFunction = functionTypeNone( - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: voidNone, - ); - var numFunction = functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: voidNone, - ); - var function = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - requiredParameter(type: tFunction), - ], - returnType: typeParameterTypeNone(T), - ); + var numFunction = parseFunctionType('void Function(num)'); + var function = parseFunctionType('T Function(T, void Function(T))'); - _assertTypes(_inferCall(function, [intNone, numFunction]), [intNone]); + _assertTypes(_inferCall(function, [parseType('int'), numFunction]), [ + parseType('int'), + ]); } void test_parametersToFunctionParam() { // (f(T t)) -> T - var T = typeParameter('T'); - var cast = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: dynamicType, - ), - ), - ], - returnType: typeParameterTypeNone(T), - ); + var cast = parseFunctionType('T Function(dynamic Function(T))'); _assertTypes( - _inferCall(cast, [ - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: dynamicType, - ), - ]), - [numNone], + _inferCall(cast, [parseFunctionType('dynamic Function(num)')]), + [parseType('num')], ); } void test_parametersUseLeastUpperBound() { // (T x, T y) -> T - var T = typeParameter('T'); - var cast = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: typeParameterTypeNone(T), - ); - _assertTypes(_inferCall(cast, [intNone, doubleNone]), [numNone]); + var cast = parseFunctionType('T Function(T, T)'); + _assertTypes(_inferCall(cast, [parseType('int'), parseType('double')]), [ + parseType('num'), + ]); } void test_parameterTypeUsesUpperBound() { // (T) -> dynamic - var T = typeParameter('T', bound: numNone); - var f = functionTypeNone( - typeParameters: [T], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: dynamicType, - ); - _assertTypes(_inferCall(f, [intNone]), [intNone]); + var f = parseFunctionType('dynamic Function(T)'); + _assertTypes(_inferCall(f, [parseType('int')]), [parseType('int')]); } void test_returnFunctionWithGenericParameter() { // (T -> T) -> (T -> void) - var T = typeParameter('T'); - var f = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: typeParameterTypeNone(T), - ), - ), - ], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: voidNone, - ), - ); - _assertTypes( - _inferCall(f, [ - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intNone, - ), - ]), - [intNone], - ); + var f = parseFunctionType('void Function(T) Function(T Function(T))'); + _assertTypes(_inferCall(f, [parseFunctionType('int Function(num)')]), [ + parseType('int'), + ]); } void test_returnFunctionWithGenericParameterAndContext() { // (T -> T) -> (T -> Null) - var T = typeParameter('T'); - var f = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: typeParameterTypeNone(T), - ), - ), - ], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: nullNone, - ), - ); + var f = parseFunctionType('Null Function(T) Function(T Function(T))'); _assertTypes( - _inferCall( - f, - [], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intQuestion, - ), - ), - [numNone], + _inferCall(f, [], returnType: parseFunctionType('int? Function(num)')), + [parseType('num')], ); } void test_returnFunctionWithGenericParameterAndReturn() { // (T -> T) -> (T -> T) - var T = typeParameter('T'); - var f = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: typeParameterTypeNone(T), - ), - ), - ], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - returnType: typeParameterTypeNone(T), - ), - ); - _assertTypes( - _inferCall(f, [ - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intNone, - ), - ]), - [intNone], - ); + var f = parseFunctionType('T Function(T) Function(T Function(T))'); + _assertTypes(_inferCall(f, [parseFunctionType('int Function(num)')]), [ + parseType('int'), + ]); } void test_returnFunctionWithGenericReturn() { // (T -> T) -> (() -> T) - var T = typeParameter('T'); - var f = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: typeParameterTypeNone(T), - ), - ), - ], - returnType: functionTypeNone(returnType: typeParameterTypeNone(T)), - ); - _assertTypes( - _inferCall(f, [ - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intNone, - ), - ]), - [intNone], - ); + var f = parseFunctionType('T Function() Function(T Function(T))'); + _assertTypes(_inferCall(f, [parseFunctionType('int Function(num)')]), [ + parseType('int'), + ]); } void test_returnTypeFromContext() { // () -> T - var T = typeParameter('T'); - var f = functionTypeNone( - typeParameters: [T], - returnType: typeParameterTypeNone(T), - ); - _assertTypes(_inferCall(f, [], returnType: stringNone), [stringNone]); + var f = parseFunctionType('T Function()'); + _assertTypes(_inferCall(f, [], returnType: parseType('String')), [ + parseType('String'), + ]); } void test_returnTypeWithBoundFromContext() { // () -> T - var T = typeParameter('T', bound: numNone); - var f = functionTypeNone( - typeParameters: [T], - returnType: typeParameterTypeNone(T), - ); - _assertTypes(_inferCall(f, [], returnType: doubleNone), [doubleNone]); + var f = parseFunctionType('T Function()'); + _assertTypes(_inferCall(f, [], returnType: parseType('double')), [ + parseType('double'), + ]); } void test_returnTypeWithBoundFromInvalidContext() { // () -> T - var T = typeParameter('T', bound: numNone); - var f = functionTypeNone( - typeParameters: [T], - returnType: typeParameterTypeNone(T), - ); - _assertTypes(_inferCall(f, [], returnType: stringNone), [neverNone]); + var f = parseFunctionType('T Function()'); + _assertTypes(_inferCall(f, [], returnType: parseType('String')), [ + parseType('Never'), + ]); } void test_unifyParametersToFunctionParam() { // (f(T t), g(T t)) -> T - var T = typeParameter('T'); - var cast = functionTypeNone( - typeParameters: [T], - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: dynamicType, - ), - ), - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - ], - returnType: dynamicType, - ), - ), - ], - returnType: typeParameterTypeNone(T), + var cast = parseFunctionType( + 'T Function(dynamic Function(T), dynamic Function(T))', ); _assertTypes( _inferCall(cast, [ - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: dynamicType, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: doubleNone)], - returnType: dynamicType, - ), + parseFunctionType('dynamic Function(int)'), + parseFunctionType('dynamic Function(double)'), ]), - [neverNone], + [parseType('Never')], ); } void test_unusedReturnTypeIsDynamic() { // () -> T - var T = typeParameter('T'); - var f = functionTypeNone( - typeParameters: [T], - returnType: typeParameterTypeNone(T), - ); - _assertTypes(_inferCall(f, []), [dynamicType]); + var f = parseFunctionType('T Function()'); + _assertTypes(_inferCall(f, []), [parseType('dynamic')]); } void test_unusedReturnTypeWithUpperBound() { // () -> T - var T = typeParameter('T', bound: numNone); - var f = functionTypeNone( - typeParameters: [T], - returnType: typeParameterTypeNone(T), - ); - _assertTypes(_inferCall(f, []), [numNone]); + var f = parseFunctionType('T Function()'); + _assertTypes(_inferCall(f, []), [parseType('num')]); } void _assertType(DartType type, String expected) { diff --git a/pkg/analyzer/test/src/dart/element/incompatible_with_await_test.dart b/pkg/analyzer/test/src/dart/element/incompatible_with_await_test.dart index 3bd78b3b90f..45bbc51d11b 100644 --- a/pkg/analyzer/test/src/dart/element/incompatible_with_await_test.dart +++ b/pkg/analyzer/test/src/dart/element/incompatible_with_await_test.dart @@ -26,8 +26,8 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { } test_class_int() { - isNotIncompatible(intNone); - isNotIncompatible(intQuestion); + isNotIncompatible(parseType('int')); + isNotIncompatible(parseType('int?')); } test_extensionType_implementsFuture() { @@ -39,7 +39,7 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { ), ], ); - isNotIncompatible(interfaceTypeNone(extensionTypeElement('A'))); + isNotIncompatible(parseInterfaceType('A')); } test_extensionType_notImplementsFuture() { @@ -47,15 +47,15 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { imports: ['dart:core', 'dart:async'], extensionTypes: [ExtensionTypeSpec('extension type A(Future it)')], ); - isIncompatible(interfaceTypeNone(extensionTypeElement('A'))); + isIncompatible(parseInterfaceType('A')); } test_futureInt() { - isNotIncompatible(futureNone(intNone)); + isNotIncompatible(parseType('Future')); } test_futureOrInt() { - isNotIncompatible(futureOrNone(intNone)); + isNotIncompatible(parseType('FutureOr')); } test_typeParameter_bound_extensionType_implementsFuture() { @@ -67,11 +67,9 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { ), ], ); - var A = extensionTypeElement('A'); - - isNotIncompatible( - typeParameterTypeNone(typeParameter('T', bound: interfaceTypeNone(A))), - ); + withTypeParameterScope('T extends A', (scope) { + isNotIncompatible(scope.parseType('T')); + }); } test_typeParameter_bound_extensionType_notImplementsFuture() { @@ -79,17 +77,15 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { imports: ['dart:core', 'dart:async'], extensionTypes: [ExtensionTypeSpec('extension type A(Future it)')], ); - var A = extensionTypeElement('A'); - - isIncompatible( - typeParameterTypeNone(typeParameter('T', bound: interfaceTypeNone(A))), - ); + withTypeParameterScope('T extends A', (scope) { + isIncompatible(scope.parseType('T')); + }); } test_typeParameter_bound_numNone() { - isNotIncompatible( - typeParameterTypeNone(typeParameter('T', bound: numNone)), - ); + withTypeParameterScope('T extends num', (scope) { + isNotIncompatible(scope.parseType('T')); + }); } test_typeParameter_promotedBound_extensionType_implementsFuture() { @@ -104,15 +100,9 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { ), ], ); - var N = extensionTypeElement('N'); - var F = extensionTypeElement('F'); - - isNotIncompatible( - typeParameterTypeNone( - typeParameter('T', bound: interfaceTypeNone(N)), - promotedBound: interfaceTypeNone(F), - ), - ); + withTypeParameterScope('T extends N', (scope) { + isNotIncompatible(scope.parseType('T & F')); + }); } test_typeParameter_promotedBound_extensionType_notImplementsFuture() { @@ -120,19 +110,14 @@ class IsIncompatibleWithAwaitTest extends AbstractTypeSystemTest { imports: ['dart:core', 'dart:async'], extensionTypes: [ExtensionTypeSpec('extension type A(Future it)')], ); - var A = extensionTypeElement('A'); - - isIncompatible( - typeParameterTypeNone( - typeParameter('T'), - promotedBound: interfaceTypeNone(A), - ), - ); + withTypeParameterScope('T', (scope) { + isIncompatible(scope.parseType('T & A')); + }); } test_typeParameter_promotedBound_intNone() { - isNotIncompatible( - typeParameterTypeNone(typeParameter('T'), promotedBound: intNone), - ); + withTypeParameterScope('T', (scope) { + isNotIncompatible(scope.parseType('T & int')); + }); } } diff --git a/pkg/analyzer/test/src/dart/element/is_known_test.dart b/pkg/analyzer/test/src/dart/element/is_known_test.dart index ba453a3b0ab..a56483c21e5 100644 --- a/pkg/analyzer/test/src/dart/element/is_known_test.dart +++ b/pkg/analyzer/test/src/dart/element/is_known_test.dart @@ -18,52 +18,47 @@ main() { @reflectiveTest class IsKnownTest extends AbstractTypeSystemTest { test_dynamic() { - _checkKnown(dynamicType); + _checkKnown(parseType('dynamic')); } test_function() { - _checkKnown(functionTypeNone(returnType: voidNone)); + _checkKnown(parseType('void Function()')); - _checkUnknown(functionTypeNone(returnType: unknownInferredType)); + _checkUnknown(parseType('UnknownInferredType Function()')); - _checkUnknown( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: unknownInferredType)], - ), - ); + _checkUnknown(parseType('void Function(UnknownInferredType)')); } test_interface() { - _checkKnown(intNone); - _checkKnown(listNone(intNone)); - _checkUnknown(listNone(unknownInferredType)); + _checkKnown(parseType('int')); + _checkKnown(parseType('List')); + _checkUnknown(parseType('List')); } test_never() { - _checkKnown(neverNone); + _checkKnown(parseType('Never')); } test_null() { - _checkKnown(nullNone); + _checkKnown(parseType('Null')); } test_record() { - _checkKnown(recordTypeNone(positionalTypes: [intNone])); + _checkKnown(parseRecordType('(int,)')); - _checkUnknown(recordTypeNone(positionalTypes: [unknownInferredType])); + _checkUnknown(parseType('(UnknownInferredType,)')); - _checkKnown(recordTypeNone(namedTypes: {'x': intNone})); + _checkKnown(parseRecordType('({int x})')); - _checkUnknown(recordTypeNone(namedTypes: {'x': unknownInferredType})); + _checkUnknown(parseType('({UnknownInferredType x})')); } test_unknownInferredType() { - _checkUnknown(unknownInferredType); + _checkUnknown(parseType('UnknownInferredType')); } test_void() { - _checkKnown(voidNone); + _checkKnown(parseType('void')); } void _checkKnown(DartType type) { diff --git a/pkg/analyzer/test/src/dart/element/least_greatest_closure_test.dart b/pkg/analyzer/test/src/dart/element/least_greatest_closure_test.dart index 9cbcbad260a..4f89ec83e9d 100644 --- a/pkg/analyzer/test/src/dart/element/least_greatest_closure_test.dart +++ b/pkg/analyzer/test/src/dart/element/least_greatest_closure_test.dart @@ -17,115 +17,108 @@ main() { @reflectiveTest class GreatestClosureTest extends AbstractTypeSystemTest { - late final TypeParameterElementImpl T; - late final TypeParameterTypeImpl T_none; - late final TypeParameterTypeImpl T_question; - - @override - void setUp() { - super.setUp(); - - T = typeParameter('T'); - T_none = typeParameterTypeNone(T); - T_question = typeParameterTypeQuestion(T); - } - test_contravariant() { - _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ), - greatest: 'void Function(Never)', - least: 'void Function(Object?)', - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _check( - functionTypeNone( - returnType: functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ), - ), - greatest: 'void Function(Never) Function()', - least: 'void Function(Object?) Function()', - ); + _check( + scope.parseType('void Function(T)'), + typeParameters: [T], + greatest: 'void Function(Never)', + least: 'void Function(Object?)', + ); + + _check( + scope.parseType('void Function(T) Function()'), + typeParameters: [T], + greatest: 'void Function(Never) Function()', + least: 'void Function(Object?) Function()', + ); + }); } test_covariant() { - _check(T_none, greatest: 'Object?', least: 'Never'); - _check(T_question, greatest: 'Object?', least: 'Never?'); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _check(listNone(T_none), greatest: 'List', least: 'List'); + _check( + scope.parseTypeParameterType('T'), + typeParameters: [T], + greatest: 'Object?', + least: 'Never', + ); + _check( + scope.parseTypeParameterType('T?'), + typeParameters: [T], + greatest: 'Object?', + least: 'Never?', + ); - _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - requiredParameter( - type: functionTypeNone( - returnType: intNone, - formalParameters: [requiredParameter(type: T_none)], - ), - ), - ], - ), - greatest: 'void Function(int Function(Object?))', - least: 'void Function(int Function(Never))', - ); + _check( + scope.parseType('List'), + typeParameters: [T], + greatest: 'List', + least: 'List', + ); + + _check( + scope.parseType('void Function(int Function(T))'), + typeParameters: [T], + greatest: 'void Function(int Function(Object?))', + least: 'void Function(int Function(Never))', + ); + }); } test_function() { // void Function() - _check( - functionTypeNone( - typeParameters: [typeParameter('U', bound: T_none)], - returnType: voidNone, - ), - greatest: 'Function', - least: 'Never', - ); + withTypeParameterScope('T', (scope) { + _check( + scope.parseType('void Function()'), + typeParameters: [scope.typeParameter('T')], + greatest: 'Function', + least: 'Never', + ); + }); } test_unrelated() { - _check1(intNone, 'int'); - _check1(intQuestion, 'int?'); + withTypeParameterScope('T, U', (scope) { + void checkUnchanged(TypeImpl type, String expected) { + var T = scope.typeParameter('T'); + _check(type, typeParameters: [T], greatest: expected, least: expected); + } - _check1(listNone(intNone), 'List'); - _check1(listQuestion(intNone), 'List?'); + checkUnchanged(parseType('int'), 'int'); + checkUnchanged(parseType('int?'), 'int?'); - _check1(objectNone, 'Object'); - _check1(objectQuestion, 'Object?'); + checkUnchanged(parseType('List'), 'List'); + checkUnchanged(parseType('List?'), 'List?'); - _check1(neverNone, 'Never'); - _check1(neverQuestion, 'Never?'); + checkUnchanged(parseType('Object'), 'Object'); + checkUnchanged(parseType('Object?'), 'Object?'); - _check1(dynamicType, 'dynamic'); + checkUnchanged(parseType('Never'), 'Never'); + checkUnchanged(parseType('Never?'), 'Never?'); - _check1( - functionTypeNone( - returnType: stringNone, - formalParameters: [requiredParameter(type: intNone)], - ), - 'String Function(int)', - ); + checkUnchanged(parseType('dynamic'), 'dynamic'); - _check1(typeParameterTypeNone(typeParameter('U')), 'U'); + checkUnchanged(parseType('String Function(int)'), 'String Function(int)'); + + checkUnchanged(scope.parseType('U'), 'U'); + }); } void _check( TypeImpl type, { + required List typeParameters, required String greatest, required String least, }) { - var greatestResult = typeSystem.greatestClosure(type, [T]); + var greatestResult = typeSystem.greatestClosure(type, typeParameters); expect(greatestResult.getDisplayString(), greatest); - var leastResult = typeSystem.leastClosure(type, [T]); + var leastResult = typeSystem.leastClosure(type, typeParameters); expect(leastResult.getDisplayString(), least); } - - void _check1(TypeImpl type, String expected) { - _check(type, greatest: expected, least: expected); - } } diff --git a/pkg/analyzer/test/src/dart/element/least_upper_bound_helper_test.dart b/pkg/analyzer/test/src/dart/element/least_upper_bound_helper_test.dart index 9a77a0e1923..668c71024be 100644 --- a/pkg/analyzer/test/src/dart/element/least_upper_bound_helper_test.dart +++ b/pkg/analyzer/test/src/dart/element/least_upper_bound_helper_test.dart @@ -3,7 +3,6 @@ // BSD-style license that can be found in the LICENSE file. import 'package:analyzer/dart/element/type.dart'; -import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/least_upper_bound.dart'; import 'package:analyzer/src/test_utilities/test_library_builder.dart'; import 'package:test/test.dart'; @@ -25,18 +24,14 @@ class PathToObjectTest extends AbstractTypeSystemTest { classes: [ClassSpec('class A'), ClassSpec('class X extends A with M1')], mixins: [MixinSpec('mixin M1')], ); - var M1 = mixinElement('M1'); - expect(_toElement(M1), 2); - - var A = classElement('A'); - expect(_toElement(A), 2); - var X = classElement('X'); + expect(_toType(parseInterfaceType('M1')), 2); + expect(_toType(parseInterfaceType('A')), 2); // class _X&A&M1 extends A implements M1 {} // length: 2 // class X extends _X&A&M1 {} // length: 3 - expect(_toElement(X), 4); + expect(_toType(parseInterfaceType('X')), 4); } void test_class_mixins2() { @@ -47,14 +42,9 @@ class PathToObjectTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M1'), MixinSpec('mixin M2')], ); - var M1 = mixinElement('M1'); - var M2 = mixinElement('M2'); - expect(_toElement(M1), 2); - expect(_toElement(M2), 2); - - var A = classElement('A'); - expect(_toElement(A), 2); - var X = classElement('X'); + expect(_toType(parseInterfaceType('M1')), 2); + expect(_toType(parseInterfaceType('M2')), 2); + expect(_toType(parseInterfaceType('A')), 2); // class _X&A&M1 extends A implements M1 {} // length: 2 @@ -62,7 +52,7 @@ class PathToObjectTest extends AbstractTypeSystemTest { // length: 3 // class X extends _X&A&M1&M2 {} // length: 4 - expect(_toElement(X), 5); + expect(_toType(parseInterfaceType('X')), 5); } void test_class_mixins_longerViaSecondMixin() { @@ -76,22 +66,12 @@ class PathToObjectTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M1'), MixinSpec('mixin M2 implements I3')], ); - var I1 = classElement('I1'); - var I2 = classElement('I2'); - var I3 = classElement('I3'); - - expect(_toElement(I1), 2); - expect(_toElement(I2), 3); - expect(_toElement(I3), 4); - - var M1 = mixinElement('M1'); - var M2 = mixinElement('M2'); - expect(_toElement(M1), 2); - expect(_toElement(M2), 5); - - var A = classElement('A'); - expect(_toElement(A), 2); - var X = classElement('X'); + expect(_toType(parseInterfaceType('I1')), 2); + expect(_toType(parseInterfaceType('I2')), 3); + expect(_toType(parseInterfaceType('I3')), 4); + expect(_toType(parseInterfaceType('M1')), 2); + expect(_toType(parseInterfaceType('M2')), 5); + expect(_toType(parseInterfaceType('A')), 2); // class _X&A&M1 extends A implements M1 {} // length: 2 @@ -99,7 +79,7 @@ class PathToObjectTest extends AbstractTypeSystemTest { // length: 5 = max(1 + _X&A&M1, 1 + M2) // class X extends _X&A&M1&M2 {} // length: 6 - expect(_toElement(X), 7); + expect(_toType(parseInterfaceType('X')), 7); } void test_class_multipleInterfacePaths() { @@ -125,13 +105,11 @@ class PathToObjectTest extends AbstractTypeSystemTest { ClassSpec('class E implements B, D'), ], ); - var classB = classElement('B'); - var classE = classElement('E'); // assertion: even though the longest path to Object for typeB is 2, and // typeE implements typeB, the longest path for typeE is 4 since it also // implements typeD - expect(_toElement(classB), 3); - expect(_toElement(classE), 5); + expect(_toType(parseInterfaceType('B')), 3); + expect(_toType(parseInterfaceType('E')), 5); } void test_class_multipleSuperclassPaths() { @@ -157,32 +135,27 @@ class PathToObjectTest extends AbstractTypeSystemTest { ClassSpec('class E extends B implements D'), ], ); - var classB = classElement('B'); - var classE = classElement('E'); // assertion: even though the longest path to Object for typeB is 2, and // typeE extends typeB, the longest path for typeE is 4 since it also // implements typeD - expect(_toElement(classB), 3); - expect(_toElement(classE), 5); + expect(_toType(parseInterfaceType('B')), 3); + expect(_toType(parseInterfaceType('E')), 5); } void test_class_null() { - expect(_toType(nullNone), 1); + expect(_toType(parseInterfaceType('Null')), 1); } void test_class_object() { - expect(_toType(objectQuestion), 0); - expect(_toType(objectNone), 1); + expect(_toType(parseInterfaceType('Object?')), 0); + expect(_toType(parseInterfaceType('Object')), 1); } void test_class_recursion() { buildTestLibrary( - classes: [ClassSpec('class A'), ClassSpec('class B extends A')], + classes: [ClassSpec('class A extends B'), ClassSpec('class B extends A')], ); - var classA = classElement('A'); - var classB = classElement('B'); - classA.supertype = interfaceTypeNone(classB); - expect(_toElement(classA), 2); + expect(_toType(parseInterfaceType('A')), 2); } void test_class_singleInterfacePath() { @@ -204,12 +177,9 @@ class PathToObjectTest extends AbstractTypeSystemTest { ClassSpec('class C implements B'), ], ); - var classA = classElement('A'); - var classB = classElement('B'); - var classC = classElement('C'); - expect(_toElement(classA), 2); - expect(_toElement(classB), 3); - expect(_toElement(classC), 4); + expect(_toType(parseInterfaceType('A')), 2); + expect(_toType(parseInterfaceType('B')), 3); + expect(_toType(parseInterfaceType('C')), 4); } void test_class_singleSuperclassPath() { @@ -231,12 +201,9 @@ class PathToObjectTest extends AbstractTypeSystemTest { ClassSpec('class C extends B'), ], ); - var classA = classElement('A'); - var classB = classElement('B'); - var classC = classElement('C'); - expect(_toElement(classA), 2); - expect(_toElement(classB), 3); - expect(_toElement(classC), 4); + expect(_toType(parseInterfaceType('A')), 2); + expect(_toType(parseInterfaceType('B')), 3); + expect(_toType(parseInterfaceType('C')), 4); } void test_mixin_constraints_interfaces_allSame() { @@ -249,18 +216,13 @@ class PathToObjectTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M on A, B implements I, J')], ); - var A = classElement('A'); - var B = classElement('B'); - var I = classElement('I'); - var J = classElement('J'); - expect(_toElement(A), 2); - expect(_toElement(B), 2); - expect(_toElement(I), 2); - expect(_toElement(J), 2); - var M = mixinElement('M'); + expect(_toType(parseInterfaceType('A')), 2); + expect(_toType(parseInterfaceType('B')), 2); + expect(_toType(parseInterfaceType('I')), 2); + expect(_toType(parseInterfaceType('J')), 2); // The interface of M is: // class _M&A&A implements A, B, I, J {} - expect(_toElement(M), 3); + expect(_toType(parseInterfaceType('M')), 3); } void test_mixin_longerConstraint_1() { @@ -274,18 +236,13 @@ class PathToObjectTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M on A, B implements I, J')], ); - var A = classElement('A'); - var B = classElement('B'); - var I = classElement('I'); - var J = classElement('J'); - expect(_toElement(A), 3); - expect(_toElement(B), 2); - expect(_toElement(I), 2); - expect(_toElement(J), 2); - var M = mixinElement('M'); + expect(_toType(parseInterfaceType('A')), 3); + expect(_toType(parseInterfaceType('B')), 2); + expect(_toType(parseInterfaceType('I')), 2); + expect(_toType(parseInterfaceType('J')), 2); // The interface of M is: // class _M&A&A implements A, B, I, J {} - expect(_toElement(M), 4); + expect(_toType(parseInterfaceType('M')), 4); } void test_mixin_longerConstraint_2() { @@ -299,18 +256,13 @@ class PathToObjectTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M on A, B implements I, J')], ); - var A = classElement('A'); - var B = classElement('B'); - var I = classElement('I'); - var J = classElement('J'); - expect(_toElement(A), 2); - expect(_toElement(B), 3); - expect(_toElement(I), 2); - expect(_toElement(J), 2); - var M = mixinElement('M'); + expect(_toType(parseInterfaceType('A')), 2); + expect(_toType(parseInterfaceType('B')), 3); + expect(_toType(parseInterfaceType('I')), 2); + expect(_toType(parseInterfaceType('J')), 2); // The interface of M is: // class _M&A&A implements A, B, I, J {} - expect(_toElement(M), 4); + expect(_toType(parseInterfaceType('M')), 4); } void test_mixin_longerInterface_1() { @@ -324,23 +276,13 @@ class PathToObjectTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M on A, B implements I, J')], ); - var A = classElement('A'); - var B = classElement('B'); - var I = classElement('I'); - var J = classElement('J'); - expect(_toElement(A), 2); - expect(_toElement(B), 2); - expect(_toElement(I), 3); - expect(_toElement(J), 2); - var M = mixinElement('M'); + expect(_toType(parseInterfaceType('A')), 2); + expect(_toType(parseInterfaceType('B')), 2); + expect(_toType(parseInterfaceType('I')), 3); + expect(_toType(parseInterfaceType('J')), 2); // The interface of M is: // class _M&A&A implements A, B, I, J {} - expect(_toElement(M), 4); - } - - int _toElement(InterfaceElementImpl element) { - var type = interfaceTypeNone(element); - return _toType(type); + expect(_toType(parseInterfaceType('M')), 4); } int _toType(InterfaceType type) { @@ -371,36 +313,28 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ClassSpec('class D'), ], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var classC = classElement('C'); - var classD = classElement('D'); + var instA = parseInterfaceType('A'); // A expect( _superInterfaces(instA), - unorderedEquals([objectQuestion, objectNone]), + unorderedEquals([parseType('Object?'), parseType('Object')]), ); // B expect( - _superInterfaces( - interfaceTypeNone(classB, typeArguments: [interfaceTypeNone(classD)]), - ), - unorderedEquals([objectQuestion, objectNone, instA]), + _superInterfaces(parseInterfaceType('B')), + unorderedEquals([parseType('Object?'), parseType('Object'), instA]), ); // C expect( - _superInterfaces( - interfaceTypeNone(classC, typeArguments: [interfaceTypeNone(classD)]), - ), + _superInterfaces(parseInterfaceType('C')), unorderedEquals([ - objectQuestion, - objectNone, + parseType('Object?'), + parseType('Object'), instA, - interfaceTypeNone(classB, typeArguments: [interfaceTypeNone(classD)]), + parseInterfaceType('B'), ]), ); } @@ -424,36 +358,28 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ClassSpec('class D'), ], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var classC = classElement('C'); - var classD = classElement('D'); + var instA = parseInterfaceType('A'); // A expect( _superInterfaces(instA), - unorderedEquals([objectQuestion, objectNone]), + unorderedEquals([parseType('Object?'), parseType('Object')]), ); // B expect( - _superInterfaces( - interfaceTypeNone(classB, typeArguments: [interfaceTypeNone(classD)]), - ), - unorderedEquals([objectQuestion, objectNone, instA]), + _superInterfaces(parseInterfaceType('B')), + unorderedEquals([parseType('Object?'), parseType('Object'), instA]), ); // C expect( - _superInterfaces( - interfaceTypeNone(classC, typeArguments: [interfaceTypeNone(classD)]), - ), + _superInterfaces(parseInterfaceType('C')), unorderedEquals([ - objectQuestion, - objectNone, + parseType('Object?'), + parseType('Object'), instA, - interfaceTypeNone(classB, typeArguments: [interfaceTypeNone(classD)]), + parseInterfaceType('B'), ]), ); } @@ -467,29 +393,30 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M on B, C')], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); - var classC = classElement('C'); - var instC = interfaceTypeNone(classC); - var mixinM = mixinElement('M'); - var instM = interfaceTypeNone(mixinM); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); + var instC = parseInterfaceType('C'); + var instM = parseInterfaceType('M'); expect( _superInterfaces(instM), - unorderedEquals([objectQuestion, objectNone, instA, instB, instC]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instB, + instC, + ]), ); } void test_mixin_constraints_object() { buildTestLibrary(mixins: [MixinSpec('mixin M')]); - var mixinM = mixinElement('M'); - var instM = interfaceTypeNone(mixinM); + var instM = parseInterfaceType('M'); expect( _superInterfaces(instM), - unorderedEquals([objectQuestion, objectNone]), + unorderedEquals([parseType('Object?'), parseType('Object')]), ); } @@ -502,18 +429,20 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ], mixins: [MixinSpec('mixin M implements B, C')], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); - var classC = classElement('C'); - var instC = interfaceTypeNone(classC); - var mixinM = mixinElement('M'); - var instM = interfaceTypeNone(mixinM); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); + var instC = parseInterfaceType('C'); + var instM = parseInterfaceType('M'); expect( _superInterfaces(instM), - unorderedEquals([objectQuestion, objectNone, instA, instB, instC]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instB, + instC, + ]), ); } @@ -527,27 +456,34 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ClassSpec('class E implements B, D'), ], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); - var classC = classElement('C'); - var instC = interfaceTypeNone(classC); - var classD = classElement('D'); - var instD = interfaceTypeNone(classD); - var classE = classElement('E'); - var instE = interfaceTypeNone(classE); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); + var instC = parseInterfaceType('C'); + var instD = parseInterfaceType('D'); + var instE = parseInterfaceType('E'); // D expect( _superInterfaces(instD), - unorderedEquals([objectQuestion, objectNone, instA, instC]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instC, + ]), ); // E expect( _superInterfaces(instE), - unorderedEquals([objectQuestion, objectNone, instA, instB, instC, instD]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instB, + instC, + instD, + ]), ); } @@ -561,27 +497,34 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ClassSpec('class E extends B implements D'), ], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); - var classC = classElement('C'); - var instC = interfaceTypeNone(classC); - var classD = classElement('D'); - var instD = interfaceTypeNone(classD); - var classE = classElement('E'); - var instE = interfaceTypeNone(classE); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); + var instC = parseInterfaceType('C'); + var instD = parseInterfaceType('D'); + var instE = parseInterfaceType('E'); // D expect( _superInterfaces(instD), - unorderedEquals([objectQuestion, objectNone, instA, instC]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instC, + ]), ); // E expect( _superInterfaces(instE), - unorderedEquals([objectQuestion, objectNone, instA, instB, instC, instD]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instB, + instC, + instD, + ]), ); } @@ -590,9 +533,8 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { classes: [ClassSpec('class A'), ClassSpec('class B extends A')], ); var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); classA.supertype = instB; @@ -609,29 +551,31 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ClassSpec('class C implements B'), ], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); - var classC = classElement('C'); - var instC = interfaceTypeNone(classC); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); + var instC = parseInterfaceType('C'); // A expect( _superInterfaces(instA), - unorderedEquals([objectQuestion, objectNone]), + unorderedEquals([parseType('Object?'), parseType('Object')]), ); // B expect( _superInterfaces(instB), - unorderedEquals([objectQuestion, objectNone, instA]), + unorderedEquals([parseType('Object?'), parseType('Object'), instA]), ); // C expect( _superInterfaces(instC), - unorderedEquals([objectQuestion, objectNone, instA, instB]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instB, + ]), ); } @@ -650,29 +594,31 @@ class SuperinterfaceSetTest extends AbstractTypeSystemTest { ClassSpec('class C extends B'), ], ); - var classA = classElement('A'); - var instA = interfaceTypeNone(classA); - var classB = classElement('B'); - var instB = interfaceTypeNone(classB); - var classC = classElement('C'); - var instC = interfaceTypeNone(classC); + var instA = parseInterfaceType('A'); + var instB = parseInterfaceType('B'); + var instC = parseInterfaceType('C'); // A expect( _superInterfaces(instA), - unorderedEquals([objectQuestion, objectNone]), + unorderedEquals([parseType('Object?'), parseType('Object')]), ); // B expect( _superInterfaces(instB), - unorderedEquals([objectQuestion, objectNone, instA]), + unorderedEquals([parseType('Object?'), parseType('Object'), instA]), ); // C expect( _superInterfaces(instC), - unorderedEquals([objectQuestion, objectNone, instA, instB]), + unorderedEquals([ + parseType('Object?'), + parseType('Object'), + instA, + instB, + ]), ); } diff --git a/pkg/analyzer/test/src/dart/element/non_covariant_type_parameter_position_test.dart b/pkg/analyzer/test/src/dart/element/non_covariant_type_parameter_position_test.dart index f1ed506c6fa..a80da2cecce 100644 --- a/pkg/analyzer/test/src/dart/element/non_covariant_type_parameter_position_test.dart +++ b/pkg/analyzer/test/src/dart/element/non_covariant_type_parameter_position_test.dart @@ -4,8 +4,8 @@ import 'package:_fe_analyzer_shared/src/types/shared_type.dart'; import 'package:analyzer/dart/element/type.dart'; +import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/non_covariant_type_parameter_position.dart'; -import 'package:analyzer/src/dart/element/type.dart'; import 'package:test/test.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; @@ -20,116 +20,111 @@ main() { @reflectiveTest class NonCovariantTypeParameterPositionVisitorTest extends AbstractTypeSystemTest { - late final T_element = typeParameter('T'); - late final T = typeParameterTypeNone(T_element); - - FunctionTypeImpl get _contravariantT { - return functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: T)], - ); - } - - void expectNonCovariant(DartType type) { - var actual = _compute(type); + void expectNonCovariant(DartType type, TypeParameterElementImpl T) { + var actual = _compute(type, T); expect(actual, isTrue); } - void expectNotNonCovariant(DartType type) { - var actual = _compute(type); + void expectNotNonCovariant(DartType type, TypeParameterElementImpl T) { + var actual = _compute(type, T); expect(actual, isFalse); } test_dynamic() { - expectNotNonCovariant(dynamicType); + withTypeParameterScope('T', (scope) { + expectNotNonCovariant(parseType('dynamic'), scope.typeParameter('T')); + }); } test_function() { - expectNotNonCovariant(functionTypeNone(returnType: T)); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - // void Function(T) - expectNonCovariant(_contravariantT); + expectNotNonCovariant(scope.parseType('T Function()'), T); - // void Function(T) Function() - expectNonCovariant(functionTypeNone(returnType: _contravariantT)); + // void Function(T) + expectNonCovariant(scope.parseType('void Function([T])'), T); - // void Function(void Function(T)) - expectNotNonCovariant( - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: _contravariantT)], - ), - ); + // void Function(T) Function() + expectNonCovariant(scope.parseType('void Function([T]) Function()'), T); - // T Function(T) - expectNonCovariant( - functionTypeNone( - returnType: T, - formalParameters: [positionalParameter(type: T)], - ), - ); + // void Function(void Function(T)) + expectNotNonCovariant( + scope.parseType('void Function([void Function([T])])'), + T, + ); + + // T Function(T) + expectNonCovariant(scope.parseType('T Function([T])'), T); + + // void Function() + expectNonCovariant(scope.parseType('void Function()'), T); + }); // Not the `T` for which we check. - var T2 = typeParameter('T'); - expectNotNonCovariant( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - positionalParameter(type: typeParameterTypeNone(T2)), - ], - ), - ); - - // void Function() - expectNonCovariant( - functionTypeNone( - typeParameters: [typeParameter('U', bound: T)], - returnType: voidNone, - ), - ); + withTypeParameterScope('T', (scope1) { + var T = scope1.typeParameter('T'); + scope1.withTypeParameterScope('T', (scope2) { + expectNotNonCovariant(scope2.parseType('void Function([T])'), T); + }); + }); } test_interface() { - expectNotNonCovariant(intNone); - expectNotNonCovariant(listNone(T)); - expectNonCovariant(listNone(_contravariantT)); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + expectNotNonCovariant(parseType('int'), T); + expectNotNonCovariant(scope.parseType('List'), T); + expectNonCovariant(scope.parseType('List'), T); + }); } test_invalidType() { - expectNotNonCovariant(invalidType); + withTypeParameterScope('T', (scope) { + expectNotNonCovariant(parseType('InvalidType'), scope.typeParameter('T')); + }); } test_never() { - expectNotNonCovariant(neverNone); + withTypeParameterScope('T', (scope) { + expectNotNonCovariant(parseType('Never'), scope.typeParameter('T')); + }); } test_record() { - expectNotNonCovariant(recordTypeNone(positionalTypes: [T])); - - expectNonCovariant(recordTypeNone(positionalTypes: [_contravariantT])); - - expectNonCovariant(recordTypeNone(positionalTypes: [T, _contravariantT])); - - expectNotNonCovariant(recordTypeNone(namedTypes: {'a': T})); - - expectNonCovariant(recordTypeNone(namedTypes: {'a': _contravariantT})); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + expectNotNonCovariant(scope.parseType('(T,)'), T); + expectNonCovariant(scope.parseType('(void Function([T]),)'), T); + expectNonCovariant(scope.parseType('(T, void Function([T]))'), T); + expectNotNonCovariant(scope.parseType('({T a})'), T); + expectNonCovariant(scope.parseType('({void Function([T]) a})'), T); + }); } test_typeParameter() { - expectNotNonCovariant(T); + withTypeParameterScope('T', (scope1) { + var T = scope1.typeParameter('T'); + scope1.withTypeParameterScope('U', (scope2) { + expectNotNonCovariant(scope2.parseType('U'), T); + }); + }); - var U = typeParameter('U'); - expectNotNonCovariant(typeParameterTypeNone(U)); + withTypeParameterScope('T', (scope) { + expectNotNonCovariant(scope.parseType('T'), scope.typeParameter('T')); + }); } test_void() { - expectNotNonCovariant(voidNone); + withTypeParameterScope('T', (scope) { + expectNotNonCovariant(parseType('void'), scope.typeParameter('T')); + }); } - bool _compute(DartType type) { + bool _compute(DartType type, TypeParameterElementImpl T) { return type.accept( NonCovariantTypeParameterPositionVisitor([ - T_element, + T, ], initialVariance: Variance.covariant), ); } diff --git a/pkg/analyzer/test/src/dart/element/normalize_type_test.dart b/pkg/analyzer/test/src/dart/element/normalize_type_test.dart index 91a87dd4be5..fb668169a64 100644 --- a/pkg/analyzer/test/src/dart/element/normalize_type_test.dart +++ b/pkg/analyzer/test/src/dart/element/normalize_type_test.dart @@ -3,7 +3,6 @@ // BSD-style license that can be found in the LICENSE file. import 'package:analyzer/dart/element/nullability_suffix.dart'; -import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/type.dart'; import 'package:test/test.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; @@ -21,183 +20,76 @@ main() { class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes { test_functionType_parameter() { _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: futureOrNone(objectNone))], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: objectNone)], - ), + parseType('void Function(FutureOr)'), + parseType('void Function(Object)'), ); _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedParameter(name: 'a', type: futureOrNone(objectNone)), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: objectNone)], - ), + parseType('void Function({FutureOr a})'), + parseType('void Function({Object a})'), ); _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedRequiredParameter(name: 'a', type: futureOrNone(objectNone)), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: objectNone)], - ), + parseType('void Function({required FutureOr a})'), + parseType('void Function({required Object a})'), ); _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: futureOrNone(objectNone))], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: objectNone)], - ), + parseType('void Function([FutureOr])'), + parseType('void Function([Object])'), ); } test_functionType_parameter_covariant() { _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - requiredParameter(type: futureOrNone(objectNone), isCovariant: true), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [ - requiredParameter(type: objectNone, isCovariant: true), - ], - ), + parseType('void Function(covariant FutureOr)'), + parseType('void Function(covariant Object)'), ); } test_functionType_parameter_typeParameter() { - TypeParameterElementImpl T; - TypeParameterElementImpl T2; - - T = typeParameter('T', bound: neverNone); - T2 = typeParameter('T2', bound: neverNone); _check( - functionTypeNone( - returnType: voidNone, - typeParameters: [T], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - ), - functionTypeNone( - returnType: voidNone, - typeParameters: [T2], - formalParameters: [requiredParameter(type: neverNone)], - ), + parseType('void Function(T)'), + parseType('void Function(Never)'), ); - T = typeParameter('T', bound: iterableNone(futureOrNone(dynamicType))); - T2 = typeParameter('T2', bound: iterableNone(dynamicType)); _check( - functionTypeNone( - returnType: voidNone, - typeParameters: [T], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - ), - functionTypeNone( - returnType: voidNone, - typeParameters: [T2], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T2))], - ), + parseType('void Function>>(T)'), + parseType('void Function>(T2)'), ); } test_functionType_returnType() { _check( - functionTypeNone(returnType: futureOrNone(objectNone)), - functionTypeNone(returnType: objectNone), + parseType('FutureOr Function()'), + parseType('Object Function()'), ); - _check( - functionTypeNone(returnType: intNone), - functionTypeNone(returnType: intNone), - ); + _check(parseType('int Function()'), parseType('int Function()')); } test_functionType_typeParameter_bound_normalized() { _check( - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T', bound: futureOrNone(objectNone))], - ), - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T', bound: objectNone)], - ), + parseType('void Function>()'), + parseType('void Function()'), ); } test_functionType_typeParameter_bound_unchanged() { _check( - functionTypeNone( - returnType: intNone, - typeParameters: [typeParameter('T', bound: numNone)], - ), - functionTypeNone( - returnType: intNone, - typeParameters: [typeParameter('T', bound: numNone)], - ), + parseType('int Function()'), + parseType('int Function()'), ); } test_functionType_typeParameter_fresh() { - var T = typeParameter('T'); - var T2 = typeParameter('T'); - _check( - functionTypeNone( - returnType: typeParameterTypeNone(T), - typeParameters: [T], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T))], - ), - functionTypeNone( - returnType: typeParameterTypeNone(T2), - typeParameters: [T2], - formalParameters: [requiredParameter(type: typeParameterTypeNone(T2))], - ), - ); + _check(parseType('T Function(T)'), parseType('U Function(U)')); } test_functionType_typeParameter_fresh_bound() { - var T = typeParameter('T'); - var S = typeParameter('S', bound: typeParameterTypeNone(T)); - var T2 = typeParameter('T'); - var S2 = typeParameter('S', bound: typeParameterTypeNone(T2)); _check( - functionTypeNone( - returnType: typeParameterTypeNone(T), - typeParameters: [T, S], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T)), - requiredParameter(type: typeParameterTypeNone(S)), - ], - ), - functionTypeNone( - returnType: typeParameterTypeNone(T2), - typeParameters: [T2, S2], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T2)), - requiredParameter(type: typeParameterTypeNone(S2)), - ], - ), + parseType('T Function(T, S)'), + parseType('U Function(U, V)'), ); } @@ -205,40 +97,43 @@ class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes { /// * let S be NORM(T) test_futureOr() { void check(TypeImpl T, TypeImpl expected) { - var input = futureOrNone(T); + var input = typeProvider.futureOrElement.instantiateImpl( + typeArguments: [T], + nullabilitySuffix: NullabilitySuffix.none, + ); _check(input, expected); } // * if S is a top type then S - check(dynamicType, dynamicType); - check(invalidType, invalidType); - check(voidNone, voidNone); - check(objectQuestion, objectQuestion); + check(parseType('dynamic'), parseType('dynamic')); + check(parseType('InvalidType'), parseType('InvalidType')); + check(parseType('void'), parseType('void')); + check(parseType('Object?'), parseType('Object?')); // * if S is Object then S - check(objectNone, objectNone); + check(parseType('Object'), parseType('Object')); // * if S is Never then Future - check(neverNone, futureNone(neverNone)); + check(parseType('Never'), parseType('Future')); // * if S is Null then Future? - check(nullNone, futureQuestion(nullNone)); + check(parseType('Null'), parseType('Future?')); // * else FutureOr - check(intNone, futureOrNone(intNone)); + check(parseType('int'), parseType('FutureOr')); } test_interfaceType() { - _check(listNone(intNone), listNone(intNone)); + _check(parseType('List'), parseType('List')); - _check(listNone(futureOrNone(objectNone)), listNone(objectNone)); + _check(parseType('List>'), parseType('List')); } test_primitive() { - _check(dynamicType, dynamicType); - _check(neverNone, neverNone); - _check(voidNone, voidNone); - _check(intNone, intNone); + _check(parseType('dynamic'), parseType('dynamic')); + _check(parseType('Never'), parseType('Never')); + _check(parseType('void'), parseType('void')); + _check(parseType('int'), parseType('int')); } /// NORM(T?) @@ -250,12 +145,12 @@ class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes { } // * if S is a top type then S - check(futureOrQuestion(dynamicType), dynamicType); - check(futureOrQuestion(voidNone), voidNone); - check(futureOrQuestion(objectQuestion), objectQuestion); + check(parseType('FutureOr?'), parseType('dynamic')); + check(parseType('FutureOr?'), parseType('void')); + check(parseType('FutureOr?'), parseType('Object?')); // * if S is Never then Null - check(neverQuestion, nullNone); + check(parseType('Never?'), parseType('Null')); // * if S is Never* then Null // Analyzer: impossible, we have only one suffix @@ -264,7 +159,7 @@ class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes { // Analyzer: impossible; `Null?` is always represented as `Null`. // * if S is FutureOr and R is nullable then S - check(futureOrQuestion(intQuestion), futureOrNone(intQuestion)); + check(parseType('FutureOr?'), parseType('FutureOr')); // * if S is FutureOr* and R is nullable then FutureOr // Analyzer: impossible, we have only one suffix @@ -272,95 +167,73 @@ class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes { // * if S is R? then R? // * if S is R* then R? // * else S? - check(intQuestion, intQuestion); - check(objectQuestion, objectQuestion); - check(futureOrQuestion(objectNone), objectQuestion); + check(parseType('int?'), parseType('int?')); + check(parseType('Object?'), parseType('Object?')); + check(parseType('FutureOr?'), parseType('Object?')); } test_recordType() { + _check(parseRecordType('(int,)'), parseRecordType('(int,)')); + _check( - recordTypeNone(positionalTypes: [intNone]), - recordTypeNone(positionalTypes: [intNone]), + parseRecordType('(FutureOr,)'), + parseRecordType('(Object,)'), ); _check( - recordTypeNone(positionalTypes: [futureOrNone(objectNone)]), - recordTypeNone(positionalTypes: [objectNone]), - ); - - _check( - recordTypeNone(namedTypes: {'foo': futureOrNone(objectNone)}), - recordTypeNone(namedTypes: {'foo': objectNone}), + parseRecordType('({FutureOr foo})'), + parseRecordType('({Object foo})'), ); } /// NORM(X & T) /// * let S be NORM(T) test_typeParameter_bound() { - TypeParameterElementImpl T; - // * if S is Never then Never - T = typeParameter('T', bound: neverNone); - _check(typeParameterTypeNone(T), neverNone); + withTypeParameterScope('T extends Never', (scope) { + _check(scope.parseType('T'), parseType('Never')); + }); // * else X - T = typeParameter('T'); - _check(typeParameterTypeNone(T), typeParameterTypeNone(T)); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T'), scope.parseType('T')); + }); // * else X - T = typeParameter('T', bound: futureOrNone(objectNone)); - _check(typeParameterTypeNone(T), typeParameterTypeNone(T)); + withTypeParameterScope('T extends FutureOr', (scope) { + _check(scope.parseType('T'), scope.parseType('T')); + }); } test_typeParameter_bound_recursive() { - var T = typeParameter('T'); - T.bound = iterableNone(typeParameterTypeNone(T)); - _check(typeParameterTypeNone(T), typeParameterTypeNone(T)); + withTypeParameterScope('T extends Iterable', (scope) { + _check(scope.parseType('T'), scope.parseType('T')); + }); } test_typeParameter_promoted() { - var T = typeParameter('T'); + withTypeParameterScope('T', (scope) { + // * if S is Never then Never + _check(scope.parseType('T & Never'), parseType('Never')); - // * if S is Never then Never - _check(promotedTypeParameterTypeNone(T, neverNone), neverNone); + // * if S is a top type then X + _check(scope.parseType('T & Object?'), scope.parseType('T')); + _check(scope.parseType('T & FutureOr?'), scope.parseType('T')); - // * if S is a top type then X - _check( - promotedTypeParameterTypeNone(T, objectQuestion), - typeParameterTypeNone(T), - ); - _check( - promotedTypeParameterTypeNone(T, futureOrQuestion(objectNone)), - typeParameterTypeNone(T), - ); + // * if S is X then X + _check(scope.parseType('T & T'), scope.parseType('T')); - // * if S is X then X - _check( - promotedTypeParameterTypeNone(T, typeParameterTypeNone(T)), - typeParameterTypeNone(T), - ); + // else X & S + _check( + scope.parseType('T & FutureOr'), + scope.parseType('T & Future'), + ); + }); // * if S is Object and NORM(B) is Object where B is the bound of X then X - T = typeParameter('T', bound: objectNone); - _check( - promotedTypeParameterTypeNone(T, futureOrNone(objectNone)), - typeParameterTypeNone(T), - ); - - // else X & S - T = typeParameter('T'); - _check( - promotedTypeParameterType( - element: T, - nullabilitySuffix: NullabilitySuffix.none, - promotedBound: futureOrNone(neverNone), - ), - promotedTypeParameterType( - element: T, - nullabilitySuffix: NullabilitySuffix.none, - promotedBound: futureNone(neverNone), - ), - ); + withTypeParameterScope('T extends Object', (scope) { + _check(scope.parseType('T & FutureOr'), scope.parseType('T')); + }); } void _assertNullability(TypeImpl type, NullabilitySuffix expected) { diff --git a/pkg/analyzer/test/src/dart/element/nullable_test.dart b/pkg/analyzer/test/src/dart/element/nullable_test.dart index bc9b9a9c07e..ab33fb0f0e1 100644 --- a/pkg/analyzer/test/src/dart/element/nullable_test.dart +++ b/pkg/analyzer/test/src/dart/element/nullable_test.dart @@ -34,100 +34,91 @@ class IsNonNullableTest extends AbstractTypeSystemTest { } test_dynamic() { - isNotNonNullable(dynamicType); + isNotNonNullable(parseType('dynamic')); } test_function() { - isNonNullable(functionTypeNone(returnType: voidNone)); + isNonNullable(parseType('void Function()')); - isNotNonNullable(functionTypeQuestion(returnType: voidNone)); + isNotNonNullable(parseType('void Function()?')); } test_functionClass() { - isNonNullable(functionNone); - isNotNonNullable(functionQuestion); + isNonNullable(parseType('Function')); + isNotNonNullable(parseType('Function?')); } test_futureOr_noneArgument() { - isNonNullable(futureOrNone(intNone)); + isNonNullable(parseType('FutureOr')); - isNotNonNullable(futureOrQuestion(intNone)); + isNotNonNullable(parseType('FutureOr?')); } test_futureOr_questionArgument() { - isNotNonNullable(futureOrNone(intQuestion)); + isNotNonNullable(parseType('FutureOr')); - isNotNonNullable(futureOrQuestion(intQuestion)); + isNotNonNullable(parseType('FutureOr?')); } test_interface() { - isNonNullable(intNone); - isNotNonNullable(intQuestion); + isNonNullable(parseType('int')); + isNotNonNullable(parseType('int?')); } test_interface_extensionType2() { - buildTestLibrary( - extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], - ); - var A = extensionTypeElement('A'); buildTestLibrary( extensionTypes: [ - ExtensionTypeSpec('extension type A(int it) implements int'), + ExtensionTypeSpec('extension type A(int it)'), + ExtensionTypeSpec('extension type B(int it) implements int'), ], ); - var AWithInt = extensionTypeElement('A'); - isNotNonNullable(interfaceTypeNone(A)); - - isNonNullable(interfaceTypeNone(AWithInt)); + isNotNonNullable(parseInterfaceType('A')); + isNonNullable(parseInterfaceType('B')); } test_invalidType() { - isNotNonNullable(invalidType); + isNotNonNullable(parseType('InvalidType')); } test_never() { - isNonNullable(neverNone); - isNotNonNullable(neverQuestion); + isNonNullable(parseType('Never')); + isNotNonNullable(parseType('Never?')); } test_null() { - isNotNonNullable(nullNone); + isNotNonNullable(parseType('Null')); } test_typeParameter_boundNone() { - var T = typeParameter('T', bound: intNone); - - isNonNullable(typeParameterTypeNone(T)); - - isNotNonNullable(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends int', (scope) { + isNonNullable(scope.parseType('T')); + isNotNonNullable(scope.parseType('T?')); + }); } test_typeParameter_boundQuestion() { - var T = typeParameter('T', bound: intQuestion); - - isNotNonNullable(typeParameterTypeNone(T)); - - isNotNonNullable(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends int?', (scope) { + isNotNonNullable(scope.parseType('T')); + isNotNonNullable(scope.parseType('T?')); + }); } test_typeParameter_promotedBoundNone() { - var T = typeParameter('T'); - - isNonNullable(typeParameterTypeNone(T, promotedBound: intNone)); - - isNonNullable(typeParameterTypeQuestion(T, promotedBound: intNone)); + withTypeParameterScope('T', (scope) { + isNonNullable(scope.parseType('T & int')); + isNonNullable(scope.parseType('(T & int)?')); + }); } test_typeParameter_promotedBoundQuestion() { - var T = typeParameter('T'); - - isNotNonNullable(typeParameterTypeNone(T, promotedBound: intQuestion)); - - isNotNonNullable(typeParameterTypeQuestion(T, promotedBound: intQuestion)); + withTypeParameterScope('T', (scope) { + isNotNonNullable(scope.parseType('T & int?')); + isNotNonNullable(scope.parseType('(T & int?)?')); + }); } test_void() { - isNotNonNullable(voidNone); + isNotNonNullable(parseType('void')); } } @@ -142,102 +133,92 @@ class IsNullableTest extends AbstractTypeSystemTest { } test_dynamic() { - isNullable(dynamicType); + isNullable(parseType('dynamic')); } test_function() { - isNotNullable(functionTypeNone(returnType: voidNone)); + isNotNullable(parseType('void Function()')); - isNullable(functionTypeQuestion(returnType: voidNone)); + isNullable(parseType('void Function()?')); } test_functionClass() { - isNotNullable(functionNone); - isNullable(functionQuestion); + isNotNullable(parseType('Function')); + isNullable(parseType('Function?')); } test_futureOr_noneArgument() { - isNotNullable(futureOrNone(intNone)); + isNotNullable(parseType('FutureOr')); - isNullable(futureOrQuestion(intNone)); + isNullable(parseType('FutureOr?')); } test_futureOr_questionArgument() { - isNullable(futureOrNone(intQuestion)); + isNullable(parseType('FutureOr')); - isNullable(futureOrQuestion(intQuestion)); + isNullable(parseType('FutureOr?')); } test_interface() { - isNotNullable(intNone); - isNullable(intQuestion); + isNotNullable(parseType('int')); + isNullable(parseType('int?')); } test_interface_extensionType2() { - buildTestLibrary( - extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], - ); - var A = extensionTypeElement('A'); buildTestLibrary( extensionTypes: [ - ExtensionTypeSpec('extension type A(int it) implements int'), + ExtensionTypeSpec('extension type A(int it)'), + ExtensionTypeSpec('extension type B(int it) implements int'), ], ); - var AWithInt = extensionTypeElement('A'); - isNotNullable(interfaceTypeNone(A)); - - isNotNullable(interfaceTypeNone(AWithInt)); - - isNullable(interfaceTypeQuestion(AWithInt)); + isNotNullable(parseInterfaceType('A')); + isNotNullable(parseInterfaceType('B')); + isNullable(parseInterfaceType('B?')); } test_invalidType() { - isNullable(invalidType); + isNullable(parseType('InvalidType')); } test_never() { - isNotNullable(neverNone); - isNullable(neverQuestion); + isNotNullable(parseType('Never')); + isNullable(parseType('Never?')); } test_null() { - isNullable(nullNone); + isNullable(parseType('Null')); } test_typeParameter_boundNone() { - var T = typeParameter('T', bound: intNone); - - isNotNullable(typeParameterTypeNone(T)); - - isNullable(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends int', (scope) { + isNotNullable(scope.parseType('T')); + isNullable(scope.parseType('T?')); + }); } test_typeParameter_boundQuestion_none() { - var T = typeParameter('T', bound: intQuestion); - - isNotNullable(typeParameterTypeNone(T)); - - isNullable(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends int?', (scope) { + isNotNullable(scope.parseType('T')); + isNullable(scope.parseType('T?')); + }); } test_typeParameter_promotedBoundNone() { - var T = typeParameter('T'); - - isNotNullable(typeParameterTypeNone(T, promotedBound: intNone)); - - isNotNullable(typeParameterTypeQuestion(T, promotedBound: intNone)); + withTypeParameterScope('T', (scope) { + isNotNullable(scope.parseType('T & int')); + isNotNullable(scope.parseType('(T & int)?')); + }); } test_typeParameter_promotedBoundQuestion() { - var T = typeParameter('T'); - - isNullable(typeParameterTypeNone(T, promotedBound: intQuestion)); - - isNullable(typeParameterTypeQuestion(T, promotedBound: intQuestion)); + withTypeParameterScope('T', (scope) { + isNullable(scope.parseType('T & int?')); + isNullable(scope.parseType('(T & int?)?')); + }); } test_void() { - isNullable(voidNone); + isNullable(parseType('void')); } } @@ -252,50 +233,45 @@ class IsPotentiallyNonNullableTest extends AbstractTypeSystemTest { } test_dynamic() { - isNotPotentiallyNonNullable(dynamicType); + isNotPotentiallyNonNullable(parseType('dynamic')); } test_futureOr() { - isPotentiallyNonNullable(futureOrNone(intNone)); + isPotentiallyNonNullable(parseType('FutureOr')); - isNotPotentiallyNonNullable(futureOrNone(intQuestion)); + isNotPotentiallyNonNullable(parseType('FutureOr')); } test_interface() { - isPotentiallyNonNullable(intNone); - isNotPotentiallyNonNullable(intQuestion); + isPotentiallyNonNullable(parseType('int')); + isNotPotentiallyNonNullable(parseType('int?')); } test_interface_extensionType2() { - buildTestLibrary( - extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], - ); - var A = extensionTypeElement('A'); buildTestLibrary( extensionTypes: [ - ExtensionTypeSpec('extension type A(int it) implements int'), + ExtensionTypeSpec('extension type A(int it)'), + ExtensionTypeSpec('extension type B(int it) implements int'), ], ); - var AWithInt = extensionTypeElement('A'); - isPotentiallyNonNullable(interfaceTypeNone(A)); - - isPotentiallyNonNullable(interfaceTypeNone(AWithInt)); + isPotentiallyNonNullable(parseInterfaceType('A')); + isPotentiallyNonNullable(parseInterfaceType('B')); } test_invalidType() { - isNotPotentiallyNonNullable(invalidType); + isNotPotentiallyNonNullable(parseType('InvalidType')); } test_never() { - isPotentiallyNonNullable(neverNone); + isPotentiallyNonNullable(parseType('Never')); } test_null() { - isNotPotentiallyNonNullable(nullNone); + isNotPotentiallyNonNullable(parseType('Null')); } test_void() { - isNotPotentiallyNonNullable(voidNone); + isNotPotentiallyNonNullable(parseType('void')); } } @@ -310,52 +286,46 @@ class IsPotentiallyNullableTest extends AbstractTypeSystemTest { } test_dynamic() { - isPotentiallyNullable(dynamicType); + isPotentiallyNullable(parseType('dynamic')); } test_futureOr() { - isNotPotentiallyNullable(futureOrNone(intNone)); + isNotPotentiallyNullable(parseType('FutureOr')); - isPotentiallyNullable(futureOrNone(intQuestion)); + isPotentiallyNullable(parseType('FutureOr')); } test_interface() { - isNotPotentiallyNullable(intNone); - isPotentiallyNullable(intQuestion); + isNotPotentiallyNullable(parseType('int')); + isPotentiallyNullable(parseType('int?')); } test_interface_extensionType2() { - buildTestLibrary( - extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], - ); - var A = extensionTypeElement('A'); buildTestLibrary( extensionTypes: [ - ExtensionTypeSpec('extension type A(int it) implements int'), + ExtensionTypeSpec('extension type A(int it)'), + ExtensionTypeSpec('extension type B(int it) implements int'), ], ); - var AWithInt = extensionTypeElement('A'); - isPotentiallyNullable(interfaceTypeQuestion(A)); - - isPotentiallyNullable(interfaceTypeNone(A)); - - isNotPotentiallyNullable(interfaceTypeNone(AWithInt)); + isPotentiallyNullable(parseInterfaceType('A?')); + isPotentiallyNullable(parseInterfaceType('A')); + isNotPotentiallyNullable(parseInterfaceType('B')); } test_invalidType() { - isPotentiallyNullable(invalidType); + isPotentiallyNullable(parseType('InvalidType')); } test_never() { - isNotPotentiallyNullable(neverNone); + isNotPotentiallyNullable(parseType('Never')); } test_null() { - isPotentiallyNullable(nullNone); + isPotentiallyNullable(parseType('Null')); } test_void() { - isPotentiallyNullable(voidNone); + isPotentiallyNullable(parseType('void')); } } @@ -370,226 +340,220 @@ class IsStrictlyNonNullableTest extends AbstractTypeSystemTest { } test_dynamic() { - isNotStrictlyNonNullable(dynamicType); + isNotStrictlyNonNullable(parseType('dynamic')); } test_function() { - isStrictlyNonNullable(functionTypeNone(returnType: voidNone)); + isStrictlyNonNullable(parseType('void Function()')); - isNotStrictlyNonNullable(functionTypeQuestion(returnType: voidNone)); + isNotStrictlyNonNullable(parseType('void Function()?')); } test_functionClass() { - isStrictlyNonNullable(functionNone); - isNotStrictlyNonNullable(functionQuestion); + isStrictlyNonNullable(parseType('Function')); + isNotStrictlyNonNullable(parseType('Function?')); } test_futureOr_noneArgument() { - isStrictlyNonNullable(futureOrNone(intNone)); + isStrictlyNonNullable(parseType('FutureOr')); - isNotStrictlyNonNullable(futureOrQuestion(intNone)); + isNotStrictlyNonNullable(parseType('FutureOr?')); } test_futureOr_questionArgument() { - isNotStrictlyNonNullable(futureOrNone(intQuestion)); + isNotStrictlyNonNullable(parseType('FutureOr')); - isNotStrictlyNonNullable(futureOrQuestion(intQuestion)); + isNotStrictlyNonNullable(parseType('FutureOr?')); } test_interface() { - isStrictlyNonNullable(intNone); - isNotStrictlyNonNullable(intQuestion); + isStrictlyNonNullable(parseType('int')); + isNotStrictlyNonNullable(parseType('int?')); } test_interface_extensionType2() { - buildTestLibrary( - extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], - ); - var A = extensionTypeElement('A'); buildTestLibrary( extensionTypes: [ - ExtensionTypeSpec('extension type A(int it) implements int'), + ExtensionTypeSpec('extension type A(int it)'), + ExtensionTypeSpec('extension type B(int it) implements int'), ], ); - var AWithInt = extensionTypeElement('A'); - isNotStrictlyNonNullable(interfaceTypeNone(A)); - - isStrictlyNonNullable(interfaceTypeNone(AWithInt)); + isNotStrictlyNonNullable(parseInterfaceType('A')); + isStrictlyNonNullable(parseInterfaceType('B')); } test_invalidType() { - isNotStrictlyNonNullable(invalidType); + isNotStrictlyNonNullable(parseType('InvalidType')); } test_never() { - isStrictlyNonNullable(neverNone); - isNotStrictlyNonNullable(neverQuestion); + isStrictlyNonNullable(parseType('Never')); + isNotStrictlyNonNullable(parseType('Never?')); } test_null() { - isNotStrictlyNonNullable(nullNone); + isNotStrictlyNonNullable(parseType('Null')); } test_typeParameter_boundNone() { - var T = typeParameter('T', bound: intNone); - - isStrictlyNonNullable(typeParameterTypeNone(T)); - - isNotStrictlyNonNullable(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends int', (scope) { + isStrictlyNonNullable(scope.parseType('T')); + isNotStrictlyNonNullable(scope.parseType('T?')); + }); } test_typeParameter_boundQuestion() { - var T = typeParameter('T', bound: intQuestion); - - isNotStrictlyNonNullable(typeParameterTypeNone(T)); - - isNotStrictlyNonNullable(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends int?', (scope) { + isNotStrictlyNonNullable(scope.parseType('T')); + isNotStrictlyNonNullable(scope.parseType('T?')); + }); } test_void() { - isNotStrictlyNonNullable(voidNone); + isNotStrictlyNonNullable(parseType('void')); } } @reflectiveTest class PromoteToNonNullTest extends AbstractTypeSystemTest { test_dynamic() { - _check(dynamicType, dynamicType); + _check(parseType('dynamic'), parseType('dynamic')); } test_functionType() { // NonNull(T0 Function(...)) = T0 Function(...) - _check( - functionTypeQuestion(returnType: voidNone), - functionTypeNone(returnType: voidNone), - ); + _check(parseType('void Function()?'), parseType('void Function()')); } test_futureOr_question() { // NonNull(FutureOr) = FutureOr - _check(futureOrQuestion(stringQuestion), futureOrNone(stringQuestion)); + _check(parseType('FutureOr?'), parseType('FutureOr')); } test_interfaceType() { - _check(intNone, intNone); - _check(intQuestion, intNone); + _check(parseType('int'), parseType('int')); + _check(parseType('int?'), parseType('int')); // NonNull(C) = C - _check(listQuestion(intQuestion), listNone(intQuestion)); + _check(parseType('List?'), parseType('List')); } test_interfaceType_function() { - _check(functionQuestion, functionNone); + _check(parseType('Function?'), parseType('Function')); } test_invalidType() { - _check(invalidType, invalidType); + _check(parseType('InvalidType'), parseType('InvalidType')); } test_never() { - _check(neverNone, neverNone); - _check(neverQuestion, neverNone); + _check(parseType('Never'), parseType('Never')); + _check(parseType('Never?'), parseType('Never')); } test_null() { - _check(nullNone, neverNone); + _check(parseType('Null'), parseType('Never')); } test_typeParameter_bound_dynamic() { - var element = typeParameter('T', bound: dynamicType); - - _checkTypeParameter( - typeParameterTypeNone(element), - element: element, - promotedBound: null, - ); + withTypeParameterScope('T extends dynamic', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T'), + element: element, + promotedBound: null, + ); + }); } test_typeParameter_bound_invalidType() { - var element = typeParameter('T', bound: invalidType); - - _checkTypeParameter( - typeParameterTypeNone(element), - element: element, - promotedBound: null, - ); + withTypeParameterScope('T extends InvalidType', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T'), + element: element, + promotedBound: null, + ); + }); } test_typeParameter_bound_none() { - var element = typeParameter('T', bound: intNone); - - _checkTypeParameter( - typeParameterTypeNone(element), - element: element, - promotedBound: null, - ); - - _checkTypeParameter( - typeParameterTypeQuestion(element), - element: element, - promotedBound: null, - ); + withTypeParameterScope('T extends int', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T'), + element: element, + promotedBound: null, + ); + _checkTypeParameter( + scope.parseTypeParameterType('T?'), + element: element, + promotedBound: null, + ); + }); } test_typeParameter_bound_null() { - var element = typeParameter('T'); - _checkTypeParameter( - typeParameterTypeNone(element), - element: element, - promotedBound: objectNone, - ); + withTypeParameterScope('T', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T'), + element: element, + promotedBound: parseType('Object'), + ); + }); } test_typeParameter_bound_question() { - var element = typeParameter('T', bound: intQuestion); - - _checkTypeParameter( - typeParameterTypeNone(element), - element: element, - promotedBound: intNone, - ); - - _checkTypeParameter( - typeParameterTypeQuestion(element), - element: element, - promotedBound: intNone, - ); + withTypeParameterScope('T extends int?', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T'), + element: element, + promotedBound: parseType('int'), + ); + _checkTypeParameter( + scope.parseTypeParameterType('T?'), + element: element, + promotedBound: parseType('int'), + ); + }); } test_typeParameter_promotedBound_none() { - var element = typeParameter('T', bound: numQuestion); - - _checkTypeParameter( - promotedTypeParameterTypeNone(element, intNone), - element: element, - promotedBound: intNone, - ); - - _checkTypeParameter( - promotedTypeParameterTypeQuestion(element, intNone), - element: element, - promotedBound: intNone, - ); + withTypeParameterScope('T extends num?', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T & int'), + element: element, + promotedBound: parseType('int'), + ); + _checkTypeParameter( + scope.parseTypeParameterType('(T & int)?'), + element: element, + promotedBound: parseType('int'), + ); + }); } test_typeParameter_promotedBound_question() { - var element = typeParameter('T', bound: numQuestion); - - _checkTypeParameter( - promotedTypeParameterTypeNone(element, intQuestion), - element: element, - promotedBound: intNone, - ); - - _checkTypeParameter( - promotedTypeParameterTypeQuestion(element, intQuestion), - element: element, - promotedBound: intNone, - ); + withTypeParameterScope('T extends num?', (scope) { + var element = scope.typeParameter('T'); + _checkTypeParameter( + scope.parseTypeParameterType('T & int?'), + element: element, + promotedBound: parseType('int'), + ); + _checkTypeParameter( + scope.parseTypeParameterType('(T & int?)?'), + element: element, + promotedBound: parseType('int'), + ); + }); } test_void() { - _check(voidNone, voidNone); + _check(parseType('void'), parseType('void')); } void _check(TypeImpl type, TypeImpl expected) { diff --git a/pkg/analyzer/test/src/dart/element/replace_top_bottom_test.dart b/pkg/analyzer/test/src/dart/element/replace_top_bottom_test.dart index 1c580970bd3..ceece21fc60 100644 --- a/pkg/analyzer/test/src/dart/element/replace_top_bottom_test.dart +++ b/pkg/analyzer/test/src/dart/element/replace_top_bottom_test.dart @@ -21,63 +21,42 @@ main() { class ReplaceTopBottomTest extends AbstractTypeSystemTest { test_contravariant_bottom() { // Not contravariant. - _check(neverNone, 'Never'); + _check(parseType('Never'), 'Never'); - void checkContravariant(TypeImpl type, String expectedStr) { - _check( - functionTypeNone( - returnType: intNone, - formalParameters: [requiredParameter(type: type)], - ), - 'int Function($expectedStr)', - ); - } + _check(parseFunctionType('int Function(Never)'), 'int Function(Object?)'); - checkContravariant(neverNone, 'Object?'); - - checkContravariant( - typeParameterTypeNone(typeParameter('T', bound: neverNone)), - 'Object?', - ); + withTypeParameterScope('T extends Never', (scope) { + _check(scope.parseType('int Function(T)'), 'int Function(Object?)'); + }); } test_notContravariant_covariant_top() { - _check(objectQuestion, 'Never'); - _check(dynamicType, 'Never'); - _check(voidNone, 'Never'); + _check(parseType('Object?'), 'Never'); + _check(parseType('dynamic'), 'Never'); + _check(parseType('void'), 'Never'); - _check(listNone(objectQuestion), 'List'); - _check(listNone(dynamicType), 'List'); - _check(listNone(voidNone), 'List'); + _check(parseType('List'), 'List'); + _check(parseType('List'), 'List'); + _check(parseType('List'), 'List'); - _check(futureOrNone(objectQuestion), 'Never'); - _check(futureOrNone(dynamicType), 'Never'); - _check(futureOrNone(voidNone), 'Never'); - _check(futureOrNone(futureOrNone(voidNone)), 'Never'); + _check(parseType('FutureOr'), 'Never'); + _check(parseType('FutureOr'), 'Never'); + _check(parseType('FutureOr'), 'Never'); + _check(parseType('FutureOr>'), 'Never'); _check( - functionTypeNone( - returnType: intNone, - formalParameters: [ - requiredParameter( - type: functionTypeNone( - returnType: intNone, - formalParameters: [requiredParameter(type: objectQuestion)], - ), - ), - ], - ), + parseType('int Function(int Function(Object?))'), 'int Function(int Function(Never))', typeStr: 'int Function(int Function(Object?))', ); - _check(intNone, 'int'); - _check(intQuestion, 'int?'); + _check(parseType('int'), 'int'); + _check(parseType('int?'), 'int?'); - _check(listNone(intNone), 'List'); - _check(listNone(intQuestion), 'List'); - _check(listQuestion(intNone), 'List?'); - _check(listQuestion(intQuestion), 'List?'); + _check(parseType('List'), 'List'); + _check(parseType('List'), 'List'); + _check(parseType('List?'), 'List?'); + _check(parseType('List?'), 'List?'); } test_notContravariant_invariant() { @@ -88,7 +67,7 @@ class ReplaceTopBottomTest extends AbstractTypeSystemTest { var F = typeAliasElement('F'); var F_dynamic = F.instantiateImpl( - typeArguments: [dynamicType], + typeArguments: [parseType('dynamic')], nullabilitySuffix: NullabilitySuffix.none, ); _check(F_dynamic, 'Never Function(Never)'); diff --git a/pkg/analyzer/test/src/dart/element/resolve_to_bound_test.dart b/pkg/analyzer/test/src/dart/element/resolve_to_bound_test.dart index 77cf09eab0b..af300779618 100644 --- a/pkg/analyzer/test/src/dart/element/resolve_to_bound_test.dart +++ b/pkg/analyzer/test/src/dart/element/resolve_to_bound_test.dart @@ -18,105 +18,94 @@ main() { @reflectiveTest class ResolveToBoundTest extends AbstractTypeSystemTest { test_dynamic() { - _check(dynamicType, 'dynamic'); + _check(parseType('dynamic'), 'dynamic'); } test_functionType() { - _check(functionTypeNone(returnType: voidNone), 'void Function()'); + _check(parseType('void Function()'), 'void Function()'); } test_interfaceType() { - _check(intNone, 'int'); - _check(intQuestion, 'int?'); + _check(parseType('int'), 'int'); + _check(parseType('int?'), 'int?'); } test_typeParameter_bound() { - _check(typeParameterTypeNone(typeParameter('T', bound: intNone)), 'int'); + withTypeParameterScope('T extends int', (scope) { + _check(scope.parseType('T'), 'int'); + }); - _check( - typeParameterTypeNone(typeParameter('T', bound: intQuestion)), - 'int?', - ); + withTypeParameterScope('T extends int?', (scope) { + _check(scope.parseType('T'), 'int?'); + }); } test_typeParameter_bound_functionType() { - _check( - typeParameterTypeNone( - typeParameter('T', bound: functionTypeNone(returnType: voidNone)), - ), - 'void Function()', - ); + withTypeParameterScope('T extends void Function()', (scope) { + _check(scope.parseType('T'), 'void Function()'); + }); } test_typeParameter_bound_nested_noBound() { - var T = typeParameter('T'); - var U = typeParameter('U', bound: typeParameterTypeNone(T)); - _check(typeParameterTypeNone(U), 'Object?'); + withTypeParameterScope('T, U extends T', (scope) { + _check(scope.parseType('U'), 'Object?'); + }); } test_typeParameter_bound_nested_none() { - var T = typeParameter('T', bound: intNone); - var U = typeParameter('U', bound: typeParameterTypeNone(T)); - _check(typeParameterTypeNone(U), 'int'); + withTypeParameterScope('T extends int, U extends T', (scope) { + _check(scope.parseType('U'), 'int'); + }); } test_typeParameter_bound_nested_none_outerNullable() { - var T = typeParameter('T', bound: intNone); - var U = typeParameter('U', bound: typeParameterTypeQuestion(T)); - _check(typeParameterTypeNone(U), 'int?'); + withTypeParameterScope('T extends int, U extends T?', (scope) { + _check(scope.parseType('U'), 'int?'); + }); } test_typeParameter_bound_nested_question() { - var T = typeParameter('T', bound: intQuestion); - var U = typeParameter('U', bound: typeParameterTypeNone(T)); - _check(typeParameterTypeNone(U), 'int?'); + withTypeParameterScope('T extends int?, U extends T', (scope) { + _check(scope.parseType('U'), 'int?'); + }); } test_typeParameter_bound_nullableInner() { - _check( - typeParameterTypeNone(typeParameter('T', bound: intQuestion)), - 'int?', - ); + withTypeParameterScope('T extends int?', (scope) { + _check(scope.parseType('T'), 'int?'); + }); } test_typeParameter_bound_nullableInnerOuter() { - _check( - typeParameterTypeQuestion(typeParameter('T', bound: intQuestion)), - 'int?', - ); + withTypeParameterScope('T extends int?', (scope) { + _check(scope.parseType('T?'), 'int?'); + }); } test_typeParameter_bound_nullableOuter() { - _check( - typeParameterTypeQuestion(typeParameter('T', bound: intNone)), - 'int?', - ); + withTypeParameterScope('T extends int', (scope) { + _check(scope.parseType('T?'), 'int?'); + }); } test_typeParameter_noBound() { - _check(typeParameterTypeNone(typeParameter('T')), 'Object?'); + withTypeParameterScope('T', (scope) { + _check(scope.parseType('T'), 'Object?'); + }); } test_typeParameter_promotedBound() { - _check( - typeParameterTypeNone( - typeParameter('T', bound: numNone), - promotedBound: intNone, - ), - 'int', - ); + withTypeParameterScope('T extends num', (scope) { + _check(scope.parseType('T & int'), 'int'); + }); - _check( - typeParameterTypeNone( - typeParameter('T', bound: numQuestion), - promotedBound: intQuestion, - ), - 'int?', - ); + withTypeParameterScope('T extends num?', (scope) { + _check(scope.parseType('T & int?'), 'int?'); + }); } test_void() { - _check(voidNone, 'void'); + _check(parseType('void'), 'void'); } void _check(TypeImpl type, String expectedStr) { diff --git a/pkg/analyzer/test/src/dart/element/runtime_type_equality_test.dart b/pkg/analyzer/test/src/dart/element/runtime_type_equality_test.dart index ea5480020ea..9c74a050dd6 100644 --- a/pkg/analyzer/test/src/dart/element/runtime_type_equality_test.dart +++ b/pkg/analyzer/test/src/dart/element/runtime_type_equality_test.dart @@ -2,7 +2,7 @@ // 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:analyzer/src/dart/element/element.dart'; +import 'package:analyzer/dart/element/nullability_suffix.dart'; import 'package:analyzer/src/dart/element/type.dart'; import 'package:test/test.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; @@ -26,225 +26,168 @@ class RuntimeTypeEqualityTypeTest extends AbstractTypeSystemTest } test_dynamic() { - _equal(dynamicType, dynamicType); - _notEqual(dynamicType, voidNone); - _notEqual(dynamicType, intNone); + _equal(parseType('dynamic'), parseType('dynamic')); + _notEqual(parseType('dynamic'), parseType('void')); + _notEqual(parseType('dynamic'), parseType('int')); - _notEqual(dynamicType, neverNone); - _notEqual(dynamicType, neverQuestion); + _notEqual(parseType('dynamic'), parseType('Never')); + _notEqual(parseType('dynamic'), parseType('Never?')); } test_functionType_parameters() { - void check( - FormalParameterElementImpl T1_parameter, - FormalParameterElementImpl T2_parameter, - bool expected, - ) { - var T1 = functionTypeNone( - returnType: voidNone, - formalParameters: [T1_parameter], - ); - var T2 = functionTypeNone( - returnType: voidNone, - formalParameters: [T2_parameter], - ); - _check(T1, T2, expected); + void check(String T1, String T2, bool expected) { + _check(parseFunctionType(T1), parseFunctionType(T2), expected); } { - void checkRequiredParameter( - TypeImpl T1_type, - TypeImpl T2_type, - bool expected, - ) { - check( - requiredParameter(type: T1_type), - requiredParameter(type: T2_type), - expected, - ); + void checkRequiredParameter(String T1, String T2, bool expected) { + check('void Function($T1)', 'void Function($T2)', expected); } - checkRequiredParameter(intNone, intNone, true); - checkRequiredParameter(intNone, intQuestion, false); + checkRequiredParameter('int', 'int', true); + checkRequiredParameter('int', 'int?', false); - checkRequiredParameter(intQuestion, intNone, false); - checkRequiredParameter(intQuestion, intQuestion, true); + checkRequiredParameter('int?', 'int', false); + checkRequiredParameter('int?', 'int?', true); - check( - requiredParameter(type: intNone, name: 'a'), - requiredParameter(type: intNone, name: 'b'), - true, - ); + check('void Function(int a)', 'void Function(int b)', true); - check( - requiredParameter(type: intNone), - positionalParameter(type: intNone), - false, - ); + check('void Function(int)', 'void Function([int])', false); - check( - requiredParameter(type: intNone), - namedParameter(type: intNone, name: 'a'), - false, - ); + check('void Function(int)', 'void Function({int a})', false); - check( - requiredParameter(type: intNone), - namedRequiredParameter(type: intNone, name: 'a'), - false, - ); + check('void Function(int)', 'void Function({required int a})', false); + } + + { + check('void Function({int a})', 'void Function({int a})', true); + + check('void Function({int a})', 'void Function({bool a})', false); + + check('void Function({int a})', 'void Function({int b})', false); + + check('void Function({int a})', 'void Function({required int a})', false); } { check( - namedParameter(type: intNone, name: 'a'), - namedParameter(type: intNone, name: 'a'), + 'void Function({required int a})', + 'void Function({required int a})', true, ); check( - namedParameter(type: intNone, name: 'a'), - namedParameter(type: boolNone, name: 'a'), + 'void Function({required int a})', + 'void Function({required bool a})', false, ); check( - namedParameter(type: intNone, name: 'a'), - namedParameter(type: intNone, name: 'b'), + 'void Function({required int a})', + 'void Function({required int b})', false, ); - check( - namedParameter(type: intNone, name: 'a'), - namedRequiredParameter(type: intNone, name: 'a'), - false, - ); - } - - { - check( - namedRequiredParameter(type: intNone, name: 'a'), - namedRequiredParameter(type: intNone, name: 'a'), - true, - ); - - check( - namedRequiredParameter(type: intNone, name: 'a'), - namedRequiredParameter(type: boolNone, name: 'a'), - false, - ); - - check( - namedRequiredParameter(type: intNone, name: 'a'), - namedRequiredParameter(type: intNone, name: 'b'), - false, - ); - - check( - namedRequiredParameter(type: intNone, name: 'a'), - namedParameter(type: intNone, name: 'a'), - false, - ); + check('void Function({required int a})', 'void Function({int a})', false); } } test_functionType_returnType() { - void check(TypeImpl T1_returnType, TypeImpl T2_returnType, bool expected) { - var T1 = functionTypeNone(returnType: T1_returnType); - var T2 = functionTypeNone(returnType: T2_returnType); - _check(T1, T2, expected); + void check(String T1, String T2, bool expected) { + _check(parseFunctionType(T1), parseFunctionType(T2), expected); } - check(intNone, intNone, true); - check(intNone, intQuestion, false); + check('int Function()', 'int Function()', true); + check('int Function()', 'int? Function()', false); } test_functionType_typeParameters() { { - var T1_T = typeParameter('T', bound: numNone); _check( - functionTypeNone(typeParameters: [T1_T], returnType: voidNone), - functionTypeNone(returnType: voidNone), + parseType('void Function()'), + parseType('void Function()'), false, ); } { - var T1_T = typeParameter('T', bound: numNone); - var T2_U = typeParameter('U'); _check( - functionTypeNone(typeParameters: [T1_T], returnType: voidNone), - functionTypeNone(typeParameters: [T2_U], returnType: voidNone), + parseType('void Function()'), + parseType('void Function()'), false, ); } { - var T1_T = typeParameter('T'); - var T2_U = typeParameter('U'); _check( - functionTypeNone( - typeParameters: [T1_T], - returnType: typeParameterTypeNone(T1_T), - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T1_T)), - ], - ), - functionTypeNone( - typeParameters: [T2_U], - returnType: typeParameterTypeNone(T2_U), - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(T2_U)), - ], - ), + parseType('T Function(T)'), + parseType('U Function(U)'), true, ); } } test_interfaceType() { - _notEqual(intNone, boolNone); + _notEqual(parseType('int'), parseType('bool')); - _equal(intNone, intNone); - _notEqual(intNone, intQuestion); + _equal(parseType('int'), parseType('int')); + _notEqual(parseType('int'), parseType('int?')); - _notEqual(intQuestion, intNone); - _equal(intQuestion, intQuestion); + _notEqual(parseType('int?'), parseType('int')); + _equal(parseType('int?'), parseType('int?')); } test_interfaceType_typeArguments() { void equal(TypeImpl T1, TypeImpl T2) { - _equal(listNone(T1), listNone(T2)); + _equal( + typeProvider.listElement.instantiateImpl( + typeArguments: [T1], + nullabilitySuffix: NullabilitySuffix.none, + ), + typeProvider.listElement.instantiateImpl( + typeArguments: [T2], + nullabilitySuffix: NullabilitySuffix.none, + ), + ); } void notEqual(TypeImpl T1, TypeImpl T2) { - _notEqual(listNone(T1), listNone(T2)); + _notEqual( + typeProvider.listElement.instantiateImpl( + typeArguments: [T1], + nullabilitySuffix: NullabilitySuffix.none, + ), + typeProvider.listElement.instantiateImpl( + typeArguments: [T2], + nullabilitySuffix: NullabilitySuffix.none, + ), + ); } - notEqual(intNone, boolNone); + notEqual(parseType('int'), parseType('bool')); - equal(intNone, intNone); - notEqual(intNone, intQuestion); + equal(parseType('int'), parseType('int')); + notEqual(parseType('int'), parseType('int?')); - notEqual(intQuestion, intNone); - equal(intQuestion, intQuestion); + notEqual(parseType('int?'), parseType('int')); + equal(parseType('int?'), parseType('int?')); } test_never() { - _equal(neverNone, neverNone); - _notEqual(neverNone, neverQuestion); - _notEqual(neverNone, intNone); + _equal(parseType('Never'), parseType('Never')); + _notEqual(parseType('Never'), parseType('Never?')); + _notEqual(parseType('Never'), parseType('int')); - _notEqual(neverQuestion, neverNone); - _equal(neverQuestion, neverQuestion); - _notEqual(neverQuestion, intNone); - _equal(neverQuestion, nullNone); + _notEqual(parseType('Never?'), parseType('Never')); + _equal(parseType('Never?'), parseType('Never?')); + _notEqual(parseType('Never?'), parseType('int')); + _equal(parseType('Never?'), parseType('Null')); } test_norm() { - _equal(futureOrNone(objectNone), objectNone); - _equal(futureOrNone(neverNone), futureNone(neverNone)); - _equal(neverQuestion, nullNone); + _equal(parseType('FutureOr'), parseType('Object')); + _equal(parseType('FutureOr'), parseType('Future')); + _equal(parseType('Never?'), parseType('Null')); } test_recordType_andNot() { @@ -275,12 +218,12 @@ class RuntimeTypeEqualityTypeTest extends AbstractTypeSystemTest } test_void() { - _equal(voidNone, voidNone); - _notEqual(voidNone, dynamicType); - _notEqual(voidNone, intNone); + _equal(parseType('void'), parseType('void')); + _notEqual(parseType('void'), parseType('dynamic')); + _notEqual(parseType('void'), parseType('int')); - _notEqual(voidNone, neverNone); - _notEqual(voidNone, neverQuestion); + _notEqual(parseType('void'), parseType('Never')); + _notEqual(parseType('void'), parseType('Never?')); } void _check(TypeImpl T1, TypeImpl T2, bool expected) { diff --git a/pkg/analyzer/test/src/dart/element/string_types.dart b/pkg/analyzer/test/src/dart/element/string_types.dart index be046c8d830..5800804875b 100644 --- a/pkg/analyzer/test/src/dart/element/string_types.dart +++ b/pkg/analyzer/test/src/dart/element/string_types.dart @@ -22,62 +22,20 @@ mixin StringTypes on AbstractTypeSystemTest { } void defineStringTypes() { - _defineType('dynamic', dynamicType); - _defineType('InvalidType', invalidType); - _defineType('void', voidNone); - - _defineType('Never', neverNone); - _defineType('Never?', neverQuestion); - - _defineType('Null', nullNone); - - _defineType('Object', objectNone); - _defineType('Object?', objectQuestion); - - _defineType('Comparable', comparableNone(objectNone)); - _defineType('Comparable', comparableNone(numNone)); - _defineType('Comparable', comparableNone(intNone)); - - _defineType('num', numNone); - _defineType('num?', numQuestion); - - _defineType('int', intNone); - _defineType('int?', intQuestion); - - _defineType('double', doubleNone); - _defineType('double?', doubleQuestion); - - _defineType('List', listNone(objectNone)); - _defineType('List', listNone(numNone)); - _defineType('List', listNone(intNone)); - _defineType('List?', listQuestion(intNone)); - _defineType('List', listNone(intQuestion)); - - _defineType( - 'List>', - listNone(comparableNone(objectNone)), - ); - _defineType('List>', listNone(comparableNone(numNone))); - _defineType( - 'List>>', - listNone(comparableNone(comparableNone(numNone))), - ); - - _defineType('Iterable', iterableNone(objectNone)); - _defineType('Iterable', iterableNone(numNone)); - _defineType('Iterable', iterableNone(intNone)); - - _defineFunctionTypes(); - _defineFutureTypes(); - _defineRecordTypes(); + _types.clear(); } TypeImpl typeOfString(String str) { - var type = _types[str]; - if (type == null) { - fail('No TypeImpl for: $str'); - } - return type; + return _types.putIfAbsent(str, () { + var type = parseType(str); + + var typeStr = typeString(type); + if (typeStr != str) { + fail('Expected: $str\nActual: $typeStr'); + } + + return type; + }); } String typesString(List types) { @@ -89,309 +47,6 @@ mixin StringTypes on AbstractTypeSystemTest { return type.getDisplayString() + _typeParametersStr(type); } - void _defineFunctionTypes() { - _defineType('Function', functionNone); - _defineType('Function?', functionQuestion); - - _defineType('void Function()', functionTypeNone(returnType: voidNone)); - - _defineType('int Function()', functionTypeNone(returnType: intNone)); - _defineType('int Function()?', functionTypeQuestion(returnType: intNone)); - - _defineType( - 'num Function(num)', - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - ); - _defineType( - 'num Function(num)?', - functionTypeQuestion( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - ); - - _defineType( - 'num Function(int)', - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: numNone, - ), - ); - _defineType( - 'num Function(int)?', - functionTypeQuestion( - formalParameters: [requiredParameter(type: intNone)], - returnType: numNone, - ), - ); - - _defineType( - 'int Function(num)', - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intNone, - ), - ); - _defineType( - 'int Function(int)', - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - ); - - _defineType( - 'num Function(num?)', - functionTypeNone( - formalParameters: [requiredParameter(type: numQuestion)], - returnType: numNone, - ), - ); - _defineType( - 'num? Function(num)', - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numQuestion, - ), - ); - _defineType( - 'num? Function(num?)', - functionTypeNone( - formalParameters: [requiredParameter(type: numQuestion)], - returnType: numQuestion, - ), - ); - - _defineType( - 'num Function({num x})', - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numNone)], - returnType: numNone, - ), - ); - _defineType( - 'num Function({num? x})', - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numQuestion)], - returnType: numNone, - ), - ); - _defineType( - 'num? Function({num x})', - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numNone)], - returnType: numQuestion, - ), - ); - _defineType( - 'num? Function({num? x})', - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numQuestion)], - returnType: numQuestion, - ), - ); - - _defineType( - 'num Function([num])', - functionTypeNone( - formalParameters: [positionalParameter(type: numNone)], - returnType: numNone, - ), - ); - _defineType( - 'num Function([num?])', - functionTypeNone( - formalParameters: [positionalParameter(type: numQuestion)], - returnType: numNone, - ), - ); - _defineType( - 'num? Function([num])', - functionTypeNone( - formalParameters: [positionalParameter(type: numNone)], - returnType: numQuestion, - ), - ); - _defineType( - 'num? Function([num?])', - functionTypeNone( - formalParameters: [positionalParameter(type: numQuestion)], - returnType: numQuestion, - ), - ); - } - - void _defineFutureTypes() { - _defineType('FutureOr', futureOrNone(objectNone)); - _defineType('FutureOr?', futureOrQuestion(objectNone)); - _defineType('FutureOr', futureOrNone(objectQuestion)); - _defineType('FutureOr?', futureOrQuestion(objectQuestion)); - - _defineType('FutureOr', futureOrNone(numNone)); - _defineType('FutureOr', futureOrNone(numQuestion)); - _defineType('FutureOr?', futureOrQuestion(numNone)); - _defineType('FutureOr?', futureOrQuestion(numQuestion)); - - _defineType('Future', futureNone(numNone)); - _defineType('Future?', futureQuestion(numNone)); - _defineType('Future', futureNone(numQuestion)); - _defineType('Future?', futureQuestion(numQuestion)); - - _defineType('FutureOr', futureOrNone(intNone)); - _defineType('FutureOr?', futureOrQuestion(intNone)); - _defineType('FutureOr', futureOrNone(intQuestion)); - _defineType('FutureOr?', futureOrQuestion(intQuestion)); - - _defineType('Future', futureNone(intNone)); - _defineType('Future?', futureQuestion(intNone)); - _defineType('Future', futureNone(intQuestion)); - _defineType('Future?', futureQuestion(intQuestion)); - - _defineType('Future', futureNone(objectNone)); - _defineType( - 'FutureOr>', - futureOrNone(futureNone(objectNone)), - ); - _defineType( - 'FutureOr>?', - futureOrQuestion(futureNone(objectNone)), - ); - _defineType( - 'FutureOr?>', - futureOrNone(futureQuestion(objectNone)), - ); - _defineType( - 'FutureOr?>?', - futureOrQuestion(futureQuestion(objectNone)), - ); - - _defineType('Future>?', futureQuestion(futureNone(numNone))); - _defineType( - 'Future?>?', - futureQuestion(futureQuestion(numQuestion)), - ); - - _defineType( - 'Future>>?', - futureQuestion(futureNone(futureNone(numNone))), - ); - _defineType( - 'Future?>?>?', - futureQuestion(futureQuestion(futureQuestion(numQuestion))), - ); - - _defineType( - 'FutureOr>?>', - futureOrNone(futureOrQuestion(futureOrNone(numNone))), - ); - _defineType( - 'FutureOr>>', - futureOrNone(futureOrNone(futureOrNone(numQuestion))), - ); - } - - void _defineRecordTypes() { - _defineType('Record', recordNone); - - void mixed( - String str, - List positionalTypes, - Map namedTypes, - ) { - var type = recordTypeNone( - positionalTypes: positionalTypes, - namedTypes: namedTypes, - ); - _defineType(str, type); - } - - void allPositional(String str, List types) { - mixed(str, types, const {}); - } - - void allPositionalQuestion(String str, List types) { - var type = recordTypeQuestion(positionalTypes: types); - _defineType(str, type); - } - - allPositional('(double,)', [doubleNone]); - allPositional('(int,)', [intNone]); - allPositional('(int?,)', [intQuestion]); - allPositional('(num,)', [numNone]); - allPositional('(Never,)', [neverNone]); - - allPositionalQuestion('(int,)?', [intNone]); - allPositionalQuestion('(int?,)?', [intQuestion]); - - allPositional('(double, int)', [doubleNone, intNone]); - allPositional('(int, double)', [intNone, doubleNone]); - allPositional('(int, int)', [intNone, intNone]); - allPositional('(int, Object)', [intNone, objectNone]); - allPositional('(int, String)', [intNone, stringNone]); - allPositional('(num, num)', [numNone, numNone]); - allPositional('(num, Object)', [numNone, objectNone]); - allPositional('(num, String)', [numNone, stringNone]); - allPositional('(Never, Never)', [neverNone, neverNone]); - - void allNamed(String str, Map types) { - mixed(str, const [], types); - } - - void allNamedQuestion(String str, Map types) { - var type = recordTypeQuestion(namedTypes: types); - _defineType(str, type); - } - - allNamed('({double f1})', {'f1': doubleNone}); - allNamed('({int f1})', {'f1': intNone}); - allNamed('({int? f1})', {'f1': intQuestion}); - allNamed('({num f1})', {'f1': numNone}); - allNamed('({int f2})', {'f2': intNone}); - allNamed('({Never f1})', {'f1': neverNone}); - allNamed(r'({int $1})', {r'$1': intNone}); - - allNamedQuestion('({int f1})?', {'f1': intNone}); - allNamedQuestion('({int? f1})?', {'f1': intQuestion}); - - allNamed('({double f1, int f2})', {'f1': doubleNone, 'f2': intNone}); - allNamed('({int f1, double f2})', {'f1': intNone, 'f2': doubleNone}); - allNamed('({int f1, int f2})', {'f1': intNone, 'f2': intNone}); - allNamed('({int f1, Object f2})', {'f1': intNone, 'f2': objectNone}); - allNamed('({int f1, String f2})', {'f1': intNone, 'f2': stringNone}); - allNamed('({num f1, num f2})', {'f1': numNone, 'f2': numNone}); - allNamed('({num f1, Object f2})', {'f1': numNone, 'f2': objectNone}); - allNamed('({num f1, String f2})', {'f1': numNone, 'f2': stringNone}); - allNamed('({Never f1, Never f2})', {'f1': neverNone, 'f2': neverNone}); - - mixed('(int, {Object f2})', [intNone], {'f2': objectNone}); - mixed('(int, {String f2})', [intNone], {'f2': stringNone}); - } - - void _defineType(String str, TypeImpl type) { - if (typeString(type) != str) { - fail('Expected: $str\nActual: ${typeString(type)}'); - } - - for (var entry in _types.entries) { - var key = entry.key; - if (key == 'Never' || typeString(type) == 'Never') { - // We have aliases for Never. - } else { - var value = entry.value; - if (key == str) { - fail('Duplicate type: $str; existing: $value; new: $type'); - } - if (typeString(value) == typeString(type)) { - fail('Duplicate type: $str'); - } - } - } - _types[str] = type; - } - String _typeParametersStr(TypeImpl type) { var typeStr = ''; diff --git a/pkg/analyzer/test/src/dart/element/subtype_test.dart b/pkg/analyzer/test/src/dart/element/subtype_test.dart index 261bf9df917..b7338847009 100644 --- a/pkg/analyzer/test/src/dart/element/subtype_test.dart +++ b/pkg/analyzer/test/src/dart/element/subtype_test.dart @@ -3,7 +3,6 @@ // BSD-style license that can be found in the LICENSE file. import 'package:analyzer/dart/element/nullability_suffix.dart'; -import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/type.dart'; import 'package:analyzer/src/test_utilities/test_library_builder.dart'; import 'package:test/test.dart'; @@ -28,9 +27,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } void isNotSubtype2(String strT0, String strT1) { - var T0 = typeOfString(strT0); - var T1 = typeOfString(strT1); - expect(typeSystem.isSubtypeOf(T0, T1), isFalse); + isNotSubtype( + _parseTestType(strT0), + _parseTestType(strT1), + strT0: strT0, + strT1: strT1, + ); } void isNotSubtype3({required String strT0, required String strT1}) { @@ -44,9 +46,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } void isSubtype2(String strT0, String strT1) { - var T0 = typeOfString(strT0); - var T1 = typeOfString(strT1); - expect(typeSystem.isSubtypeOf(T0, T1), isTrue); + isSubtype( + _parseTestType(strT0), + _parseTestType(strT1), + strT0: strT0, + strT1: strT1, + ); } @override @@ -61,26 +66,24 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { ExtensionTypeSpec('extension type A(int it) implements int'), ], ); - var element = extensionTypeElement('A'); - var type = interfaceTypeNone(element); + var type = parseInterfaceType('A'); - isSubtype(type, objectQuestion); - isSubtype(type, objectNone); - isSubtype(type, intNone); - isSubtype(type, numNone); - isSubtype(neverNone, type); + isSubtype(type, parseType('Object?')); + isSubtype(type, parseType('Object')); + isSubtype(type, parseType('int')); + isSubtype(type, parseType('num')); + isSubtype(parseType('Never'), type); } test_extensionType_noImplementedInterfaces() { buildTestLibrary( extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], ); - var element = extensionTypeElement('A'); - var type = interfaceTypeNone(element); + var type = parseInterfaceType('A'); - isSubtype(type, objectQuestion); - isNotSubtype(type, objectNone); - isNotSubtype(type, intNone); + isSubtype(type, parseType('Object?')); + isNotSubtype(type, parseType('Object')); + isNotSubtype(type, parseType('int')); } test_extensionType_superinterfaces() { @@ -90,26 +93,19 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { ExtensionTypeSpec('extension type X(int it) implements A'), ], ); - var A = classElement('A'); - var B = classElement('B'); - var element = extensionTypeElement('X'); - var type = interfaceTypeNone(element); + var type = parseInterfaceType('X'); - isSubtype(type, interfaceTypeNone(A)); - isNotSubtype(type, interfaceTypeNone(B)); + isSubtype(type, parseInterfaceType('A')); + isNotSubtype(type, parseInterfaceType('B')); } test_extensionType_typeArguments() { buildTestLibrary( extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], ); - var A = extensionTypeElement('A'); - - var A_object = interfaceTypeNone(A, typeArguments: [objectNone]); - - var A_int = interfaceTypeNone(A, typeArguments: [intNone]); - - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); + var A_object = parseInterfaceType('A'); + var A_int = parseInterfaceType('A'); + var A_num = parseInterfaceType('A'); isSubtype(A_int, A_num); isSubtype(A_int, A_object); @@ -117,1957 +113,675 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } test_functionType_01() { - var E0 = typeParameter('E0'); - var E1 = typeParameter('E1', bound: numNone); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: numNone), - ], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function(E0, num)', - strT1: 'E1 Function(E1, E1)', + isNotSubtype2( + 'E0 Function(E0, num)', + 'E1 Function(E1, E1)', ); } test_functionType_02() { - var E0 = typeParameter('E0', bound: numNone); - var E1 = typeParameter('E1', bound: intNone); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: intNone, - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: intNone, - ), - strT0: 'int Function(E0)', - strT1: 'int Function(E1)', + isNotSubtype2( + 'int Function(E0)', + 'int Function(E1)', ); } test_functionType_03() { - var E0 = typeParameter('E0', bound: numNone); - var E1 = typeParameter('E1', bound: intNone); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function(E0)', - strT1: 'E1 Function(E1)', + isNotSubtype2( + 'E0 Function(E0)', + 'E1 Function(E1)', ); } test_functionType_04() { - var E0 = typeParameter('E0', bound: numNone); - var E1 = typeParameter('E1', bound: intNone); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: intNone)], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: intNone)], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function(int)', - strT1: 'E1 Function(int)', + isNotSubtype2( + 'E0 Function(int)', + 'E1 Function(int)', ); } test_functionType_05() { - var E0 = typeParameter('E0', bound: numNone); - var E1 = typeParameter('E1', bound: numNone); - - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: numNone, - ), - strT0: 'E0 Function(E0)', - strT1: 'num Function(E1)', + isSubtype2( + 'E0 Function(E0)', + 'num Function(E1)', ); } test_functionType_06() { - var E0 = typeParameter('E0', bound: intNone); - var E1 = typeParameter('E1', bound: intNone); - - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: numNone, - ), - strT0: 'E0 Function(E0)', - strT1: 'num Function(E1)', + isSubtype2( + 'E0 Function(E0)', + 'num Function(E1)', ); } test_functionType_07() { - var E0 = typeParameter('E0', bound: intNone); - var E1 = typeParameter('E1', bound: intNone); - - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: intNone, - ), - strT0: 'E0 Function(E0)', - strT1: 'int Function(E1)', + isSubtype2( + 'E0 Function(E0)', + 'int Function(E1)', ); } test_functionType_08() { - var E0 = typeParameter('E0'); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'int Function(int)', - strT1: 'int Function(int)', - ); + isNotSubtype2('int Function(int)', 'int Function(int)'); } test_functionType_09() { - var E0 = typeParameter('E0'); - var F0 = typeParameter('F0'); - var E1 = typeParameter('E1'); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0, F0], - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'int Function(int)', - strT1: 'int Function(int)', - ); + isNotSubtype2('int Function(int)', 'int Function(int)'); } test_functionType_10() { - var E0 = typeParameter('E0'); - E0.bound = listNone(typeParameterTypeNone(E0)); - - var E1 = typeParameter('E1'); - E1.bound = listNone(typeParameterTypeNone(E1)); - - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function>(E0)', - strT1: 'E1 Function>(E1)', + isSubtype2( + 'E0 Function>(E0)', + 'E1 Function>(E1)', ); } test_functionType_11() { - var E0 = typeParameter('E0'); - E0.bound = iterableNone(typeParameterTypeNone(E0)); - - var E1 = typeParameter('E1'); - E1.bound = listNone(typeParameterTypeNone(E1)); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function>(E0)', - strT1: 'E1 Function>(E1)', + isNotSubtype2( + 'E0 Function>(E0)', + 'E1 Function>(E1)', ); } test_functionType_12() { - var E0 = typeParameter('E0'); - - var E1 = typeParameter('E1'); - E1.bound = listNone(typeParameterTypeNone(E1)); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: listNone(objectNone)), - ], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function(E0, List)', - strT1: 'E1 Function>(E1, E1)', + isNotSubtype2( + 'E0 Function(E0, List)', + 'E1 Function>(E1, E1)', ); } test_functionType_13() { - var E0 = typeParameter('E0'); - - var E1 = typeParameter('E1'); - E1.bound = listNone(typeParameterTypeNone(E1)); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: listNone(objectNone)), - ], - returnType: listNone(typeParameterTypeNone(E0)), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'List Function(E0, List)', - strT1: 'E1 Function>(E1, E1)', + isNotSubtype2( + 'List Function(E0, List)', + 'E1 Function>(E1, E1)', ); } test_functionType_14() { - var E0 = typeParameter('E0'); - - var E1 = typeParameter('E1'); - E1.bound = listNone(typeParameterTypeNone(E1)); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: listNone(objectNone)), - ], - returnType: intNone, - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'int Function(E0, List)', - strT1: 'E1 Function>(E1, E1)', + isNotSubtype2( + 'int Function(E0, List)', + 'E1 Function>(E1, E1)', ); } test_functionType_15() { - var E0 = typeParameter('E0'); - - var E1 = typeParameter('E1'); - E1.bound = listNone(typeParameterTypeNone(E1)); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: listNone(objectNone)), - ], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: voidNone, - ), - strT0: 'E0 Function(E0, List)', - strT1: 'void Function>(E1, E1)', + isNotSubtype2( + 'E0 Function(E0, List)', + 'void Function>(E1, E1)', ); } test_functionType_16() { - isSubtype( - functionTypeNone(returnType: intNone), - functionNone, - strT0: 'int Function()', - strT1: 'Function', - ); + isSubtype2('int Function()', 'Function'); } test_functionType_17() { - isNotSubtype( - functionNone, - functionTypeNone(returnType: intNone), - strT0: 'Function', - strT1: 'int Function()', - ); + isNotSubtype2('Function', 'int Function()'); } test_functionType_18() { - isSubtype( - functionTypeNone(returnType: dynamicType), - functionTypeNone(returnType: dynamicType), - strT0: 'dynamic Function()', - strT1: 'dynamic Function()', - ); + isSubtype2('dynamic Function()', 'dynamic Function()'); } test_functionType_19() { - isSubtype( - functionTypeNone(returnType: dynamicType), - functionTypeNone(returnType: voidNone), - strT0: 'dynamic Function()', - strT1: 'void Function()', - ); + isSubtype2('dynamic Function()', 'void Function()'); } test_functionType_20() { - isSubtype( - functionTypeNone(returnType: voidNone), - functionTypeNone(returnType: dynamicType), - strT0: 'void Function()', - strT1: 'dynamic Function()', - ); + isSubtype2('void Function()', 'dynamic Function()'); } test_functionType_21() { - isSubtype( - functionTypeNone(returnType: intNone), - functionTypeNone(returnType: voidNone), - strT0: 'int Function()', - strT1: 'void Function()', - ); + isSubtype2('int Function()', 'void Function()'); } test_functionType_22() { - isNotSubtype( - functionTypeNone(returnType: voidNone), - functionTypeNone(returnType: intNone), - strT0: 'void Function()', - strT1: 'int Function()', - ); + isNotSubtype2('void Function()', 'int Function()'); } test_functionType_23() { - isSubtype( - functionTypeNone(returnType: voidNone), - functionTypeNone(returnType: voidNone), - strT0: 'void Function()', - strT1: 'void Function()', - ); + isSubtype2('void Function()', 'void Function()'); } test_functionType_24() { - isSubtype( - functionTypeNone(returnType: intNone), - functionTypeNone(returnType: intNone), - strT0: 'int Function()', - strT1: 'int Function()', - ); + isSubtype2('int Function()', 'int Function()'); } test_functionType_25() { - isSubtype( - functionTypeNone(returnType: intNone), - functionTypeNone(returnType: objectNone), - strT0: 'int Function()', - strT1: 'Object Function()', - ); + isSubtype2('int Function()', 'Object Function()'); } test_functionType_26() { - isNotSubtype( - functionTypeNone(returnType: intNone), - functionTypeNone(returnType: doubleNone), - strT0: 'int Function()', - strT1: 'double Function()', - ); + isNotSubtype2('int Function()', 'double Function()'); } test_functionType_27() { - isNotSubtype( - functionTypeNone(returnType: intNone), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'int Function()', - strT1: 'void Function(int)', - ); + isNotSubtype2('int Function()', 'void Function(int)'); } test_functionType_28() { - isNotSubtype( - functionTypeNone(returnType: voidNone), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'void Function()', - strT1: 'int Function(int)', - ); + isNotSubtype2('void Function()', 'int Function(int)'); } test_functionType_29() { - isNotSubtype( - functionTypeNone(returnType: voidNone), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function()', - strT1: 'void Function(int)', - ); + isNotSubtype2('void Function()', 'void Function(int)'); } test_functionType_30() { - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'int Function(int)', - strT1: 'int Function(int)', - ); + isSubtype2('int Function(int)', 'int Function(int)'); } test_functionType_31() { - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: objectNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: objectNone, - ), - strT0: 'int Function(Object)', - strT1: 'Object Function(int)', - ); + isSubtype2('int Function(Object)', 'Object Function(int)'); } test_functionType_32() { - isNotSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: doubleNone)], - returnType: intNone, - ), - strT0: 'int Function(int)', - strT1: 'int Function(double)', - ); + isNotSubtype2('int Function(int)', 'int Function(double)'); } test_functionType_33() { - isNotSubtype( - functionTypeNone(returnType: intNone), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'int Function()', - strT1: 'int Function(int)', - ); + isNotSubtype2('int Function()', 'int Function(int)'); } test_functionType_34() { - isNotSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: intNone), - ], - returnType: intNone, - ), - strT0: 'int Function(int)', - strT1: 'int Function(int, int)', - ); + isNotSubtype2('int Function(int)', 'int Function(int, int)'); } test_functionType_35() { - isNotSubtype( - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: intNone), - ], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'int Function(int, int)', - strT1: 'int Function(int)', - ); + isNotSubtype2('int Function(int, int)', 'int Function(int)'); } test_functionType_36() { - var f = functionTypeNone( - formalParameters: [ - requiredParameter(type: functionTypeNone(returnType: voidNone)), - ], - returnType: voidNone, - ); - var g = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + isNotSubtype2( + 'void Function(void Function())', + 'void Function(void Function(int))', ); - isNotSubtype( - f, - g, - strT0: 'void Function(void Function())', - strT1: 'void Function(void Function(int))', - ); - - isNotSubtype( - g, - f, - strT0: 'void Function(void Function(int))', - strT1: 'void Function(void Function())', + isNotSubtype2( + 'void Function(void Function(int))', + 'void Function(void Function())', ); } test_functionType_37() { - isSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone(returnType: voidNone), - strT0: 'void Function([int])', - strT1: 'void Function()', - ); + isSubtype2('void Function([int])', 'void Function()'); } test_functionType_38() { - isSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function([int])', - strT1: 'void Function(int)', - ); + isSubtype2('void Function([int])', 'void Function(int)'); } test_functionType_39() { - isNotSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function(int)', - strT1: 'void Function([int])', - ); + isNotSubtype2('void Function(int)', 'void Function([int])'); } test_functionType_40() { - isSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function([int])', - strT1: 'void Function([int])', - ); + isSubtype2('void Function([int])', 'void Function([int])'); } test_functionType_41() { - isSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: objectNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function([Object])', - strT1: 'void Function([int])', - ); + isSubtype2('void Function([Object])', 'void Function([int])'); } test_functionType_42() { - isNotSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [positionalParameter(type: objectNone)], - returnType: voidNone, - ), - strT0: 'void Function([int])', - strT1: 'void Function([Object])', - ); + isNotSubtype2('void Function([int])', 'void Function([Object])'); } test_functionType_43() { - isSubtype( - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function(int, [int])', - strT1: 'void Function(int)', - ); + isSubtype2('void Function(int, [int])', 'void Function(int)'); } test_functionType_44() { - isSubtype( - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function(int, [int])', - strT1: 'void Function(int, [int])', - ); + isSubtype2('void Function(int, [int])', 'void Function(int, [int])'); } test_functionType_45() { - isSubtype( - functionTypeNone( - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function([int, int])', - strT1: 'void Function(int)', - ); + isSubtype2('void Function([int, int])', 'void Function(int)'); } test_functionType_46() { - isSubtype( - functionTypeNone( - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function([int, int])', - strT1: 'void Function(int, [int])', - ); + isSubtype2('void Function([int, int])', 'void Function(int, [int])'); } test_functionType_47() { - isNotSubtype( - functionTypeNone( - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function([int, int])', - strT1: 'void Function(int, [int, int])', + isNotSubtype2( + 'void Function([int, int])', + 'void Function(int, [int, int])', ); } test_functionType_48() { - isSubtype( - functionTypeNone( - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function([int, int, int])', - strT1: 'void Function(int, [int, int])', + isSubtype2( + 'void Function([int, int, int])', + 'void Function(int, [int, int])', ); } test_functionType_49() { - isNotSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: doubleNone)], - returnType: voidNone, - ), - strT0: 'void Function([int])', - strT1: 'void Function(double)', - ); + isNotSubtype2('void Function([int])', 'void Function(double)'); } test_functionType_50() { - isNotSubtype( - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function([int])', - strT1: 'void Function([int, int])', - ); + isNotSubtype2('void Function([int])', 'void Function([int, int])'); } test_functionType_51() { - isSubtype( - functionTypeNone( - formalParameters: [ - positionalParameter(type: intNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function([int, int])', - strT1: 'void Function([int])', - ); + isSubtype2('void Function([int, int])', 'void Function([int])'); } test_functionType_52() { - isSubtype( - functionTypeNone( - formalParameters: [ - positionalParameter(type: objectNone), - positionalParameter(type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [positionalParameter(type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function([Object, int])', - strT1: 'void Function([int])', - ); + isSubtype2('void Function([Object, int])', 'void Function([int])'); } test_functionType_53() { - isSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone(returnType: voidNone), - strT0: 'void Function({int a})', - strT1: 'void Function()', - ); + isSubtype2('void Function({int a})', 'void Function()'); } test_functionType_54() { - isNotSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a})', - strT1: 'void Function(int)', - ); + isNotSubtype2('void Function({int a})', 'void Function(int)'); } test_functionType_55() { - isNotSubtype( - functionTypeNone( - formalParameters: [requiredParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function(int)', - strT1: 'void Function({int a})', - ); + isNotSubtype2('void Function(int)', 'void Function({int a})'); } test_functionType_56() { - isSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a})', - strT1: 'void Function({int a})', - ); + isSubtype2('void Function({int a})', 'void Function({int a})'); } test_functionType_57() { - isNotSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'b', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a})', - strT1: 'void Function({int b})', - ); + isNotSubtype2('void Function({int a})', 'void Function({int b})'); } test_functionType_58() { - isSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: objectNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function({Object a})', - strT1: 'void Function({int a})', - ); + isSubtype2('void Function({Object a})', 'void Function({int a})'); } test_functionType_59() { - isNotSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: objectNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a})', - strT1: 'void Function({Object a})', - ); + isNotSubtype2('void Function({int a})', 'void Function({Object a})'); } test_functionType_60() { - isSubtype( - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - namedParameter(name: 'a', type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - namedParameter(name: 'a', type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function(int, {int a})', - strT1: 'void Function(int, {int a})', - ); + isSubtype2('void Function(int, {int a})', 'void Function(int, {int a})'); } test_functionType_61() { - isNotSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: doubleNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a})', - strT1: 'void Function({double a})', - ); + isNotSubtype2('void Function({int a})', 'void Function({double a})'); } test_functionType_62() { - isNotSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function({int a})', - strT1: 'void Function({int a, int b})', - ); + isNotSubtype2('void Function({int a})', 'void Function({int a, int b})'); } test_functionType_63() { - isSubtype( - functionTypeNone( - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'a', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a, int b})', - strT1: 'void Function({int a})', - ); + isSubtype2('void Function({int a, int b})', 'void Function({int a})'); } test_functionType_64() { - isSubtype( - functionTypeNone( - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - namedParameter(name: 'c', type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'c', type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function({int a, int b, int c})', - strT1: 'void Function({int a, int c})', + isSubtype2( + 'void Function({int a, int b, int c})', + 'void Function({int a, int c})', ); } test_functionType_66() { - isSubtype( - functionTypeNone( - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - namedParameter(name: 'c', type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [ - namedParameter(name: 'b', type: intNone), - namedParameter(name: 'c', type: intNone), - ], - returnType: voidNone, - ), - strT0: 'void Function({int a, int b, int c})', - strT1: 'void Function({int b, int c})', + isSubtype2( + 'void Function({int a, int b, int c})', + 'void Function({int b, int c})', ); } test_functionType_68() { - isSubtype( - functionTypeNone( - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - namedParameter(name: 'c', type: intNone), - ], - returnType: voidNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'c', type: intNone)], - returnType: voidNone, - ), - strT0: 'void Function({int a, int b, int c})', - strT1: 'void Function({int c})', + isSubtype2( + 'void Function({int a, int b, int c})', + 'void Function({int c})', ); } test_functionType_70() { - isSubtype( - functionTypeNone( - returnType: numNone, - formalParameters: [requiredParameter(type: intNone)], - ), - objectNone, - strT0: 'num Function(int)', - strT1: 'Object', - ); + isSubtype2('num Function(int)', 'Object'); } test_functionType_71() { - isSubtype( - functionTypeNone( - returnType: numNone, - formalParameters: [requiredParameter(type: intNone)], - ), - objectNone, - strT0: 'num Function(int)', - strT1: 'Object', - ); + isSubtype2('num Function(int)', 'Object'); } test_functionType_72() { - isNotSubtype( - functionTypeQuestion( - returnType: numNone, - formalParameters: [requiredParameter(type: intNone)], - ), - objectNone, - strT0: 'num Function(int)?', - strT1: 'Object', - ); + isNotSubtype2('num Function(int)?', 'Object'); } test_functionType_73() { - var E0 = typeParameter('E0', bound: objectNone); - var E1 = typeParameter('E1', bound: futureOrNone(objectNone)); - - isSubtype( - functionTypeNone(typeParameters: [E0], returnType: voidNone), - functionTypeNone(typeParameters: [E1], returnType: voidNone), - strT0: 'void Function()', - strT1: 'void Function>()', + isSubtype2( + 'void Function()', + 'void Function>()', ); } test_functionType_74() { - var T1 = typeParameter('T'); - var R1 = typeParameter( - 'R', - bound: typeParameterType(T1, nullabilitySuffix: NullabilitySuffix.none), - ); - - var T2 = typeParameter('T'); - var R2 = typeParameter( - 'R', - bound: typeParameterType(T2, nullabilitySuffix: NullabilitySuffix.none), - ); - // Note, the order `R extends T`, then `T` is important. // We test that all type parameters replaced at once, not as we go. - isSubtype( - functionTypeNone(typeParameters: [R1, T1], returnType: voidNone), - functionTypeNone(typeParameters: [R2, T2], returnType: voidNone), - strT0: 'void Function()', - strT1: 'void Function()', + isSubtype2( + 'void Function()', + 'void Function()', ); } test_functionType_generic_nested() { - var E0 = typeParameter('E0'); - var F0 = typeParameter('F0'); - var E1 = typeParameter('E1'); - var F1 = typeParameter('F1'); - - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - ], - returnType: typeParameterTypeNone(E0), - ), - ), - functionTypeNone( - typeParameters: [F1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(F1))], - returnType: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(F1)), - ], - returnType: typeParameterTypeNone(F1), - ), - ), - strT0: 'E0 Function(E0) Function(E0)', - strT1: 'F1 Function(F1) Function(F1)', + isSubtype2( + 'E0 Function(E0) Function(E0)', + 'F1 Function(F1) Function(F1)', ); - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: typeParameterTypeNone(E0)), - ], - returnType: typeParameterTypeNone(E0), - ), - ), - ], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: numNone), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: typeParameterTypeNone(E1), - ), - ), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E0 Function(E0, E0 Function(int, E0))', - strT1: 'E1 Function(E1, E1 Function(num, E1))', + isSubtype2( + 'E0 Function(E0, E0 Function(int, E0))', + 'E1 Function(E1, E1 Function(num, E1))', ); - isNotSubtype( - functionTypeNone( - typeParameters: [E0, F0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(F0)), - ], - returnType: typeParameterTypeNone(E0), - ), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: functionTypeNone( - typeParameters: [F1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(F1)), - ], - returnType: typeParameterTypeNone(E1), - ), - ), - strT0: 'E0 Function(F0) Function(E0)', - strT1: 'E1 Function(F1) Function(E1)', + isNotSubtype2( + 'E0 Function(F0) Function(E0)', + 'E1 Function(F1) Function(E1)', ); - isNotSubtype( - functionTypeNone( - typeParameters: [E0, F0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(F0)), - ], - returnType: typeParameterTypeNone(E0), - ), - ), - functionTypeNone( - typeParameters: [F1, E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(F1)), - ], - returnType: typeParameterTypeNone(E1), - ), - ), - strT0: 'E0 Function(F0) Function(E0)', - strT1: 'E1 Function(F1) Function(E1)', + isNotSubtype2( + 'E0 Function(F0) Function(E0)', + 'E1 Function(F1) Function(E1)', ); } test_functionType_generic_required() { - var E0 = typeParameter('E'); - var E1 = typeParameter('E'); + isSubtype2('int Function(E)', 'num Function(E)'); - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E0))], - returnType: intNone, - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: typeParameterTypeNone(E1))], - returnType: numNone, - ), - strT0: 'int Function(E)', - strT1: 'num Function(E)', - ); + isSubtype2('E Function(num)', 'E Function(int)'); - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [requiredParameter(type: numNone)], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [requiredParameter(type: intNone)], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E Function(num)', - strT1: 'E Function(int)', - ); + isSubtype2('E Function(E, num)', 'E Function(E, int)'); - isSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: numNone), - ], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: intNone), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E Function(E, num)', - strT1: 'E Function(E, int)', - ); - - isNotSubtype( - functionTypeNone( - typeParameters: [E0], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E0)), - requiredParameter(type: numNone), - ], - returnType: typeParameterTypeNone(E0), - ), - functionTypeNone( - typeParameters: [E1], - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(E1)), - requiredParameter(type: typeParameterTypeNone(E1)), - ], - returnType: typeParameterTypeNone(E1), - ), - strT0: 'E Function(E, num)', - strT1: 'E Function(E, E)', - ); + isNotSubtype2('E Function(E, num)', 'E Function(E, E)'); } test_functionType_notGeneric_functionReturnType() { - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: numNone, - ), - ), - strT0: 'num Function(num) Function(num)', - strT1: 'num Function(int) Function(num)', + isSubtype2( + 'num Function(num) Function(num)', + 'num Function(int) Function(num)', ); - isNotSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - ), - strT0: 'int Function(int) Function(int)', - strT1: 'num Function(num) Function(num)', + isNotSubtype2( + 'int Function(int) Function(int)', + 'num Function(num) Function(num)', ); } test_functionType_notGeneric_named() { - isSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numNone)], - returnType: numNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: intNone)], - returnType: numNone, - ), - strT0: 'num Function({num x})', - strT1: 'num Function({int x})', - ); + isSubtype2('num Function({num x})', 'num Function({int x})'); - isSubtype( - functionTypeNone( - formalParameters: [ - requiredParameter(type: numNone), - namedParameter(name: 'x', type: numNone), - ], - returnType: numNone, - ), - functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - namedParameter(name: 'x', type: intNone), - ], - returnType: numNone, - ), - strT0: 'num Function(num, {num x})', - strT1: 'num Function(int, {int x})', - ); + isSubtype2('num Function(num, {num x})', 'num Function(int, {int x})'); - isSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numNone)], - returnType: numNone, - ), - strT0: 'int Function({num x})', - strT1: 'num Function({num x})', - ); + isSubtype2('int Function({num x})', 'num Function({num x})'); - isNotSubtype( - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: intNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [namedParameter(name: 'x', type: numNone)], - returnType: numNone, - ), - strT0: 'int Function({int x})', - strT1: 'num Function({num x})', - ); + isNotSubtype2('int Function({int x})', 'num Function({num x})'); } test_functionType_notGeneric_required() { - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: numNone, - ), - strT0: 'num Function(num)', - strT1: 'num Function(int)', - ); + isSubtype2('num Function(num)', 'num Function(int)'); - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - strT0: 'int Function(num)', - strT1: 'num Function(num)', - ); + isSubtype2('int Function(num)', 'num Function(num)'); - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: numNone, - ), - strT0: 'int Function(num)', - strT1: 'num Function(int)', - ); + isSubtype2('int Function(num)', 'num Function(int)'); - isNotSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - functionTypeNone( - formalParameters: [requiredParameter(type: numNone)], - returnType: numNone, - ), - strT0: 'int Function(int)', - strT1: 'num Function(num)', - ); + isNotSubtype2('int Function(int)', 'num Function(num)'); - isSubtype( - nullNone, - functionTypeQuestion( - formalParameters: [requiredParameter(type: intNone)], - returnType: numNone, - ), - strT0: 'Null', - strT1: 'num Function(int)?', - ); + isSubtype2('Null', 'num Function(int)?'); } test_functionType_requiredNamedParameter_01() { - var F0 = functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ); + isSubtype2('void Function({int a})', 'void Function({required int a})'); - var F1 = functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ); - - isSubtype( - F1, - F0, - strT0: 'void Function({int a})', - strT1: 'void Function({required int a})', - ); - - isNotSubtype( - F0, - F1, - strT0: 'void Function({required int a})', - strT1: 'void Function({int a})', - ); + isNotSubtype2('void Function({required int a})', 'void Function({int a})'); } test_functionType_requiredNamedParameter_02() { - isNotSubtype( - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionTypeNone(returnType: voidNone), - strT0: 'void Function({required int a})', - strT1: 'void Function()', - ); + isNotSubtype2('void Function({required int a})', 'void Function()'); - isNotSubtype( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedRequiredParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'b', type: intNone)], - ), - strT0: 'void Function({required int a, int b})', - strT1: 'void Function({int b})', + isNotSubtype2( + 'void Function({required int a, int b})', + 'void Function({int b})', ); } test_functionType_requiredNamedParameter_03() { - var F0 = functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intQuestion)], - ); + isSubtype2('void Function({int? a})', 'void Function({required int a})'); - var F1 = functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ); - - isSubtype( - F0, - F1, - strT0: 'void Function({int? a})', - strT1: 'void Function({required int a})', - ); - - isNotSubtype( - F1, - F0, - strT0: 'void Function({required int a})', - strT1: 'void Function({int? a})', - ); + isNotSubtype2('void Function({required int a})', 'void Function({int? a})'); } test_futureOr_01() { - isSubtype( - intNone, - futureOrNone(intNone), - strT0: 'int', - strT1: 'FutureOr', - ); + isSubtype2('int', 'FutureOr'); } test_futureOr_02() { - isSubtype( - intNone, - futureOrNone(numNone), - strT0: 'int', - strT1: 'FutureOr', - ); + isSubtype2('int', 'FutureOr'); } test_futureOr_03() { - isSubtype( - futureNone(intNone), - futureOrNone(intNone), - strT0: 'Future', - strT1: 'FutureOr', - ); + isSubtype2('Future', 'FutureOr'); } test_futureOr_04() { - isSubtype( - futureNone(intNone), - futureOrNone(numNone), - strT0: 'Future', - strT1: 'FutureOr', - ); + isSubtype2('Future', 'FutureOr'); } test_futureOr_05() { - isSubtype( - futureNone(intNone), - futureOrNone(objectNone), - strT0: 'Future', - strT1: 'FutureOr', - ); + isSubtype2('Future', 'FutureOr'); } test_futureOr_06() { - isSubtype( - futureOrNone(intNone), - futureOrNone(intNone), - strT0: 'FutureOr', - strT1: 'FutureOr', - ); + isSubtype2('FutureOr', 'FutureOr'); } test_futureOr_07() { - isSubtype( - futureOrNone(intNone), - futureOrNone(numNone), - strT0: 'FutureOr', - strT1: 'FutureOr', - ); + isSubtype2('FutureOr', 'FutureOr'); } test_futureOr_08() { - isSubtype( - futureOrNone(intNone), - objectNone, - strT0: 'FutureOr', - strT1: 'Object', - ); + isSubtype2('FutureOr', 'Object'); } test_futureOr_09() { - isNotSubtype( - intNone, - futureOrNone(doubleNone), - strT0: 'int', - strT1: 'FutureOr', - ); + isNotSubtype2('int', 'FutureOr'); } test_futureOr_10() { - isNotSubtype( - futureOrNone(doubleNone), - intNone, - strT0: 'FutureOr', - strT1: 'int', - ); + isNotSubtype2('FutureOr', 'int'); } test_futureOr_11() { - isNotSubtype( - futureOrNone(intNone), - futureNone(numNone), - strT0: 'FutureOr', - strT1: 'Future', - ); + isNotSubtype2('FutureOr', 'Future'); } test_futureOr_12() { - isNotSubtype( - futureOrNone(intNone), - numNone, - strT0: 'FutureOr', - strT1: 'num', - ); + isNotSubtype2('FutureOr', 'num'); } test_futureOr_13() { - isNotSubtype( - nullNone, - futureOrNone(intNone), - strT0: 'Null', - strT1: 'FutureOr', - ); + isNotSubtype2('Null', 'FutureOr'); } test_futureOr_14() { isSubtype( - nullNone, - futureQuestion(intNone), + parseType('Null'), + parseType('Future?'), strT0: 'Null', strT1: 'Future?', ); } test_futureOr_15() { - isSubtype( - dynamicType, - futureOrNone(dynamicType), - strT0: 'dynamic', - strT1: 'FutureOr', - ); + isSubtype2('dynamic', 'FutureOr'); } test_futureOr_16() { - isNotSubtype( - dynamicType, - futureOrNone(stringNone), - strT0: 'dynamic', - strT1: 'FutureOr', - ); + isNotSubtype2('dynamic', 'FutureOr'); } test_futureOr_17() { - isSubtype( - voidNone, - futureOrNone(voidNone), - strT0: 'void', - strT1: 'FutureOr', - ); + isSubtype2('void', 'FutureOr'); } test_futureOr_18() { - isNotSubtype( - voidNone, - futureOrNone(stringNone), - strT0: 'void', - strT1: 'FutureOr', - ); + isNotSubtype2('void', 'FutureOr'); } test_futureOr_19() { - var E = typeParameter('E'); - - isSubtype( - typeParameterTypeNone(E), - futureOrNone(typeParameterTypeNone(E)), - strT0: 'E', - strT1: 'FutureOr', - ); + withTypeParameterScope('E', (scope) { + isSubtype( + scope.parseType('E'), + scope.parseType('FutureOr'), + strT0: 'E', + strT1: 'FutureOr', + ); + }); } test_futureOr_20() { - var E = typeParameter('E'); - - isNotSubtype( - typeParameterTypeNone(E), - futureOrNone(stringNone), - strT0: 'E', - strT1: 'FutureOr', - ); + withTypeParameterScope('E', (scope) { + isNotSubtype( + scope.parseType('E'), + _parseTestType('FutureOr'), + strT0: 'E', + strT1: 'FutureOr', + ); + }); } test_futureOr_21() { - isSubtype( - functionTypeNone(returnType: stringNone), - futureOrNone(functionTypeNone(returnType: voidNone)), - strT0: 'String Function()', - strT1: 'FutureOr', - ); + isSubtype2('String Function()', 'FutureOr'); } test_futureOr_22() { - isNotSubtype( - functionTypeNone(returnType: voidNone), - futureOrNone(functionTypeNone(returnType: stringNone)), - strT0: 'void Function()', - strT1: 'FutureOr', - ); + isNotSubtype2('void Function()', 'FutureOr'); } test_futureOr_23() { - isNotSubtype( - futureOrNone(numNone), - futureOrNone(intNone), - strT0: 'FutureOr', - strT1: 'FutureOr', - ); + isNotSubtype2('FutureOr', 'FutureOr'); } test_futureOr_24() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrNone(numNone), - strT0: 'T & int', - strT1: 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr'), + strT0: 'T & int', + strT1: 'FutureOr', + ); + }); } test_futureOr_25() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(numNone)), - futureOrNone(numNone), - strT0: 'T & Future', - strT1: 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future', + strT1: 'FutureOr', + ); + }); } test_futureOr_26() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrNone(numNone), - strT0: 'T & Future', - strT1: 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future', + strT1: 'FutureOr', + ); + }); } test_futureOr_27() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(T, numNone), - futureOrNone(intNone), - strT0: 'T & num', - strT1: 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & num'), + _parseTestType('FutureOr'), + strT0: 'T & num', + strT1: 'FutureOr', + ); + }); } test_futureOr_28() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(T, futureNone(numNone)), - futureOrNone(intNone), - strT0: 'T & Future', - strT1: 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future', + strT1: 'FutureOr', + ); + }); } test_futureOr_29() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(T, futureOrNone(numNone)), - futureOrNone(intNone), - strT0: 'T & FutureOr', - strT1: 'FutureOr', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & FutureOr'), + _parseTestType('FutureOr'), + strT0: 'T & FutureOr', + strT1: 'FutureOr', + ); + }); } test_futureOr_30() { - isSubtype( - futureOrNone(objectNone), - futureOrNone(futureOrNone(objectNone)), - strT0: 'FutureOr', - strT1: 'FutureOr>', - ); + isSubtype2('FutureOr', 'FutureOr>'); } test_interfaceType_01() { - isSubtype(intNone, intNone, strT0: 'int', strT1: 'int'); + isSubtype(parseType('int'), parseType('int'), strT0: 'int', strT1: 'int'); } test_interfaceType_02() { - isSubtype(intNone, numNone, strT0: 'int', strT1: 'num'); + isSubtype(parseType('int'), parseType('num'), strT0: 'int', strT1: 'num'); } test_interfaceType_03() { isSubtype( - intNone, - comparableNone(numNone), + parseType('int'), + parseType('Comparable'), strT0: 'int', strT1: 'Comparable', ); } test_interfaceType_04() { - isSubtype(intNone, objectNone, strT0: 'int', strT1: 'Object'); + isSubtype( + parseType('int'), + parseType('Object'), + strT0: 'int', + strT1: 'Object', + ); } test_interfaceType_05() { - isSubtype(doubleNone, numNone, strT0: 'double', strT1: 'num'); + isSubtype( + parseType('double'), + parseType('num'), + strT0: 'double', + strT1: 'num', + ); } test_interfaceType_06() { - isNotSubtype(intNone, doubleNone, strT0: 'int', strT1: 'double'); + isNotSubtype( + parseType('int'), + parseType('double'), + strT0: 'int', + strT1: 'double', + ); } test_interfaceType_07() { isNotSubtype( - intNone, - comparableNone(intNone), + parseType('int'), + parseType('Comparable'), strT0: 'int', strT1: 'Comparable', ); @@ -2075,8 +789,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_08() { isNotSubtype( - intNone, - iterableNone(intNone), + parseType('int'), + parseType('Iterable'), strT0: 'int', strT1: 'Iterable', ); @@ -2084,8 +798,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_09() { isNotSubtype( - comparableNone(intNone), - iterableNone(intNone), + parseType('Comparable'), + parseType('Iterable'), strT0: 'Comparable', strT1: 'Iterable', ); @@ -2093,8 +807,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_10() { isSubtype( - listNone(intNone), - listNone(intNone), + _parseTestType('List'), + _parseTestType('List'), strT0: 'List', strT1: 'List', ); @@ -2102,8 +816,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_11() { isSubtype( - listNone(intNone), - iterableNone(intNone), + _parseTestType('List'), + parseType('Iterable'), strT0: 'List', strT1: 'Iterable', ); @@ -2111,8 +825,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_12() { isSubtype( - listNone(intNone), - listNone(numNone), + _parseTestType('List'), + _parseTestType('List'), strT0: 'List', strT1: 'List', ); @@ -2120,8 +834,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_13() { isSubtype( - listNone(intNone), - iterableNone(numNone), + _parseTestType('List'), + parseType('Iterable'), strT0: 'List', strT1: 'Iterable', ); @@ -2129,8 +843,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_14() { isSubtype( - listNone(intNone), - listNone(objectNone), + _parseTestType('List'), + _parseTestType('List'), strT0: 'List', strT1: 'List', ); @@ -2138,8 +852,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_15() { isSubtype( - listNone(intNone), - iterableNone(objectNone), + _parseTestType('List'), + parseType('Iterable'), strT0: 'List', strT1: 'Iterable', ); @@ -2147,8 +861,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_16() { isSubtype( - listNone(intNone), - objectNone, + _parseTestType('List'), + parseType('Object'), strT0: 'List', strT1: 'Object', ); @@ -2156,8 +870,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_17() { isSubtype( - listNone(intNone), - listNone(comparableNone(objectNone)), + _parseTestType('List'), + _parseTestType('List>'), strT0: 'List', strT1: 'List>', ); @@ -2165,8 +879,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_18() { isSubtype( - listNone(intNone), - listNone(comparableNone(numNone)), + _parseTestType('List'), + _parseTestType('List>'), strT0: 'List', strT1: 'List>', ); @@ -2174,8 +888,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_19() { isSubtype( - listNone(intNone), - listNone(comparableNone(comparableNone(numNone))), + _parseTestType('List'), + _parseTestType('List>>'), strT0: 'List', strT1: 'List>>', ); @@ -2183,8 +897,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_20() { isNotSubtype( - listNone(intNone), - listNone(doubleNone), + _parseTestType('List'), + _parseTestType('List'), strT0: 'List', strT1: 'List', ); @@ -2192,8 +906,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_21() { isNotSubtype( - listNone(intNone), - iterableNone(doubleNone), + _parseTestType('List'), + parseType('Iterable'), strT0: 'List', strT1: 'Iterable', ); @@ -2201,8 +915,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_22() { isNotSubtype( - listNone(intNone), - comparableNone(intNone), + _parseTestType('List'), + _parseTestType('Comparable'), strT0: 'List', strT1: 'Comparable', ); @@ -2210,8 +924,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_23() { isNotSubtype( - listNone(intNone), - listNone(comparableNone(intNone)), + _parseTestType('List'), + _parseTestType('List>'), strT0: 'List', strT1: 'List>', ); @@ -2219,8 +933,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { test_interfaceType_24() { isNotSubtype( - listNone(intNone), - listNone(comparableNone(comparableNone(intNone))), + _parseTestType('List'), + _parseTestType('List>>'), strT0: 'List', strT1: 'List>>', ); @@ -2267,33 +981,43 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } test_interfaceType_27() { - isSubtype(numNone, objectNone, strT0: 'num', strT1: 'Object'); + isSubtype( + parseType('num'), + parseType('Object'), + strT0: 'num', + strT1: 'Object', + ); } test_interfaceType_28() { - isSubtype(numNone, objectNone, strT0: 'num', strT1: 'Object'); + isSubtype( + parseType('num'), + parseType('Object'), + strT0: 'num', + strT1: 'Object', + ); } test_interfaceType_39() { - var T = typeParameter('T', bound: objectQuestion); - - isSubtype( - listNone(promotedTypeParameterTypeNone(T, intNone)), - listNone(typeParameterTypeNone(T)), - strT0: 'List, T extends Object?', - strT1: 'List, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + scope.parseType('List'), + scope.parseType('List'), + strT0: 'List, T extends Object?', + strT1: 'List, T extends Object?', + ); + }); } test_interfaceType_40() { - var T = typeParameter('T', bound: objectQuestion); - - isSubtype( - listNone(promotedTypeParameterTypeNone(T, intQuestion)), - listNone(typeParameterTypeNone(T)), - strT0: 'List, T extends Object?', - strT1: 'List, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + scope.parseType('List'), + scope.parseType('List'), + strT0: 'List, T extends Object?', + strT1: 'List, T extends Object?', + ); + }); } @SkippedTest() // TODO(scheglov): implement augmentation @@ -2304,12 +1028,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { // var A1 = class_( // name: 'A', // isAugmentation: true, - // interfaces: [interfaceTypeNone(I)], + // interfaces: [parseInterfaceType('I')], // ); // A.addAugmentations([A1]); // - // var A_none = interfaceTypeNone(A); - // var I_none = interfaceTypeNone(I); + // var A_none = parseInterfaceType('A'); + // var I_none = parseInterfaceType('I'); // // isSubtype(A_none, I_none, strT0: 'A', strT1: 'I'); // isNotSubtype(I_none, A_none, strT0: 'I', strT1: 'A'); @@ -2323,12 +1047,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { // var A1 = class_( // name: 'A', // isAugmentation: true, - // mixins: [interfaceTypeNone(M)], + // mixins: [parseInterfaceType('M')], // ); // A.addAugmentations([A1]); // - // var A_none = interfaceTypeNone(A); - // var M_none = interfaceTypeNone(M); + // var A_none = parseInterfaceType('A'); + // var M_none = parseInterfaceType('M'); // // isSubtype(A_none, M_none, strT0: 'A', strT1: 'M'); // isNotSubtype(M_none, A_none, strT0: 'M', strT1: 'A'); @@ -2339,12 +1063,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { var A = classElement('A'); var A_num = A.instantiateImpl( - typeArguments: [numNone], + typeArguments: [parseType('num')], nullabilitySuffix: NullabilitySuffix.none, ); var A_int = A.instantiateImpl( - typeArguments: [intNone], + typeArguments: [parseType('int')], nullabilitySuffix: NullabilitySuffix.none, ); @@ -2358,12 +1082,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { var A = classElement('A'); var A_num = A.instantiateImpl( - typeArguments: [numNone], + typeArguments: [parseType('num')], nullabilitySuffix: NullabilitySuffix.none, ); var A_int = A.instantiateImpl( - typeArguments: [intNone], + typeArguments: [parseType('int')], nullabilitySuffix: NullabilitySuffix.none, ); @@ -2377,12 +1101,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { var A = classElement('A'); var A_num = A.instantiateImpl( - typeArguments: [numNone], + typeArguments: [parseType('num')], nullabilitySuffix: NullabilitySuffix.none, ); var A_int = A.instantiateImpl( - typeArguments: [intNone], + typeArguments: [parseType('int')], nullabilitySuffix: NullabilitySuffix.none, ); @@ -2399,12 +1123,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { // var M1 = mixin_( // name: 'M1', // isAugmentation: true, - // interfaces: [interfaceTypeNone(I)], + // interfaces: [parseInterfaceType('I')], // ); // M.addAugmentations([M1]); // - // var M_none = interfaceTypeNone(M); - // var I_none = interfaceTypeNone(I); + // var M_none = parseInterfaceType('M'); + // var I_none = parseInterfaceType('I'); // // isSubtype(M_none, I_none, strT0: 'M', strT1: 'I'); // isNotSubtype(I_none, M_none, strT0: 'I', strT1: 'M'); @@ -2418,12 +1142,12 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { // var M1 = mixin_( // name: 'M1', // isAugmentation: true, - // constraints: [interfaceTypeNone(C)], + // constraints: [parseInterfaceType('C')], // ); // M.addAugmentations([M1]); // - // var M_none = interfaceTypeNone(M); - // var C_none = interfaceTypeNone(C); + // var M_none = parseInterfaceType('M'); + // var C_none = parseInterfaceType('C'); // // isSubtype(M_none, C_none, strT0: 'M', strT1: 'C'); // isNotSubtype(C_none, M_none, strT0: 'C', strT1: 'M'); @@ -2570,340 +1294,308 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } test_multi_futureOr_functionType() { - isSubtype( - functionTypeNone(returnType: stringNone), - futureOrNone(functionTypeNone(returnType: voidNone)), - strT0: 'String Function()', - strT1: 'FutureOr', - ); + isSubtype2('String Function()', 'FutureOr'); - isSubtype( - functionTypeNone(returnType: stringNone), - futureOrNone(functionTypeNone(returnType: voidNone)), - strT0: 'String Function()', - strT1: 'FutureOr', - ); + isSubtype2('String Function()', 'FutureOr'); - isSubtype( - functionTypeNone(returnType: stringNone), - futureOrNone(functionTypeQuestion(returnType: voidNone)), - strT0: 'String Function()', - strT1: 'FutureOr', - ); + isSubtype2('String Function()', 'FutureOr'); - isSubtype( - functionTypeNone(returnType: stringNone), - futureOrQuestion(functionTypeNone(returnType: voidNone)), - strT0: 'String Function()', - strT1: 'FutureOr?', - ); + isSubtype2('String Function()', 'FutureOr?'); - isSubtype( - functionTypeQuestion(returnType: stringNone), - futureOrNone(functionTypeQuestion(returnType: voidNone)), - strT0: 'String Function()?', - strT1: 'FutureOr', - ); + isSubtype2('String Function()?', 'FutureOr'); - isSubtype( - functionTypeQuestion(returnType: stringNone), - futureOrQuestion(functionTypeNone(returnType: voidNone)), - strT0: 'String Function()?', - strT1: 'FutureOr?', - ); + isSubtype2('String Function()?', 'FutureOr?'); - isNotSubtype( - functionTypeQuestion(returnType: stringNone), - futureOrNone(functionTypeNone(returnType: voidNone)), - strT0: 'String Function()?', - strT1: 'FutureOr', - ); + isNotSubtype2('String Function()?', 'FutureOr'); - isNotSubtype( - functionTypeNone(returnType: voidNone), - futureOrNone(functionTypeNone(returnType: stringNone)), - strT0: 'void Function()', - strT1: 'FutureOr', - ); + isNotSubtype2('void Function()', 'FutureOr'); } test_multi_futureOr_typeParameter() { - TypeParameterElementImpl E; + withTypeParameterScope('E extends Object', (scope) { + isSubtype( + scope.parseType('E'), + scope.parseType('FutureOr'), + strT0: 'E, E extends Object', + strT1: 'FutureOr, E extends Object', + ); + }); - E = typeParameter('E', bound: objectNone); - isSubtype( - typeParameterTypeNone(E), - futureOrNone(typeParameterTypeNone(E)), - strT0: 'E, E extends Object', - strT1: 'FutureOr, E extends Object', - ); + withTypeParameterScope('E extends Object', (scope) { + isSubtype( + scope.parseType('E?'), + scope.parseType('FutureOr?'), + strT0: 'E?, E extends Object', + strT1: 'FutureOr?, E extends Object', + ); + isSubtype( + scope.parseType('E?'), + scope.parseType('FutureOr'), + strT0: 'E?, E extends Object', + strT1: 'FutureOr, E extends Object', + ); + isNotSubtype( + scope.parseType('E?'), + scope.parseType('FutureOr'), + strT0: 'E?, E extends Object', + strT1: 'FutureOr, E extends Object', + ); + }); - E = typeParameter('E', bound: objectNone); - isSubtype( - typeParameterTypeQuestion(E), - futureOrQuestion(typeParameterTypeNone(E)), - strT0: 'E?, E extends Object', - strT1: 'FutureOr?, E extends Object', - ); - isSubtype( - typeParameterTypeQuestion(E), - futureOrNone(typeParameterTypeQuestion(E)), - strT0: 'E?, E extends Object', - strT1: 'FutureOr, E extends Object', - ); - isNotSubtype( - typeParameterTypeQuestion(E), - futureOrNone(typeParameterTypeNone(E)), - strT0: 'E?, E extends Object', - strT1: 'FutureOr, E extends Object', - ); + withTypeParameterScope('E extends Object?', (scope) { + isSubtype( + scope.parseType('E'), + scope.parseType('FutureOr?'), + strT0: 'E, E extends Object?', + strT1: 'FutureOr?, E extends Object?', + ); + isSubtype( + scope.parseType('E'), + scope.parseType('FutureOr'), + strT0: 'E, E extends Object?', + strT1: 'FutureOr, E extends Object?', + ); + isSubtype( + scope.parseType('E'), + scope.parseType('FutureOr'), + strT0: 'E, E extends Object?', + strT1: 'FutureOr, E extends Object?', + ); + }); - E = typeParameter('E', bound: objectQuestion); - isSubtype( - typeParameterTypeNone(E), - futureOrQuestion(typeParameterTypeNone(E)), - strT0: 'E, E extends Object?', - strT1: 'FutureOr?, E extends Object?', - ); - isSubtype( - typeParameterTypeNone(E), - futureOrNone(typeParameterTypeQuestion(E)), - strT0: 'E, E extends Object?', - strT1: 'FutureOr, E extends Object?', - ); - isSubtype( - typeParameterTypeNone(E), - futureOrNone(typeParameterTypeNone(E)), - strT0: 'E, E extends Object?', - strT1: 'FutureOr, E extends Object?', - ); + withTypeParameterScope('E extends Object', (scope) { + isNotSubtype( + scope.parseType('E'), + _parseTestType('FutureOr'), + strT0: 'E, E extends Object', + strT1: 'FutureOr', + ); + }); - E = typeParameter('E', bound: objectNone); - isNotSubtype( - typeParameterTypeNone(E), - futureOrNone(stringNone), - strT0: 'E, E extends Object', - strT1: 'FutureOr', - ); + withTypeParameterScope('E extends String', (scope) { + isSubtype( + scope.parseType('E?'), + _parseTestType('FutureOr?'), + strT0: 'E?, E extends String', + strT1: 'FutureOr?', + ); + isSubtype( + scope.parseType('E?'), + _parseTestType('FutureOr'), + strT0: 'E?, E extends String', + strT1: 'FutureOr', + ); + isNotSubtype( + scope.parseType('E?'), + _parseTestType('FutureOr'), + strT0: 'E?, E extends String', + strT1: 'FutureOr', + ); + }); - E = typeParameter('E', bound: stringNone); - isSubtype( - typeParameterTypeQuestion(E), - futureOrQuestion(stringNone), - strT0: 'E?, E extends String', - strT1: 'FutureOr?', - ); - isSubtype( - typeParameterTypeQuestion(E), - futureOrNone(stringQuestion), - strT0: 'E?, E extends String', - strT1: 'FutureOr', - ); - isNotSubtype( - typeParameterTypeQuestion(E), - futureOrNone(stringNone), - strT0: 'E?, E extends String', - strT1: 'FutureOr', - ); - - E = typeParameter('E', bound: stringQuestion); - isSubtype( - typeParameterTypeNone(E), - futureOrQuestion(stringNone), - strT0: 'E, E extends String?', - strT1: 'FutureOr?', - ); - isSubtype( - typeParameterTypeNone(E), - futureOrNone(stringQuestion), - strT0: 'E, E extends String?', - strT1: 'FutureOr', - ); - isNotSubtype( - typeParameterTypeNone(E), - futureOrNone(stringNone), - strT0: 'E, E extends String?', - strT1: 'FutureOr', - ); + withTypeParameterScope('E extends String?', (scope) { + isSubtype( + scope.parseType('E'), + _parseTestType('FutureOr?'), + strT0: 'E, E extends String?', + strT1: 'FutureOr?', + ); + isSubtype( + scope.parseType('E'), + _parseTestType('FutureOr'), + strT0: 'E, E extends String?', + strT1: 'FutureOr', + ); + isNotSubtype( + scope.parseType('E'), + _parseTestType('FutureOr'), + strT0: 'E, E extends String?', + strT1: 'FutureOr', + ); + }); } test_multi_futureOr_typeParameter_promotion() { - TypeParameterElementImpl S; - TypeParameterElementImpl T; + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr'), + strT0: 'T & int, T extends Object', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr'), + strT0: 'T & int, T extends Object', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr?'), + strT0: 'T & int, T extends Object', + strT1: 'FutureOr?', + ); + }); - T = typeParameter('T', bound: objectNone); - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrNone(numNone), - strT0: 'T & int, T extends Object', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrNone(numQuestion), - strT0: 'T & int, T extends Object', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrQuestion(numNone), - strT0: 'T & int, T extends Object', - strT1: 'FutureOr?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr'), + strT0: 'T & int, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr'), + strT0: 'T & int, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & int'), + _parseTestType('FutureOr?'), + strT0: 'T & int, T extends Object?', + strT1: 'FutureOr?', + ); + }); - T = typeParameter('T', bound: objectQuestion); - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrNone(numNone), - strT0: 'T & int, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrNone(numQuestion), - strT0: 'T & int, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - futureOrQuestion(numNone), - strT0: 'T & int, T extends Object?', - strT1: 'FutureOr?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isNotSubtype( + scope.parseType('T & int?'), + _parseTestType('FutureOr'), + strT0: 'T & int?, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & int?'), + _parseTestType('FutureOr'), + strT0: 'T & int?, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & int?'), + _parseTestType('FutureOr?'), + strT0: 'T & int?, T extends Object?', + strT1: 'FutureOr?', + ); + }); - T = typeParameter('T', bound: objectQuestion); - isNotSubtype( - promotedTypeParameterTypeNone(T, intQuestion), - futureOrNone(numNone), - strT0: 'T & int?, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, intQuestion), - futureOrNone(numQuestion), - strT0: 'T & int?, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, intQuestion), - futureOrQuestion(numNone), - strT0: 'T & int?, T extends Object?', - strT1: 'FutureOr?', - ); + withTypeParameterScope('T extends Object?, S extends T', (scope) { + isNotSubtype( + scope.parseType('T & S'), + _parseTestType('FutureOr'), + strT0: 'T & S, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & S'), + _parseTestType('FutureOr'), + strT0: 'T & S, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & S'), + _parseTestType('FutureOr?'), + strT0: 'T & S, T extends Object?', + strT1: 'FutureOr?', + ); + }); - T = typeParameter('T', bound: objectQuestion); - S = typeParameter('S', bound: typeParameterTypeNone(T)); - isNotSubtype( - promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), - futureOrNone(objectNone), - strT0: 'T & S, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), - futureOrNone(objectQuestion), - strT0: 'T & S, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), - futureOrQuestion(objectNone), - strT0: 'T & S, T extends Object?', - strT1: 'FutureOr?', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr', + ); + }); - T = typeParameter('T', bound: objectNone); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(numNone)), - futureOrNone(numNone), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrNone(numNone), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr?'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr?', + ); + }); - T = typeParameter('T', bound: objectNone); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrNone(numNone), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrNone(numQuestion), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrQuestion(numNone), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr?'), + strT0: 'T & Future, T extends Object?', + strT1: 'FutureOr?', + ); - T = typeParameter('T', bound: objectQuestion); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrNone(numNone), - strT0: 'T & Future, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrNone(numQuestion), - strT0: 'T & Future, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intNone)), - futureOrQuestion(numNone), - strT0: 'T & Future, T extends Object?', - strT1: 'FutureOr?', - ); + isNotSubtype( + scope.parseType('T & Future?'), + _parseTestType('FutureOr'), + strT0: 'T & Future?, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future?'), + _parseTestType('FutureOr'), + strT0: 'T & Future?, T extends Object?', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future?'), + _parseTestType('FutureOr?'), + strT0: 'T & Future?, T extends Object?', + strT1: 'FutureOr?', + ); + }); - isNotSubtype( - promotedTypeParameterTypeNone(T, futureQuestion(intNone)), - futureOrNone(numNone), - strT0: 'T & Future?, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureQuestion(intNone)), - futureOrNone(numQuestion), - strT0: 'T & Future?, T extends Object?', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureQuestion(intNone)), - futureOrQuestion(numNone), - strT0: 'T & Future?, T extends Object?', - strT1: 'FutureOr?', - ); - - T = typeParameter('T', bound: objectNone); - isNotSubtype( - promotedTypeParameterTypeNone(T, futureNone(intQuestion)), - futureOrNone(numNone), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr', - ); - isSubtype( - promotedTypeParameterTypeNone(T, futureNone(intQuestion)), - futureOrNone(numQuestion), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr', - ); - isNotSubtype( - promotedTypeParameterTypeNone(T, futureNone(intQuestion)), - futureOrQuestion(numNone), - strT0: 'T & Future, T extends Object', - strT1: 'FutureOr?', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr', + ); + isSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr', + ); + isNotSubtype( + scope.parseType('T & Future'), + _parseTestType('FutureOr?'), + strT0: 'T & Future, T extends Object', + strT1: 'FutureOr?', + ); + }); } test_multi_list_subTypes_superTypes() { @@ -3025,597 +1717,640 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } test_multi_typeParameter_promotion() { - TypeParameterElementImpl T; + withTypeParameterScope('T extends int', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T & int'), + strT0: 'T, T extends int', + strT1: 'T & int, T extends int', + ); + isNotSubtype( + scope.parseType('T?'), + scope.parseType('T & int'), + strT0: 'T?, T extends int', + strT1: 'T & int, T extends int', + ); + }); - T = typeParameter('T', bound: intNone); - isSubtype( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T, T extends int', - strT1: 'T & int, T extends int', - ); - isNotSubtype( - typeParameterTypeQuestion(T), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T?, T extends int', - strT1: 'T & int, T extends int', - ); + withTypeParameterScope('T extends int?', (scope) { + isNotSubtype( + scope.parseType('T'), + scope.parseType('T & int'), + strT0: 'T, T extends int?', + strT1: 'T & int, T extends int?', + ); + isSubtype( + scope.parseType('T'), + scope.parseType('T & int?'), + strT0: 'T, T extends int?', + strT1: 'T & int?, T extends int?', + ); + isNotSubtype( + scope.parseType('T?'), + scope.parseType('T & int?'), + strT0: 'T?, T extends int?', + strT1: 'T & int?, T extends int?', + ); + }); - T = typeParameter('T', bound: intQuestion); - isNotSubtype( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T, T extends int?', - strT1: 'T & int, T extends int?', - ); - isSubtype( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, intQuestion), - strT0: 'T, T extends int?', - strT1: 'T & int?, T extends int?', - ); - isNotSubtype( - typeParameterTypeQuestion(T), - promotedTypeParameterTypeNone(T, intQuestion), - strT0: 'T?, T extends int?', - strT1: 'T & int?, T extends int?', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T'), + strT0: 'T, T extends num', + strT1: 'T, T extends num', + ); + isSubtype( + scope.parseType('T?'), + scope.parseType('T?'), + strT0: 'T?, T extends num', + strT1: 'T?, T extends num', + ); + }); - T = typeParameter('T', bound: numNone); - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - strT0: 'T, T extends num', - strT1: 'T, T extends num', - ); - isSubtype( - typeParameterTypeQuestion(T), - typeParameterTypeQuestion(T), - strT0: 'T?, T extends num', - strT1: 'T?, T extends num', - ); - - T = typeParameter('T', bound: numQuestion); - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - strT0: 'T, T extends num?', - strT1: 'T, T extends num?', - ); - isSubtype( - typeParameterTypeQuestion(T), - typeParameterTypeQuestion(T), - strT0: 'T?, T extends num?', - strT1: 'T?, T extends num?', - ); + withTypeParameterScope('T extends num?', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T'), + strT0: 'T, T extends num?', + strT1: 'T, T extends num?', + ); + isSubtype( + scope.parseType('T?'), + scope.parseType('T?'), + strT0: 'T?, T extends num?', + strT1: 'T?, T extends num?', + ); + }); } test_never_01() { - isSubtype(neverNone, neverNone, strT0: 'Never', strT1: 'Never'); + isSubtype( + parseType('Never'), + parseType('Never'), + strT0: 'Never', + strT1: 'Never', + ); } test_never_02() { - isSubtype(neverNone, numNone, strT0: 'Never', strT1: 'num'); + isSubtype( + parseType('Never'), + parseType('num'), + strT0: 'Never', + strT1: 'num', + ); } test_never_04() { - isSubtype(neverNone, numQuestion, strT0: 'Never', strT1: 'num?'); + isSubtype( + parseType('Never'), + parseType('num?'), + strT0: 'Never', + strT1: 'num?', + ); } test_never_05() { - isNotSubtype(numNone, neverNone, strT0: 'num', strT1: 'Never'); + isNotSubtype( + parseType('num'), + parseType('Never'), + strT0: 'num', + strT1: 'Never', + ); } test_never_06() { - isSubtype(neverNone, listNone(intNone), strT0: 'Never', strT1: 'List'); + isSubtype( + parseType('Never'), + _parseTestType('List'), + strT0: 'Never', + strT1: 'List', + ); } test_never_09() { - isNotSubtype(numNone, neverNone, strT0: 'num', strT1: 'Never'); + isNotSubtype( + parseType('num'), + parseType('Never'), + strT0: 'num', + strT1: 'Never', + ); } test_never_15() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - neverNone, - promotedTypeParameterTypeNone(T, numNone), - strT0: 'Never', - strT1: 'T & num, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + parseType('Never'), + scope.parseType('T & num'), + strT0: 'Never', + strT1: 'T & num, T extends Object', + ); + }); } test_never_16() { - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - promotedTypeParameterTypeNone(T, numNone), - neverNone, - strT0: 'T & num, T extends Object', - strT1: 'Never', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + scope.parseType('T & num'), + parseType('Never'), + strT0: 'T & num, T extends Object', + strT1: 'Never', + ); + }); } test_never_17() { - var T = typeParameter('T', bound: neverNone); - - isSubtype( - typeParameterTypeNone(T), - neverNone, - strT0: 'T, T extends Never', - strT1: 'Never', - ); + withTypeParameterScope('T extends Never', (scope) { + isSubtype( + scope.parseType('T'), + parseType('Never'), + strT0: 'T, T extends Never', + strT1: 'Never', + ); + }); } test_never_18() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - promotedTypeParameterTypeNone(T, neverNone), - neverNone, - strT0: 'T & Never, T extends Object', - strT1: 'Never', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + scope.parseType('T & Never'), + parseType('Never'), + strT0: 'T & Never, T extends Object', + strT1: 'Never', + ); + }); } test_never_19() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - neverNone, - typeParameterTypeQuestion(T), - strT0: 'Never', - strT1: 'T?, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + parseType('Never'), + scope.parseType('T?'), + strT0: 'Never', + strT1: 'T?, T extends Object', + ); + }); } test_never_20() { - var T = typeParameter('T', bound: objectQuestion); - - isSubtype( - neverNone, - typeParameterTypeQuestion(T), - strT0: 'Never', - strT1: 'T?, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + parseType('Never'), + scope.parseType('T?'), + strT0: 'Never', + strT1: 'T?, T extends Object?', + ); + }); } test_never_21() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - neverNone, - typeParameterTypeNone(T), - strT0: 'Never', - strT1: 'T, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + parseType('Never'), + scope.parseType('T'), + strT0: 'Never', + strT1: 'T, T extends Object', + ); + }); } test_never_22() { - var T = typeParameter('T', bound: objectQuestion); - - isSubtype( - neverNone, - typeParameterTypeNone(T), - strT0: 'Never', - strT1: 'T, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + parseType('Never'), + scope.parseType('T'), + strT0: 'Never', + strT1: 'T, T extends Object?', + ); + }); } test_never_23() { - var T = typeParameter('T', bound: neverNone); - - isSubtype( - typeParameterTypeNone(T), - neverNone, - strT0: 'T, T extends Never', - strT1: 'Never', - ); + withTypeParameterScope('T extends Never', (scope) { + isSubtype( + scope.parseType('T'), + parseType('Never'), + strT0: 'T, T extends Never', + strT1: 'Never', + ); + }); } test_never_24() { - var T = typeParameter('T', bound: neverQuestion); - - isNotSubtype( - typeParameterTypeNone(T), - neverNone, - strT0: 'T, T extends Never?', - strT1: 'Never', - ); + withTypeParameterScope('T extends Never?', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Never'), + strT0: 'T, T extends Never?', + strT1: 'Never', + ); + }); } test_never_25() { - var T = typeParameter('T', bound: neverNone); - - isNotSubtype( - typeParameterTypeQuestion(T), - neverNone, - strT0: 'T?, T extends Never', - strT1: 'Never', - ); + withTypeParameterScope('T extends Never', (scope) { + isNotSubtype( + scope.parseType('T?'), + parseType('Never'), + strT0: 'T?, T extends Never', + strT1: 'Never', + ); + }); } test_never_26() { - var T = typeParameter('T', bound: neverQuestion); - - isNotSubtype( - typeParameterTypeQuestion(T), - neverNone, - strT0: 'T?, T extends Never?', - strT1: 'Never', - ); + withTypeParameterScope('T extends Never?', (scope) { + isNotSubtype( + scope.parseType('T?'), + parseType('Never'), + strT0: 'T?, T extends Never?', + strT1: 'Never', + ); + }); } test_never_27() { - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - typeParameterTypeNone(T), - neverNone, - strT0: 'T, T extends Object', - strT1: 'Never', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Never'), + strT0: 'T, T extends Object', + strT1: 'Never', + ); + }); } test_never_28() { - var T = typeParameter('T', bound: objectQuestion); + withTypeParameterScope('T extends Object?', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Never'), + strT0: 'T, T extends Object?', + strT1: 'Never', + ); + }); + } + test_never_29() { + isSubtype( + parseType('Never'), + parseType('Null'), + strT0: 'Never', + strT1: 'Null', + ); + } + + test_null_01() { isNotSubtype( - typeParameterTypeNone(T), - neverNone, - strT0: 'T, T extends Object?', + parseType('Null'), + parseType('Never'), + strT0: 'Null', strT1: 'Never', ); } - test_never_29() { - isSubtype(neverNone, nullNone, strT0: 'Never', strT1: 'Null'); - } - - test_null_01() { - isNotSubtype(nullNone, neverNone, strT0: 'Null', strT1: 'Never'); - } - test_null_02() { - isNotSubtype(nullNone, objectNone, strT0: 'Null', strT1: 'Object'); + isNotSubtype( + parseType('Null'), + parseType('Object'), + strT0: 'Null', + strT1: 'Object', + ); } test_null_03() { - isSubtype(nullNone, voidNone, strT0: 'Null', strT1: 'void'); + isSubtype( + parseType('Null'), + parseType('void'), + strT0: 'Null', + strT1: 'void', + ); } test_null_04() { - isSubtype(nullNone, dynamicType, strT0: 'Null', strT1: 'dynamic'); + isSubtype( + parseType('Null'), + parseType('dynamic'), + strT0: 'Null', + strT1: 'dynamic', + ); } test_null_05() { - isNotSubtype(nullNone, doubleNone, strT0: 'Null', strT1: 'double'); + isNotSubtype( + parseType('Null'), + parseType('double'), + strT0: 'Null', + strT1: 'double', + ); } test_null_06() { - isSubtype(nullNone, doubleQuestion, strT0: 'Null', strT1: 'double?'); + isSubtype( + parseType('Null'), + parseType('double?'), + strT0: 'Null', + strT1: 'double?', + ); } test_null_07() { isNotSubtype( - nullNone, - comparableNone(objectNone), + parseType('Null'), + _parseTestType('Comparable'), strT0: 'Null', strT1: 'Comparable', ); } test_null_08() { - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - nullNone, - typeParameterTypeNone(T), - strT0: 'Null', - strT1: 'T, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T'), + strT0: 'Null', + strT1: 'T, T extends Object', + ); + }); } test_null_09() { - isSubtype(nullNone, nullNone, strT0: 'Null', strT1: 'Null'); + isSubtype( + parseType('Null'), + parseType('Null'), + strT0: 'Null', + strT1: 'Null', + ); } test_null_10() { isNotSubtype( - nullNone, - listNone(intNone), + parseType('Null'), + _parseTestType('List'), strT0: 'Null', strT1: 'List', ); } test_null_13() { - isNotSubtype( - nullNone, - functionTypeNone( - returnType: numNone, - formalParameters: [requiredParameter(type: intNone)], - ), - strT0: 'Null', - strT1: 'num Function(int)', - ); + isNotSubtype2('Null', 'num Function(int)'); } test_null_14() { - isNotSubtype( - nullNone, - functionTypeNone( - returnType: numNone, - formalParameters: [requiredParameter(type: intNone)], - ), - strT0: 'Null', - strT1: 'num Function(int)', - ); + isNotSubtype2('Null', 'num Function(int)'); } test_null_15() { - isSubtype( - nullNone, - functionTypeQuestion( - returnType: numNone, - formalParameters: [requiredParameter(type: intNone)], - ), - strT0: 'Null', - strT1: 'num Function(int)?', - ); + isSubtype2('Null', 'num Function(int)?'); } test_null_16() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - nullNone, - promotedTypeParameterTypeQuestion(T, numNone), - strT0: 'Null', - strT1: '(T & num)?, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + parseType('Null'), + scope.parseType('(T & num)?'), + strT0: 'Null', + strT1: '(T & num)?, T extends Object', + ); + }); } test_null_17() { - var T = typeParameter('T', bound: objectQuestion); - - isNotSubtype( - nullNone, - promotedTypeParameterTypeNone(T, numNone), - strT0: 'Null', - strT1: 'T & num, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T & num'), + strT0: 'Null', + strT1: 'T & num, T extends Object?', + ); + }); } test_null_18() { - var T = typeParameter('T', bound: objectQuestion); - - isNotSubtype( - nullNone, - promotedTypeParameterTypeNone(T, numQuestion), - strT0: 'Null', - strT1: 'T & num?, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T & num?'), + strT0: 'Null', + strT1: 'T & num?, T extends Object?', + ); + }); } test_null_19() { - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - nullNone, - promotedTypeParameterTypeNone(T, numNone), - strT0: 'Null', - strT1: 'T & num, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T & num'), + strT0: 'Null', + strT1: 'T & num, T extends Object', + ); + }); } test_null_20() { - var T = typeParameter('T', bound: objectQuestion); - var S = typeParameter('S', bound: typeParameterTypeNone(T)); - - isNotSubtype( - nullNone, - promotedTypeParameterTypeNone(T, typeParameterTypeNone(S)), - strT0: 'Null', - strT1: 'T & S, T extends Object?', - ); + withTypeParameterScope('T extends Object?, S extends T', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T & S'), + strT0: 'Null', + strT1: 'T & S, T extends Object?', + ); + }); } test_null_21() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - nullNone, - typeParameterTypeQuestion(T), - strT0: 'Null', - strT1: 'T?, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + parseType('Null'), + scope.parseType('T?'), + strT0: 'Null', + strT1: 'T?, T extends Object', + ); + }); } test_null_22() { - var T = typeParameter('T', bound: objectQuestion); - - isSubtype( - nullNone, - typeParameterTypeQuestion(T), - strT0: 'Null', - strT1: 'T?, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isSubtype( + parseType('Null'), + scope.parseType('T?'), + strT0: 'Null', + strT1: 'T?, T extends Object?', + ); + }); } test_null_23() { - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - nullNone, - typeParameterTypeNone(T), - strT0: 'Null', - strT1: 'T, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T'), + strT0: 'Null', + strT1: 'T, T extends Object', + ); + }); } test_null_24() { - var T = typeParameter('T', bound: objectQuestion); - - isNotSubtype( - nullNone, - typeParameterTypeNone(T), - strT0: 'Null', - strT1: 'T, T extends Object?', - ); + withTypeParameterScope('T extends Object?', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T'), + strT0: 'Null', + strT1: 'T, T extends Object?', + ); + }); } test_null_25() { - var T = typeParameter('T', bound: nullNone); - - isSubtype( - typeParameterTypeNone(T), - nullNone, - strT0: 'T, T extends Null', - strT1: 'Null', - ); + withTypeParameterScope('T extends Null', (scope) { + isSubtype( + scope.parseType('T'), + parseType('Null'), + strT0: 'T, T extends Null', + strT1: 'Null', + ); + }); } test_null_26() { - var T = typeParameter('T', bound: nullNone); - - isSubtype( - typeParameterTypeQuestion(T), - nullNone, - strT0: 'T?, T extends Null', - strT1: 'Null', - ); + withTypeParameterScope('T extends Null', (scope) { + isSubtype( + scope.parseType('T?'), + parseType('Null'), + strT0: 'T?, T extends Null', + strT1: 'Null', + ); + }); } test_null_27() { - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - typeParameterTypeNone(T), - nullNone, - strT0: 'T, T extends Object', - strT1: 'Null', - ); + withTypeParameterScope('T extends Object', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Null'), + strT0: 'T, T extends Object', + strT1: 'Null', + ); + }); } test_null_28() { - var T = typeParameter('T', bound: objectQuestion); - - isNotSubtype( - typeParameterTypeNone(T), - nullNone, - strT0: 'T, T extends Object?', - strT1: 'Null', - ); + withTypeParameterScope('T extends Object?', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Null'), + strT0: 'T, T extends Object?', + strT1: 'Null', + ); + }); } test_null_29() { isSubtype( - nullNone, - comparableQuestion(objectNone), + parseType('Null'), + _parseTestType('Comparable?'), strT0: 'Null', strT1: 'Comparable?', ); } test_null_30() { - isNotSubtype(nullNone, objectNone, strT0: 'Null', strT1: 'Object'); - } - - test_nullabilitySuffix_01() { - isSubtype(intNone, intNone, strT0: 'int', strT1: 'int'); - isSubtype(intNone, intQuestion, strT0: 'int', strT1: 'int?'); - - isNotSubtype(intQuestion, intNone, strT0: 'int?', strT1: 'int'); - isSubtype(intQuestion, intQuestion, strT0: 'int?', strT1: 'int?'); - - isSubtype(intNone, intNone, strT0: 'int', strT1: 'int'); - isSubtype(intNone, intQuestion, strT0: 'int', strT1: 'int?'); - } - - test_nullabilitySuffix_05() { - isSubtype( - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ), - objectNone, - strT0: 'void Function(int)', + isNotSubtype( + parseType('Null'), + parseType('Object'), + strT0: 'Null', strT1: 'Object', ); } + test_nullabilitySuffix_01() { + isSubtype(parseType('int'), parseType('int'), strT0: 'int', strT1: 'int'); + isSubtype(parseType('int'), parseType('int?'), strT0: 'int', strT1: 'int?'); + + isNotSubtype( + parseType('int?'), + parseType('int'), + strT0: 'int?', + strT1: 'int', + ); + isSubtype( + parseType('int?'), + parseType('int?'), + strT0: 'int?', + strT1: 'int?', + ); + + isSubtype(parseType('int'), parseType('int'), strT0: 'int', strT1: 'int'); + isSubtype(parseType('int'), parseType('int?'), strT0: 'int', strT1: 'int?'); + } + + test_nullabilitySuffix_05() { + isSubtype2('void Function(int)', 'Object'); + } + test_nullabilitySuffix_11() { - isSubtype(intQuestion, intQuestion, strT0: 'int?', strT1: 'int?'); + isSubtype( + parseType('int?'), + parseType('int?'), + strT0: 'int?', + strT1: 'int?', + ); } test_nullabilitySuffix_12() { - isSubtype(intNone, intNone, strT0: 'int', strT1: 'int'); + isSubtype(parseType('int'), parseType('int'), strT0: 'int', strT1: 'int'); } test_nullabilitySuffix_13() { - var f = functionTypeQuestion( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ); - isSubtype(f, f, strT0: 'int Function(int)?', strT1: 'int Function(int)?'); + isSubtype2('int Function(int)?', 'int Function(int)?'); } test_nullabilitySuffix_14() { - var f = functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ); - isSubtype(f, f, strT0: 'int Function(int)', strT1: 'int Function(int)'); + isSubtype2('int Function(int)', 'int Function(int)'); } test_nullabilitySuffix_15() { - var f = functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: intNone), - requiredParameter(type: intQuestion), - ], - returnType: intQuestion, - ); - isSubtype( - f, - f, - strT0: 'int? Function(int, int, int?)', - strT1: 'int? Function(int, int, int?)', + isSubtype2( + 'int? Function(int, int, int?)', + 'int? Function(int, int, int?)', ); } test_nullabilitySuffix_16() { - var type = listQuestion(intNone); + var type = _parseTestType('List?'); isSubtype(type, type, strT0: 'List?', strT1: 'List?'); } test_nullabilitySuffix_17() { - var type = listQuestion(intQuestion); + var type = _parseTestType('List?'); isSubtype(type, type, strT0: 'List?', strT1: 'List?'); } test_nullabilitySuffix_18() { - var T = typeParameter('T', bound: objectNone); - var type = promotedTypeParameterTypeNone(T, intQuestion); - isSubtype( - type, - type, - strT0: 'T & int?, T extends Object', - strT1: 'T & int?, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + var type = scope.parseType('T & int?'); + isSubtype( + type, + type, + strT0: 'T & int?, T extends Object', + strT1: 'T & int?, T extends Object', + ); + }); } test_nullabilitySuffix_19() { - var T = typeParameter('T', bound: objectNone); - var type = promotedTypeParameterTypeQuestion(T, intQuestion); - isSubtype( - type, - type, - strT0: '(T & int?)?, T extends Object', - strT1: '(T & int?)?, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + var type = scope.parseType('(T & int?)?'); + isSubtype( + type, + type, + strT0: '(T & int?)?, T extends Object', + strT1: '(T & int?)?, T extends Object', + ); + }); } test_record_functionType() { @@ -3675,22 +2410,8 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { } check( - recordTypeNone( - namedTypes: { - 'f1': intNone, - 'f2': intNone, - 'f3': intNone, - 'f4': intNone, - }, - ), - recordTypeNone( - namedTypes: { - 'f4': intNone, - 'f3': intNone, - 'f2': intNone, - 'f1': intNone, - }, - ), + parseRecordType('({int f1, int f2, int f3, int f4})'), + parseRecordType('({int f4, int f3, int f2, int f1})'), ); } @@ -3717,894 +2438,878 @@ class SubtypeTest extends AbstractTypeSystemTest with StringTypes { /// The class `Record` is a subtype of `Object` and `dynamic`, and a /// supertype of `Never`. test_recordClass() { - isSubtype(recordNone, objectNone, strT0: 'Record', strT1: 'Object'); + isSubtype( + parseType('Record'), + parseType('Object'), + strT0: 'Record', + strT1: 'Object', + ); - isSubtype(recordNone, dynamicType, strT0: 'Record', strT1: 'dynamic'); + isSubtype( + parseType('Record'), + parseType('dynamic'), + strT0: 'Record', + strT1: 'dynamic', + ); - isSubtype(neverNone, recordNone, strT0: 'Never', strT1: 'Record'); + isSubtype( + parseType('Never'), + parseType('Record'), + strT0: 'Never', + strT1: 'Record', + ); } test_special_01() { - isNotSubtype(dynamicType, intNone, strT0: 'dynamic', strT1: 'int'); - } - - test_special_02() { - isNotSubtype(voidNone, intNone, strT0: 'void', strT1: 'int'); - } - - test_special_03() { isNotSubtype( - functionTypeNone(returnType: intNone), - intNone, - strT0: 'int Function()', + parseType('dynamic'), + parseType('int'), + strT0: 'dynamic', strT1: 'int', ); } - test_special_04() { + test_special_02() { isNotSubtype( - intNone, - functionTypeNone(returnType: intNone), - strT0: 'int', - strT1: 'int Function()', + parseType('void'), + parseType('int'), + strT0: 'void', + strT1: 'int', ); } + test_special_03() { + isNotSubtype2('int Function()', 'int'); + } + + test_special_04() { + isNotSubtype2('int', 'int Function()'); + } + test_special_06() { + isSubtype2('int Function()', 'Object'); + } + + test_special_07() { isSubtype( - functionTypeNone(returnType: intNone), - objectNone, - strT0: 'int Function()', + parseType('Object'), + parseType('Object'), + strT0: 'Object', strT1: 'Object', ); } - test_special_07() { - isSubtype(objectNone, objectNone, strT0: 'Object', strT1: 'Object'); - } - test_special_08() { - isSubtype(objectNone, dynamicType, strT0: 'Object', strT1: 'dynamic'); + isSubtype( + parseType('Object'), + parseType('dynamic'), + strT0: 'Object', + strT1: 'dynamic', + ); } test_special_09() { - isSubtype(objectNone, voidNone, strT0: 'Object', strT1: 'void'); + isSubtype( + parseType('Object'), + parseType('void'), + strT0: 'Object', + strT1: 'void', + ); } test_special_10() { - isNotSubtype(dynamicType, objectNone, strT0: 'dynamic', strT1: 'Object'); + isNotSubtype( + parseType('dynamic'), + parseType('Object'), + strT0: 'dynamic', + strT1: 'Object', + ); } test_special_11() { - isSubtype(dynamicType, dynamicType, strT0: 'dynamic', strT1: 'dynamic'); + isSubtype( + parseType('dynamic'), + parseType('dynamic'), + strT0: 'dynamic', + strT1: 'dynamic', + ); } test_special_12() { - isSubtype(dynamicType, voidNone, strT0: 'dynamic', strT1: 'void'); + isSubtype( + parseType('dynamic'), + parseType('void'), + strT0: 'dynamic', + strT1: 'void', + ); } test_special_13() { - isNotSubtype(voidNone, objectNone, strT0: 'void', strT1: 'Object'); + isNotSubtype( + parseType('void'), + parseType('Object'), + strT0: 'void', + strT1: 'Object', + ); } test_special_14() { - isSubtype(voidNone, dynamicType, strT0: 'void', strT1: 'dynamic'); + isSubtype( + parseType('void'), + parseType('dynamic'), + strT0: 'void', + strT1: 'dynamic', + ); } test_special_15() { - isSubtype(voidNone, voidNone, strT0: 'void', strT1: 'void'); + isSubtype( + parseType('void'), + parseType('void'), + strT0: 'void', + strT1: 'void', + ); } test_top_03() { - var T0 = typeParameter('T0', bound: dynamicType); - var T1 = typeParameter('T2', bound: voidNone); - - var f0 = functionTypeNone( - typeParameters: [T0], - returnType: typeParameterTypeNone(T0), - ); - - var f1 = functionTypeNone( - typeParameters: [T1], - returnType: typeParameterTypeNone(T1), - ); + var f0 = parseFunctionType('T0 Function()'); + var f1 = parseFunctionType('T2 Function()'); isSubtype(f0, f1); isSubtype(f1, f0); } test_top_04() { - isNotSubtype( - dynamicType, - functionTypeNone(returnType: dynamicType), - strT0: 'dynamic', - strT1: 'dynamic Function()', - ); + isNotSubtype2('dynamic', 'dynamic Function()'); } test_top_05() { - isNotSubtype( - futureOrNone(functionTypeNone(returnType: voidNone)), - functionTypeNone(returnType: voidNone), - strT0: 'FutureOr', - strT1: 'void Function()', - ); + isNotSubtype2('FutureOr', 'void Function()'); } test_top_06() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, functionTypeNone(returnType: voidNone)), - functionTypeNone(returnType: voidNone), - strT0: 'T & void Function()', - strT1: 'void Function()', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & void Function()'), + parseFunctionType('void Function()'), + strT0: 'T & void Function()', + strT1: 'void Function()', + ); + }); } test_top_07() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, functionTypeNone(returnType: voidNone)), - functionTypeNone(returnType: dynamicType), - strT0: 'T & void Function()', - strT1: 'dynamic Function()', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & void Function()'), + parseFunctionType('dynamic Function()'), + strT0: 'T & void Function()', + strT1: 'dynamic Function()', + ); + }); } test_top_08() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(T, functionTypeNone(returnType: voidNone)), - functionTypeNone(returnType: objectNone), - strT0: 'T & void Function()', - strT1: 'Object Function()', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & void Function()'), + parseFunctionType('Object Function()'), + strT0: 'T & void Function()', + strT1: 'Object Function()', + ); + }); } test_top_09() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone( - T, - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - strT0: 'T & void Function(void)', - strT1: 'void Function(void)', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & void Function(void)'), + parseFunctionType('void Function(void)'), + strT0: 'T & void Function(void)', + strT1: 'void Function(void)', + ); + }); } test_top_10() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone( - T, - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: dynamicType)], - returnType: dynamicType, - ), - strT0: 'T & void Function(void)', - strT1: 'dynamic Function(dynamic)', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & void Function(void)'), + parseFunctionType('dynamic Function(dynamic)'), + strT0: 'T & void Function(void)', + strT1: 'dynamic Function(dynamic)', + ); + }); } test_top_11() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone( - T, - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: objectNone)], - returnType: objectNone, - ), - strT0: 'T & void Function(void)', - strT1: 'Object Function(Object)', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & void Function(void)'), + parseFunctionType('Object Function(Object)'), + strT0: 'T & void Function(void)', + strT1: 'Object Function(Object)', + ); + }); } test_top_12() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone( - T, - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: iterableNone(intNone))], - returnType: dynamicType, - ), - strT0: 'T & void Function(void)', - strT1: 'dynamic Function(Iterable)', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & void Function(void)'), + parseFunctionType('dynamic Function(Iterable)'), + strT0: 'T & void Function(void)', + strT1: 'dynamic Function(Iterable)', + ); + }); } test_top_13() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone( - T, - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: objectNone, - ), - strT0: 'T & void Function(void)', - strT1: 'Object Function(int)', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & void Function(void)'), + parseFunctionType('Object Function(int)'), + strT0: 'T & void Function(void)', + strT1: 'Object Function(int)', + ); + }); } test_top_14() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone( - T, - functionTypeNone( - formalParameters: [requiredParameter(type: voidNone)], - returnType: voidNone, - ), - ), - functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: intNone, - ), - strT0: 'T & void Function(void)', - strT1: 'int Function(int)', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & void Function(void)'), + parseFunctionType('int Function(int)'), + strT0: 'T & void Function(void)', + strT1: 'int Function(int)', + ); + }); } test_top_15() { - var T = typeParameter('T', bound: functionTypeNone(returnType: voidNone)); - - isSubtype( - typeParameterTypeNone(T), - functionTypeNone(returnType: voidNone), - strT0: 'T, T extends void Function()', - strT1: 'void Function()', - ); + withTypeParameterScope('T extends void Function()', (scope) { + isSubtype( + scope.parseType('T'), + parseFunctionType('void Function()'), + strT0: 'T, T extends void Function()', + strT1: 'void Function()', + ); + }); } test_top_16() { - var T = typeParameter('T'); - - isNotSubtype( - typeParameterTypeNone(T), - functionTypeNone(returnType: voidNone), - strT0: 'T', - strT1: 'void Function()', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T'), + parseFunctionType('void Function()'), + strT0: 'T', + strT1: 'void Function()', + ); + }); } test_top_17() { isNotSubtype( - voidNone, - functionTypeNone(returnType: voidNone), + parseType('void'), + parseFunctionType('void Function()'), strT0: 'void', strT1: 'void Function()', ); } test_top_18() { - var T = typeParameter('T'); - - isNotSubtype( - dynamicType, - typeParameterTypeNone(T), - strT0: 'dynamic', - strT1: 'T', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + parseType('dynamic'), + scope.parseType('T'), + strT0: 'dynamic', + strT1: 'T', + ); + }); } test_top_19() { - var T = typeParameter('T'); - - isNotSubtype( - iterableNone(typeParameterTypeNone(T)), - typeParameterTypeNone(T), - strT0: 'Iterable', - strT1: 'T', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('Iterable'), + scope.parseType('T'), + strT0: 'Iterable', + strT1: 'T', + ); + }); } test_top_21() { - var T = typeParameter('T'); - - isNotSubtype( - functionTypeNone(returnType: voidNone), - typeParameterTypeNone(T), - strT0: 'void Function()', - strT1: 'T', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + parseFunctionType('void Function()'), + scope.parseType('T'), + strT0: 'void Function()', + strT1: 'T', + ); + }); } test_top_22() { - var T = typeParameter('T'); - - isNotSubtype( - futureOrNone(typeParameterTypeNone(T)), - typeParameterTypeNone(T), - strT0: 'FutureOr', - strT1: 'T', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('FutureOr'), + scope.parseType('T'), + strT0: 'FutureOr', + strT1: 'T', + ); + }); } test_top_23() { - var T = typeParameter('T'); - - isNotSubtype(voidNone, typeParameterTypeNone(T), strT0: 'void', strT1: 'T'); + withTypeParameterScope('T', (scope) { + isNotSubtype( + parseType('void'), + scope.parseType('T'), + strT0: 'void', + strT1: 'T', + ); + }); } test_top_24() { - var T = typeParameter('T'); - - isNotSubtype( - voidNone, - promotedTypeParameterTypeNone(T, voidNone), - strT0: 'void', - strT1: 'T & void', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + parseType('void'), + scope.parseType('T & void'), + strT0: 'void', + strT1: 'T & void', + ); + }); } test_top_25() { - var T = typeParameter('T', bound: voidNone); - - isNotSubtype( - voidNone, - promotedTypeParameterTypeNone(T, voidNone), - strT0: 'void', - strT1: 'T & void, T extends void', - ); + withTypeParameterScope('T extends void', (scope) { + isNotSubtype( + parseType('void'), + scope.parseType('T & void'), + strT0: 'void', + strT1: 'T & void, T extends void', + ); + }); } test_typeParameter_01() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T & int', - strT1: 'T & int', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & int'), + scope.parseType('T & int'), + strT0: 'T & int', + strT1: 'T & int', + ); + }); } test_typeParameter_02() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - promotedTypeParameterTypeNone(T, numNone), - strT0: 'T & int', - strT1: 'T & num', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & int'), + scope.parseType('T & num'), + strT0: 'T & int', + strT1: 'T & num', + ); + }); } test_typeParameter_03() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, numNone), - promotedTypeParameterTypeNone(T, numNone), - strT0: 'T & num', - strT1: 'T & num', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & num'), + scope.parseType('T & num'), + strT0: 'T & num', + strT1: 'T & num', + ); + }); } test_typeParameter_04() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(T, numNone), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T & num', - strT1: 'T & int', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & num'), + scope.parseType('T & int'), + strT0: 'T & num', + strT1: 'T & int', + ); + }); } test_typeParameter_05() { - var T = typeParameter('T'); - - isNotSubtype( - nullNone, - promotedTypeParameterTypeNone(T, numNone), - strT0: 'Null', - strT1: 'T & num', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T & num'), + strT0: 'Null', + strT1: 'T & num', + ); + }); } test_typeParameter_06() { - var T = typeParameter('T', bound: intNone); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - typeParameterTypeNone(T), - strT0: 'T & int, T extends int', - strT1: 'T, T extends int', - ); + withTypeParameterScope('T extends int', (scope) { + isSubtype( + scope.parseType('T & int'), + scope.parseType('T'), + strT0: 'T & int, T extends int', + strT1: 'T, T extends int', + ); + }); } test_typeParameter_07() { - var T = typeParameter('T', bound: numNone); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - typeParameterTypeNone(T), - strT0: 'T & int, T extends num', - strT1: 'T, T extends num', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T & int'), + scope.parseType('T'), + strT0: 'T & int, T extends num', + strT1: 'T, T extends num', + ); + }); } test_typeParameter_08() { - var T = typeParameter('T', bound: numNone); - - isSubtype( - promotedTypeParameterTypeNone(T, numNone), - typeParameterTypeNone(T), - strT0: 'T & num, T extends num', - strT1: 'T, T extends num', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T & num'), + scope.parseType('T'), + strT0: 'T & num, T extends num', + strT1: 'T, T extends num', + ); + }); } test_typeParameter_09() { - var T = typeParameter('T', bound: intNone); - - isSubtype( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T, T extends int', - strT1: 'T & int, T extends int', - ); + withTypeParameterScope('T extends int', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T & int'), + strT0: 'T, T extends int', + strT1: 'T & int, T extends int', + ); + }); } test_typeParameter_10() { - var T = typeParameter('T', bound: intNone); - - isSubtype( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, numNone), - strT0: 'T, T extends int', - strT1: 'T & num, T extends int', - ); + withTypeParameterScope('T extends int', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T & num'), + strT0: 'T, T extends int', + strT1: 'T & num, T extends int', + ); + }); } test_typeParameter_11() { - var T = typeParameter('T', bound: numNone); - - isNotSubtype( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, intNone), - strT0: 'T, T extends num', - strT1: 'T & int, T extends num', - ); + withTypeParameterScope('T extends num', (scope) { + isNotSubtype( + scope.parseType('T'), + scope.parseType('T & int'), + strT0: 'T, T extends num', + strT1: 'T & int, T extends num', + ); + }); } test_typeParameter_12() { - var T = typeParameter('T', bound: numNone); - - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - strT0: 'T, T extends num', - strT1: 'T, T extends num', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T'), + strT0: 'T, T extends num', + strT1: 'T, T extends num', + ); + }); } test_typeParameter_13() { - var T = typeParameter('T'); - - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - strT0: 'T', - strT1: 'T', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T'), + strT0: 'T', + strT1: 'T', + ); + }); } test_typeParameter_14() { - var S = typeParameter('S'); - var T = typeParameter('T'); - - isNotSubtype( - typeParameterTypeNone(S), - typeParameterTypeNone(T), - strT0: 'S', - strT1: 'T', - ); + withTypeParameterScope('S, T', (scope) { + isNotSubtype( + scope.parseType('S'), + scope.parseType('T'), + strT0: 'S', + strT1: 'T', + ); + }); } test_typeParameter_15() { - var T = typeParameter('T', bound: objectNone); - - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - strT0: 'T, T extends Object', - strT1: 'T, T extends Object', - ); + withTypeParameterScope('T extends Object', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T'), + strT0: 'T, T extends Object', + strT1: 'T, T extends Object', + ); + }); } test_typeParameter_16() { - var S = typeParameter('S', bound: objectNone); - var T = typeParameter('T', bound: objectNone); - - isNotSubtype( - typeParameterTypeNone(S), - typeParameterTypeNone(T), - strT0: 'S, S extends Object', - strT1: 'T, T extends Object', - ); + withTypeParameterScope('S extends Object, T extends Object', (scope) { + isNotSubtype( + scope.parseType('S'), + scope.parseType('T'), + strT0: 'S, S extends Object', + strT1: 'T, T extends Object', + ); + }); } test_typeParameter_17() { - var T = typeParameter('T', bound: dynamicType); - - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - strT0: 'T, T extends dynamic', - strT1: 'T, T extends dynamic', - ); + withTypeParameterScope('T extends dynamic', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('T'), + strT0: 'T, T extends dynamic', + strT1: 'T, T extends dynamic', + ); + }); } test_typeParameter_18() { - var S = typeParameter('S', bound: dynamicType); - var T = typeParameter('T', bound: dynamicType); - - isNotSubtype( - typeParameterTypeNone(S), - typeParameterTypeNone(T), - strT0: 'S, S extends dynamic', - strT1: 'T, T extends dynamic', - ); + withTypeParameterScope('S extends dynamic, T extends dynamic', (scope) { + isNotSubtype( + scope.parseType('S'), + scope.parseType('T'), + strT0: 'S, S extends dynamic', + strT1: 'T, T extends dynamic', + ); + }); } test_typeParameter_19() { - var S = typeParameter('S'); - var T = typeParameter('T', bound: typeParameterTypeNone(S)); + withTypeParameterScope('S, T extends S', (scope) { + isNotSubtype( + scope.parseType('S'), + scope.parseType('T'), + strT0: 'S', + strT1: 'T, T extends S', + ); - isNotSubtype( - typeParameterTypeNone(S), - typeParameterTypeNone(T), - strT0: 'S', - strT1: 'T, T extends S', - ); - - isSubtype( - typeParameterTypeNone(T), - typeParameterTypeNone(S), - strT0: 'T, T extends S', - strT1: 'S', - ); + isSubtype( + scope.parseType('T'), + scope.parseType('S'), + strT0: 'T, T extends S', + strT1: 'S', + ); + }); } test_typeParameter_20() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - intNone, - strT0: 'T & int', - strT1: 'int', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & int'), + parseType('int'), + strT0: 'T & int', + strT1: 'int', + ); + }); } test_typeParameter_21() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, intNone), - numNone, - strT0: 'T & int', - strT1: 'num', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & int'), + parseType('num'), + strT0: 'T & int', + strT1: 'num', + ); + }); } test_typeParameter_22() { - var T = typeParameter('T'); - - isSubtype( - promotedTypeParameterTypeNone(T, numNone), - numNone, - strT0: 'T & num', - strT1: 'num', - ); + withTypeParameterScope('T', (scope) { + isSubtype( + scope.parseType('T & num'), + parseType('num'), + strT0: 'T & num', + strT1: 'num', + ); + }); } test_typeParameter_23() { - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(T, numNone), - intNone, - strT0: 'T & num', - strT1: 'int', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T & num'), + parseType('int'), + strT0: 'T & num', + strT1: 'int', + ); + }); } test_typeParameter_24() { - var S = typeParameter('S'); - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(S, numNone), - typeParameterTypeNone(T), - strT0: 'S & num', - strT1: 'T', - ); + withTypeParameterScope('S, T', (scope) { + isNotSubtype( + scope.parseType('S & num'), + scope.parseType('T'), + strT0: 'S & num', + strT1: 'T', + ); + }); } test_typeParameter_25() { - var S = typeParameter('S'); - var T = typeParameter('T'); - - isNotSubtype( - promotedTypeParameterTypeNone(S, numNone), - promotedTypeParameterTypeNone(T, numNone), - strT0: 'S & num', - strT1: 'T & num', - ); + withTypeParameterScope('S, T', (scope) { + isNotSubtype( + scope.parseType('S & num'), + scope.parseType('T & num'), + strT0: 'S & num', + strT1: 'T & num', + ); + }); } test_typeParameter_26() { - var S = typeParameter('S', bound: intNone); - - isSubtype( - typeParameterTypeNone(S), - intNone, - strT0: 'S, S extends int', - strT1: 'int', - ); + withTypeParameterScope('S extends int', (scope) { + isSubtype( + scope.parseType('S'), + parseType('int'), + strT0: 'S, S extends int', + strT1: 'int', + ); + }); } test_typeParameter_27() { - var S = typeParameter('S', bound: intNone); - - isSubtype( - typeParameterTypeNone(S), - numNone, - strT0: 'S, S extends int', - strT1: 'num', - ); + withTypeParameterScope('S extends int', (scope) { + isSubtype( + scope.parseType('S'), + parseType('num'), + strT0: 'S, S extends int', + strT1: 'num', + ); + }); } test_typeParameter_28() { - var S = typeParameter('S', bound: numNone); - - isSubtype( - typeParameterTypeNone(S), - numNone, - strT0: 'S, S extends num', - strT1: 'num', - ); + withTypeParameterScope('S extends num', (scope) { + isSubtype( + scope.parseType('S'), + parseType('num'), + strT0: 'S, S extends num', + strT1: 'num', + ); + }); } test_typeParameter_29() { - var S = typeParameter('S', bound: numNone); - - isNotSubtype( - typeParameterTypeNone(S), - intNone, - strT0: 'S, S extends num', - strT1: 'int', - ); + withTypeParameterScope('S extends num', (scope) { + isNotSubtype( + scope.parseType('S'), + parseType('int'), + strT0: 'S, S extends num', + strT1: 'int', + ); + }); } test_typeParameter_30() { - var S = typeParameter('S', bound: numNone); - var T = typeParameter('T'); - - isNotSubtype( - typeParameterTypeNone(S), - typeParameterTypeNone(T), - strT0: 'S, S extends num', - strT1: 'T', - ); + withTypeParameterScope('S extends num, T', (scope) { + isNotSubtype( + scope.parseType('S'), + scope.parseType('T'), + strT0: 'S, S extends num', + strT1: 'T', + ); + }); } test_typeParameter_31() { - var S = typeParameter('S', bound: numNone); - var T = typeParameter('T'); - - isNotSubtype( - typeParameterTypeNone(S), - promotedTypeParameterTypeNone(T, numNone), - strT0: 'S, S extends num', - strT1: 'T & num', - ); + withTypeParameterScope('S extends num, T', (scope) { + isNotSubtype( + scope.parseType('S'), + scope.parseType('T & num'), + strT0: 'S, S extends num', + strT1: 'T & num', + ); + }); } test_typeParameter_32() { - var T = typeParameter('T', bound: dynamicType); - - isNotSubtype( - dynamicType, - promotedTypeParameterTypeNone(T, dynamicType), - strT0: 'dynamic', - strT1: 'T & dynamic, T extends dynamic', - ); + withTypeParameterScope('T extends dynamic', (scope) { + isNotSubtype( + parseType('dynamic'), + scope.parseType('T & dynamic'), + strT0: 'dynamic', + strT1: 'T & dynamic, T extends dynamic', + ); + }); } test_typeParameter_33() { - var T = typeParameter('T'); - - isNotSubtype( - functionTypeNone(returnType: typeParameterTypeNone(T)), - promotedTypeParameterTypeNone( - T, - functionTypeNone(returnType: typeParameterTypeNone(T)), - ), - strT0: 'T Function()', - strT1: 'T & T Function()', - ); + withTypeParameterScope('T', (scope) { + var tFunction = scope.parseType('T Function()'); + isNotSubtype( + tFunction, + scope.parseType('T & T Function()'), + strT0: 'T Function()', + strT1: 'T & T Function()', + ); + }); } test_typeParameter_34() { - var T = typeParameter('T'); - - isNotSubtype( - futureOrNone(promotedTypeParameterTypeNone(T, stringNone)), - promotedTypeParameterTypeNone(T, stringNone), - strT0: 'FutureOr', - strT1: 'T & String', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('FutureOr'), + scope.parseType('T & String'), + strT0: 'FutureOr', + strT1: 'T & String', + ); + }); } test_typeParameter_35() { - var T = typeParameter('T'); - - isNotSubtype(nullNone, typeParameterTypeNone(T), strT0: 'Null', strT1: 'T'); + withTypeParameterScope('T', (scope) { + isNotSubtype( + parseType('Null'), + scope.parseType('T'), + strT0: 'Null', + strT1: 'T', + ); + }); } test_typeParameter_36() { - var T = typeParameter('T', bound: numNone); - - isSubtype( - typeParameterTypeNone(T), - numNone, - strT0: 'T, T extends num', - strT1: 'num', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T'), + parseType('num'), + strT0: 'T, T extends num', + strT1: 'num', + ); + }); } test_typeParameter_37() { - var T = typeParameter('T', bound: objectQuestion); + withTypeParameterScope('T extends Object?', (scope) { + var type = scope.parseType('T & num?'); - var type = promotedTypeParameterTypeNone(T, numQuestion); - - isNotSubtype( - type, - numNone, - strT0: 'T & num?, T extends Object?', - strT1: 'num', - ); - isSubtype( - type, - numQuestion, - strT0: 'T & num?, T extends Object?', - strT1: 'num?', - ); + isNotSubtype( + type, + parseType('num'), + strT0: 'T & num?, T extends Object?', + strT1: 'num', + ); + isSubtype( + type, + parseType('num?'), + strT0: 'T & num?, T extends Object?', + strT1: 'num?', + ); + }); } test_typeParameter_38() { - var T = typeParameter('T', bound: numNone); - - isSubtype( - typeParameterTypeNone(T), - objectNone, - strT0: 'T, T extends num', - strT1: 'Object', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T'), + parseType('Object'), + strT0: 'T, T extends num', + strT1: 'Object', + ); + }); } test_typeParameter_39() { - var T = typeParameter('T', bound: numNone); - - isSubtype( - typeParameterTypeNone(T), - objectNone, - strT0: 'T, T extends num', - strT1: 'Object', - ); + withTypeParameterScope('T extends num', (scope) { + isSubtype( + scope.parseType('T'), + parseType('Object'), + strT0: 'T, T extends num', + strT1: 'Object', + ); + }); } test_typeParameter_40() { - var T = typeParameter('T', bound: numNone); - - isNotSubtype( - typeParameterTypeQuestion(T), - objectNone, - strT0: 'T?, T extends num', - strT1: 'Object', - ); + withTypeParameterScope('T extends num', (scope) { + isNotSubtype( + scope.parseType('T?'), + parseType('Object'), + strT0: 'T?, T extends num', + strT1: 'Object', + ); + }); } test_typeParameter_41() { - var T = typeParameter('T', bound: numQuestion); - - isNotSubtype( - typeParameterTypeNone(T), - objectNone, - strT0: 'T, T extends num?', - strT1: 'Object', - ); + withTypeParameterScope('T extends num?', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Object'), + strT0: 'T, T extends num?', + strT1: 'Object', + ); + }); } test_typeParameter_42() { - var T = typeParameter('T', bound: numQuestion); - - isNotSubtype( - typeParameterTypeQuestion(T), - objectNone, - strT0: 'T?, T extends num?', - strT1: 'Object', - ); + withTypeParameterScope('T extends num?', (scope) { + isNotSubtype( + scope.parseType('T?'), + parseType('Object'), + strT0: 'T?, T extends num?', + strT1: 'Object', + ); + }); } test_typeParameter_43() { - var T = typeParameter('T'); - - isNotSubtype( - typeParameterTypeNone(T), - objectNone, - strT0: 'T', - strT1: 'Object', - ); + withTypeParameterScope('T', (scope) { + isNotSubtype( + scope.parseType('T'), + parseType('Object'), + strT0: 'T', + strT1: 'Object', + ); + }); } @FailingTest(issue: 'https://github.com/dart-lang/language/issues/433') test_typeParameter_44() { - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); - var FutureOr_T_none = futureOrNone(T_none); - T.bound = FutureOr_T_none; + withTypeParameterScope('T extends FutureOr', (scope) { + isSubtype( + scope.parseType('T'), + scope.parseType('FutureOr'), + strT0: 'T, T extends FutureOr', + strT1: 'FutureOr, T extends FutureOr', + ); + }); + } - isSubtype( - T_none, - FutureOr_T_none, - strT0: 'T, T extends FutureOr', - strT1: 'FutureOr, T extends FutureOr', - ); + TypeImpl _parseTestType(String str) { + var type = parseType(str); + assertExpectedString(type, str); + return type; } } @reflectiveTest class SubtypingCompoundTest extends AbstractTypeSystemTest { test_double() { - var equivalents = [doubleNone]; - var supertypes = [numNone]; - var unrelated = [intNone]; + var equivalents = [parseType('double')]; + var supertypes = [parseType('num')]; + var unrelated = [parseType('int')]; _checkGroups( - doubleNone, + parseType('double'), equivalents: equivalents, supertypes: supertypes, unrelated: unrelated, @@ -4612,41 +3317,57 @@ class SubtypingCompoundTest extends AbstractTypeSystemTest { } test_dynamic() { - var equivalents = [voidNone, objectQuestion]; + var equivalents = [parseType('void'), parseType('Object?')]; - var subtypes = [neverNone, nullNone, objectNone]; + var subtypes = [ + parseType('Never'), + parseType('Null'), + parseType('Object'), + ]; - _checkGroups(dynamicType, equivalents: equivalents, subtypes: subtypes); + _checkGroups( + parseType('dynamic'), + equivalents: equivalents, + subtypes: subtypes, + ); } test_dynamic_isTop() { - var equivalents = [dynamicType, objectQuestion, voidNone]; - - var subtypes = [ - intNone, - doubleNone, - numNone, - stringNone, - functionNone, + var equivalents = [ + parseType('dynamic'), + parseType('Object?'), + parseType('void'), ]; - _checkGroups(dynamicType, equivalents: equivalents, subtypes: subtypes); + var subtypes = [ + parseType('int'), + parseType('double'), + parseType('num'), + parseType('String'), + parseType('Function'), + ]; + + _checkGroups( + parseType('dynamic'), + equivalents: equivalents, + subtypes: subtypes, + ); } test_futureOr_topTypes() { - var futureOrObject = futureOrNone(objectNone); - var futureOrObjectQuestion = futureOrNone(objectQuestion); + var futureOrObject = parseType('FutureOr'); + var futureOrObjectQuestion = parseType('FutureOr'); - var futureOrQuestionObject = futureOrQuestion(objectNone); - var futureOrQuestionObjectQuestion = futureOrQuestion(objectQuestion); + var futureOrQuestionObject = parseType('FutureOr?'); + var futureOrQuestionObjectQuestion = parseType('FutureOr?'); //FutureOr <: FutureOr* _checkGroups( futureOrObject, - equivalents: [objectNone], + equivalents: [parseType('Object')], subtypes: [], supertypes: [ - objectQuestion, + parseType('Object?'), futureOrQuestionObject, futureOrObjectQuestion, futureOrQuestionObject, @@ -4656,16 +3377,24 @@ class SubtypingCompoundTest extends AbstractTypeSystemTest { } test_intNone() { - var equivalents = [intNone]; + var equivalents = [parseType('int')]; - var subtypes = [neverNone]; + var subtypes = [parseType('Never')]; - var supertypes = [intQuestion, objectNone, objectQuestion]; + var supertypes = [ + parseType('int?'), + parseType('Object'), + parseType('Object?'), + ]; - var unrelated = [doubleNone, nullNone, neverQuestion]; + var unrelated = [ + parseType('double'), + parseType('Null'), + parseType('Never?'), + ]; _checkGroups( - intNone, + parseType('int'), equivalents: equivalents, supertypes: supertypes, unrelated: unrelated, @@ -4674,16 +3403,25 @@ class SubtypingCompoundTest extends AbstractTypeSystemTest { } test_intQuestion() { - var equivalents = [intQuestion]; + var equivalents = [parseType('int?')]; - var subtypes = [intNone, nullNone, neverNone, neverQuestion]; + var subtypes = [ + parseType('int'), + parseType('Null'), + parseType('Never'), + parseType('Never?'), + ]; - var supertypes = [numQuestion, objectQuestion]; + var supertypes = [parseType('num?'), parseType('Object?')]; - var unrelated = [doubleNone, numNone, objectNone]; + var unrelated = [ + parseType('double'), + parseType('num'), + parseType('Object'), + ]; _checkGroups( - intQuestion, + parseType('int?'), equivalents: equivalents, supertypes: supertypes, unrelated: unrelated, @@ -4692,18 +3430,23 @@ class SubtypingCompoundTest extends AbstractTypeSystemTest { } test_null() { - var equivalents = [nullNone, neverQuestion]; + var equivalents = [parseType('Null'), parseType('Never?')]; var supertypes = [ - intQuestion, - objectQuestion, - dynamicType, - voidNone, + parseType('int?'), + parseType('Object?'), + parseType('dynamic'), + parseType('void'), ]; - var subtypes = [neverNone]; + var subtypes = [parseType('Never')]; - var unrelated = [doubleNone, intNone, numNone, objectNone]; + var unrelated = [ + parseType('double'), + parseType('int'), + parseType('num'), + parseType('Object'), + ]; for (var formOfNull in equivalents) { _checkGroups( @@ -4717,12 +3460,12 @@ class SubtypingCompoundTest extends AbstractTypeSystemTest { } test_numNone() { - var equivalents = [numNone]; - var supertypes = [objectNone]; - var unrelated = [stringNone]; - var subtypes = [intNone, doubleNone]; + var equivalents = [parseType('num')]; + var supertypes = [parseType('Object')]; + var unrelated = [parseType('String')]; + var subtypes = [parseType('int'), parseType('double')]; _checkGroups( - numNone, + parseType('num'), equivalents: equivalents, supertypes: supertypes, unrelated: unrelated, @@ -4733,19 +3476,23 @@ class SubtypingCompoundTest extends AbstractTypeSystemTest { test_object() { var equivalents = []; - var supertypes = [objectQuestion, dynamicType, voidNone]; + var supertypes = [ + parseType('Object?'), + parseType('dynamic'), + parseType('void'), + ]; - var subtypes = [neverNone]; + var subtypes = [parseType('Never')]; var unrelated = [ - doubleQuestion, - numQuestion, - intQuestion, - nullNone, + parseType('double?'), + parseType('num?'), + parseType('int?'), + parseType('Null'), ]; _checkGroups( - objectNone, + parseType('Object'), equivalents: equivalents, supertypes: supertypes, unrelated: unrelated, diff --git a/pkg/analyzer/test/src/dart/element/top_merge_test.dart b/pkg/analyzer/test/src/dart/element/top_merge_test.dart index e24f4cdbccd..0cd8203786a 100644 --- a/pkg/analyzer/test/src/dart/element/top_merge_test.dart +++ b/pkg/analyzer/test/src/dart/element/top_merge_test.dart @@ -17,331 +17,231 @@ main() { @reflectiveTest class TopMergeTest extends AbstractTypeSystemTest { test_differentStructure() { - _checkThrows(intNone, functionTypeNone(returnType: voidNone)); + _checkThrows(parseType('int'), parseType('void Function()')); - _checkThrows(intNone, typeParameterTypeNone(typeParameter('T'))); - - _checkThrows( - functionTypeNone(returnType: voidNone), - typeParameterTypeNone(typeParameter('T')), - ); + withTypeParameterScope('T', (scope) { + _checkThrows(parseType('int'), scope.parseType('T')); + _checkThrows(parseType('void Function()'), scope.parseType('T')); + }); } test_dynamic() { // NNBD_TOP_MERGE(dynamic, dynamic) = dynamic - _check(dynamicType, dynamicType, dynamicType); + _check(parseType('dynamic'), parseType('dynamic'), parseType('dynamic')); } test_function_formalParameters_differentCount() { _checkThrows( - functionTypeNone(returnType: voidNone, formalParameters: []), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone)], - ), + parseFunctionType('void Function()'), + parseFunctionType('void Function(int)'), ); } test_function_parameters_covariant() { _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - requiredParameter(type: objectQuestion, isCovariant: true), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: dynamicType)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [ - requiredParameter(type: objectQuestion, isCovariant: true), - ], - ), + parseFunctionType('void Function(covariant Object?)'), + parseFunctionType('void Function(dynamic)'), + parseFunctionType('void Function(covariant Object?)'), ); _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone, isCovariant: true)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: numNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: numNone, isCovariant: true)], - ), + parseFunctionType('void Function(covariant int)'), + parseFunctionType('void Function(num)'), + parseFunctionType('void Function(covariant num)'), ); } test_function_parameters_kind_optionalPositional_optionalPositional() { _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: intNone)], - ), + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), ); } test_function_parameters_kind_requiredNamed_optionalNamed() { _checkThrows( - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(type: intNone, name: 'a')], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(type: intNone, name: 'a')], - ), + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function({int a})'), ); } test_function_parameters_kind_requiredPositional_optionalPositional() { _checkThrows( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: intNone)], - ), + parseFunctionType('void Function(int)'), + parseFunctionType('void Function([int])'), ); _checkThrows( - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(type: intNone, name: 'a')], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(type: intNone, name: 'b')], - ), + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int b})'), ); } test_function_parameters_mismatch() { _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone, name: 'a')], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone, name: 'b')], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone, name: 'a')], - ), + parseFunctionType('void Function(int a)'), + parseFunctionType('void Function(int b)'), + parseFunctionType('void Function(int a)'), ); } test_function_parameters_type() { _check( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: objectQuestion, name: 'a')], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: dynamicType, name: 'a')], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: objectQuestion, name: 'a')], - ), + parseFunctionType('void Function(Object? a)'), + parseFunctionType('void Function(dynamic a)'), + parseFunctionType('void Function(Object? a)'), ); } test_function_returnType() { _check( - functionTypeNone(returnType: voidNone), - functionTypeNone(returnType: objectQuestion), - functionTypeNone(returnType: objectQuestion), + parseFunctionType('void Function()'), + parseFunctionType('Object? Function()'), + parseFunctionType('Object? Function()'), ); } test_function_typeParameters_boundsMerge() { - var T1 = typeParameter('T', bound: dynamicType); - var T2 = typeParameter('T', bound: objectQuestion); - var TR = typeParameter('T', bound: objectQuestion); _check( - functionTypeNone( - typeParameters: [T1], - returnType: typeParameterTypeNone(T1), - ), - functionTypeNone( - typeParameters: [T2], - returnType: typeParameterTypeNone(T2), - ), - functionTypeNone( - typeParameters: [TR], - returnType: typeParameterTypeNone(TR), - ), + parseFunctionType('T Function()'), + parseFunctionType('T Function()'), + parseFunctionType('T Function()'), ); } test_function_typeParameters_boundsMismatch() { - var T1 = typeParameter('T', bound: intNone); - var T2 = typeParameter('T'); _checkThrows( - functionTypeNone( - typeParameters: [T1], - returnType: typeParameterTypeNone(T1), - ), - functionTypeNone( - typeParameters: [T2], - returnType: typeParameterTypeNone(T2), - ), + parseFunctionType('T Function()'), + parseFunctionType('T Function()'), ); } test_function_typeParameters_differentCount() { - var T = typeParameter('T'); - var S = typeParameter('S'); _checkThrows( - functionTypeNone(returnType: voidNone), - functionTypeNone(typeParameters: [T, S], returnType: voidNone), + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), ); } test_interface() { _check( - listNone(dynamicType), - listNone(objectQuestion), - listNone(objectQuestion), + parseType('List'), + parseType('List'), + parseType('List'), ); _check( - listNone(voidNone), - listNone(objectQuestion), - listNone(objectQuestion), + parseType('List'), + parseType('List'), + parseType('List'), ); - _checkThrows(iterableNone(intNone), listNone(intNone)); + _checkThrows(parseType('Iterable'), parseType('List')); } test_invalid() { - _check(invalidType, intNone, invalidType); - _check(intNone, invalidType, invalidType); + _check( + parseType('InvalidType'), + parseType('int'), + parseType('InvalidType'), + ); + _check( + parseType('int'), + parseType('InvalidType'), + parseType('InvalidType'), + ); } test_never() { - _check(neverNone, neverNone, neverNone); + _check(parseType('Never'), parseType('Never'), parseType('Never')); } test_nullability() { // NNBD_TOP_MERGE(T?, S?) = NNBD_TOP_MERGE(T, S)? - _check(intQuestion, intQuestion, intQuestion); + _check(parseType('int?'), parseType('int?'), parseType('int?')); } test_nullability_mismatch() { - _checkThrows(intQuestion, intNone); + _checkThrows(parseType('int?'), parseType('int')); } test_objectQuestion() { // NNBD_TOP_MERGE(Object?, Object?) = Object? - _check(objectQuestion, objectQuestion, objectQuestion); + _check(parseType('Object?'), parseType('Object?'), parseType('Object?')); // NNBD_TOP_MERGE(Object?, void) = Object? // NNBD_TOP_MERGE(void, Object?) = Object? - _check(objectQuestion, voidNone, objectQuestion); + _check(parseType('Object?'), parseType('void'), parseType('Object?')); // NNBD_TOP_MERGE(Object?, dynamic) = Object? // NNBD_TOP_MERGE(dynamic, Object?) = Object? - _check(objectQuestion, dynamicType, objectQuestion); + _check(parseType('Object?'), parseType('dynamic'), parseType('Object?')); } test_record() { _check( - recordTypeNone(positionalTypes: [dynamicType]), - recordTypeNone(positionalTypes: [objectQuestion]), - recordTypeNone(positionalTypes: [objectQuestion]), + parseRecordType('(dynamic,)'), + parseRecordType('(Object?,)'), + parseRecordType('(Object?,)'), ); _check( - recordTypeNone(positionalTypes: [voidNone]), - recordTypeNone(positionalTypes: [objectQuestion]), - recordTypeNone(positionalTypes: [objectQuestion]), + parseRecordType('(void,)'), + parseRecordType('(Object?,)'), + parseRecordType('(Object?,)'), ); _check( - recordTypeNone(namedTypes: {'f': dynamicType}), - recordTypeNone(namedTypes: {'f': objectQuestion}), - recordTypeNone(namedTypes: {'f': objectQuestion}), + parseRecordType('({dynamic f})'), + parseRecordType('({Object? f})'), + parseRecordType('({Object? f})'), ); _check( - recordTypeNone( - positionalTypes: [dynamicType], - namedTypes: {'f': voidNone}, - ), - recordTypeNone( - positionalTypes: [objectQuestion], - namedTypes: {'f': objectQuestion}, - ), - recordTypeNone( - positionalTypes: [objectQuestion], - namedTypes: {'f': objectQuestion}, - ), + parseRecordType('(dynamic, {void f})'), + parseRecordType('(Object?, {Object? f})'), + parseRecordType('(Object?, {Object? f})'), ); } test_record_namedFields_differentCount() { _checkThrows( - recordTypeNone(namedTypes: {'a': intNone}), - recordTypeNone(namedTypes: {'a': intNone, 'b': intNone}), + parseRecordType('({int a})'), + parseRecordType('({int a, int b})'), ); } test_record_namedFields_differentNames() { - _checkThrows( - recordTypeNone(namedTypes: {'a': intNone}), - recordTypeNone(namedTypes: {'b': intNone}), - ); + _checkThrows(parseRecordType('({int a})'), parseRecordType('({int b})')); } test_record_positionalFields_differentCount() { - _checkThrows( - recordTypeNone(positionalTypes: [intNone]), - recordTypeNone(positionalTypes: [intNone, intNone]), - ); + _checkThrows(parseRecordType('(int,)'), parseRecordType('(int, int)')); } test_typeParameter() { - var T = typeParameter('T'); + withTypeParameterScope('T', (scope1) { + _check( + scope1.parseType('T'), + scope1.parseType('T'), + scope1.parseType('T'), + ); - _check( - typeParameterTypeNone(T), - typeParameterTypeNone(T), - typeParameterTypeNone(T), - ); - - var S = typeParameter('T'); - _checkThrows(typeParameterTypeNone(T), typeParameterTypeNone(S)); - _checkThrows(typeParameterTypeNone(S), typeParameterTypeNone(T)); + withTypeParameterScope('T', (scope2) { + _checkThrows(scope1.parseType('T'), scope2.parseType('T')); + _checkThrows(scope2.parseType('T'), scope1.parseType('T')); + }); + }); } test_void() { // NNBD_TOP_MERGE(void, void) = void - _check(voidNone, voidNone, voidNone); + _check(parseType('void'), parseType('void'), parseType('void')); // NNBD_TOP_MERGE(void, dynamic) = Object? // NNBD_TOP_MERGE(dynamic, void) = Object? - _check(voidNone, dynamicType, objectQuestion); + _check(parseType('void'), parseType('dynamic'), parseType('Object?')); } void _check(TypeImpl T, TypeImpl S, TypeImpl expected) { diff --git a/pkg/analyzer/test/src/dart/element/type_algebra_test.dart b/pkg/analyzer/test/src/dart/element/type_algebra_test.dart index 987974e861e..7533020dd3e 100644 --- a/pkg/analyzer/test/src/dart/element/type_algebra_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_algebra_test.dart @@ -47,31 +47,36 @@ DartType substitute( @reflectiveTest class MapSubstitutionTest extends _Base { test_andThen_empty_andThenNotEmpty() { - var T = typeParameter('T'); - var after = Substitution.fromMap({T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var after = Substitution.fromMap({T: scope.parseType('int')}); - var combined = Substitution.empty.andThen(after); - expect(combined, same(Substitution.empty)); + var combined = Substitution.empty.andThen(after); + expect(combined, same(Substitution.empty)); + }); } test_andThen_notEmpty_andThenEmpty() { - var T = typeParameter('T'); - var inner = Substitution.fromMap({T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var inner = Substitution.fromMap({T: scope.parseType('int')}); - var combined = inner.andThen(Substitution.empty); - expect(combined, same(inner)); + var combined = inner.andThen(Substitution.empty); + expect(combined, same(inner)); + }); } test_andThen_notEmpty_andThenNotEmpty() { - var T = typeParameter('T'); - var G = typeParameter('G'); + withTypeParameterScope('T, G', (scope) { + var T = scope.typeParameter('T'); + var G = scope.typeParameter('G'); + var inner = Substitution.fromMap({T: scope.parseType('List')}); + var after = Substitution.fromMap({G: parseType('String')}); - var inner = Substitution.fromMap({T: listNone(typeParameterTypeNone(G))}); - var after = Substitution.fromMap({G: stringNone}); - - var combined = inner.andThen(after); - var result = combined.substituteType(typeParameterTypeNone(T)); - assertType(result, 'List'); + var combined = inner.andThen(after); + var result = combined.substituteType(scope.parseType('T')); + assertType(result, 'List'); + }); } } @@ -80,9 +85,8 @@ class SubstituteEmptyTest extends _Base { test_interface() async { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var type = interfaceTypeNone(A, typeArguments: [intNone]); + var type = parseType('A'); var result = Substitution.empty.substituteType(type); expect(result, same(type)); @@ -91,61 +95,66 @@ class SubstituteEmptyTest extends _Base { @reflectiveTest class SubstituteFromInterfaceTypeTest extends _Base { - test_interface() async { - // class A {} + test_methodReturnType() async { buildTestLibrary( - classes: [ClassSpec('class A'), ClassSpec('class B')], + classes: [ + ClassSpec('class A', methods: [MethodSpec('List foo()')]), + ], ); - var A = classElement('A'); - // class B {} - var B = classElement('B'); - var U = B.typeParameters.single; + var substitution = Substitution.fromInterfaceType( + parseInterfaceType('A'), + ); - var BofInt = interfaceTypeNone(B, typeArguments: [intNone]); - var substitution = Substitution.fromInterfaceType(BofInt); - - // A - var type = interfaceTypeNone(A, typeArguments: [typeParameterTypeNone(U)]); - assertType(type, 'A'); + var type = classElement('A').getMethod('foo')!.returnType; + assertType(type, 'List'); var result = substitution.substituteType(type); - assertType(result, 'A'); + assertType(result, 'List'); } } @reflectiveTest class SubstituteFromPairsTest extends _Base { - test_interface() async { - // class A {} - buildTestLibrary(classes: [ClassSpec('class A')]); + test_methodReturnType() async { + buildTestLibrary( + classes: [ + ClassSpec('class A', methods: [MethodSpec('Map foo()')]), + ], + ); var A = classElement('A'); var T = A.typeParameters[0]; var U = A.typeParameters[1]; - var type = interfaceTypeNone( - A, - typeArguments: [typeParameterTypeNone(T), typeParameterTypeNone(U)], - ); + var type = A.getMethod('foo')!.returnType; + assertType(type, 'Map'); var result = Substitution.fromPairs2( [T, U], - [intNone, doubleNone], + [parseType('int'), parseType('double')], ).substituteType(type); - assertType(result, 'A'); + assertType(result, 'Map'); } } @reflectiveTest class SubstituteTest extends _Base { test_bottom() async { - var T = typeParameter('T'); - _assertIdenticalType(typeProvider.bottomType, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(typeProvider.bottomType, { + T: scope.parseType('int'), + }); + }); } test_dynamic() async { - var T = typeParameter('T'); - _assertIdenticalType(typeProvider.dynamicType, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(typeProvider.dynamicType, { + T: scope.parseType('int'), + }); + }); } test_function_fromAlias_hasRef() async { @@ -153,15 +162,15 @@ class SubstituteTest extends _Base { buildTestLibrary( typeAliases: [TypeAliasSpec('typedef Alias = void Function()')], ); - var Alias = typeAliasElement('Alias'); - var U = typeParameter('U'); - var type = typeAliasTypeNone( - Alias, - typeArguments: [typeParameterTypeNone(U)], - ); - assertType(type, 'void Function() via Alias'); - _assertSubstitution(type, {U: intNone}, 'void Function() via Alias'); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('Alias'); + assertType(type, 'void Function() via Alias'); + _assertSubstitution(type, { + U: parseType('int'), + }, 'void Function() via Alias'); + }); } test_function_fromAlias_noRef() async { @@ -169,13 +178,14 @@ class SubstituteTest extends _Base { buildTestLibrary( typeAliases: [TypeAliasSpec('typedef Alias = void Function()')], ); - var Alias = typeAliasElement('Alias'); - var type = typeAliasTypeNone(Alias, typeArguments: [doubleNone]); + var type = parseType('Alias'); assertType(type, 'void Function() via Alias'); - var U = typeParameter('U'); - _assertIdenticalType(type, {U: intNone}); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + _assertIdenticalType(type, {U: scope.parseType('int')}); + }); } test_function_fromAlias_noTypeParameters() async { @@ -183,141 +193,123 @@ class SubstituteTest extends _Base { buildTestLibrary( typeAliases: [TypeAliasSpec('typedef Alias = void Function()')], ); - var Alias = typeAliasElement('Alias'); - var type = typeAliasTypeNone(Alias, typeArguments: [intNone]); + var type = parseType('Alias'); assertType(type, 'void Function() via Alias'); - var U = typeParameter('U'); - _assertIdenticalType(type, {U: intNone}); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + _assertIdenticalType(type, {U: scope.parseType('int')}); + }); } test_function_noSubstitutions() async { - var type = functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: boolNone, - ); + var type = parseType('bool Function(int)'); - var T = typeParameter('T'); - _assertIdenticalType(type, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(type, {T: scope.parseType('int')}); + }); } test_function_parameters_returnType() async { // typedef F = T Function(U u, bool); - var T = typeParameter('T'); - var U = typeParameter('U'); - var type = functionTypeNone( - formalParameters: [ - requiredParameter(type: typeParameterTypeNone(U)), - requiredParameter(type: boolNone), - ], - returnType: typeParameterTypeNone(T), - ); + withTypeParameterScope('T, U', (scope) { + var T = scope.typeParameter('T'); + var U = scope.typeParameter('U'); + var type = scope.parseType('T Function(U, bool)'); - assertType(type, 'T Function(U, bool)'); - _assertSubstitution(type, {T: intNone}, 'int Function(U, bool)'); - _assertSubstitution(type, { - T: intNone, - U: doubleNone, - }, 'int Function(double, bool)'); + assertType(type, 'T Function(U, bool)'); + _assertSubstitution(type, {T: parseType('int')}, 'int Function(U, bool)'); + _assertSubstitution(type, { + T: parseType('int'), + U: parseType('double'), + }, 'int Function(double, bool)'); + }); } test_function_typeFormals() async { // typedef F = T Function(U); - var T = typeParameter('T'); - var U = typeParameter('U', bound: typeParameterTypeNone(T)); - var type = functionTypeNone( - typeParameters: [U], - formalParameters: [requiredParameter(type: typeParameterTypeNone(U))], - returnType: typeParameterTypeNone(T), - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var type = scope.parseType('T Function(U)'); - assertType(type, 'T Function(U)'); - _assertSubstitution(type, {T: intNone}, 'int Function(U)'); + assertType(type, 'T Function(U)'); + _assertSubstitution(type, { + T: parseType('int'), + }, 'int Function(U)'); + }); } test_function_typeFormals_bounds() async { // class Triple {} // typedef F = bool Function, U>(); buildTestLibrary(classes: [ClassSpec('class Triple')]); - var classTriple = classElement('Triple'); - var T = typeParameter('T'); - var U = typeParameter('U'); - var V = typeParameter('V'); + withTypeParameterScope('V', (scope) { + var V = scope.typeParameter('V'); + var type = scope.parseType( + 'bool Function, U>()', + ); - T.bound = interfaceTypeNone( - classTriple, - typeArguments: [ - typeParameterTypeNone(T), - typeParameterTypeNone(U), - typeParameterTypeNone(V), - ], - ); + assertType(type, 'bool Function, U>()'); - var type = functionTypeNone(typeParameters: [T, U], returnType: boolNone); - - assertType(type, 'bool Function, U>()'); - - var result = substitute(type, {V: intNone}) as FunctionType; - assertType(result, 'bool Function, U>()'); - var T2 = result.typeParameters[0]; - var U2 = result.typeParameters[1]; - var T2boundArgs = (T2.bound as InterfaceType).typeArguments; - expect((T2boundArgs[0] as TypeParameterType).element, same(T2)); - expect((T2boundArgs[1] as TypeParameterType).element, same(U2)); + var result = substitute(type, {V: parseType('int')}) as FunctionType; + assertType(result, 'bool Function, U>()'); + var T2 = result.typeParameters[0]; + var U2 = result.typeParameters[1]; + var T2boundArgs = (T2.bound as InterfaceType).typeArguments; + expect((T2boundArgs[0] as TypeParameterType).element, same(T2)); + expect((T2boundArgs[1] as TypeParameterType).element, same(U2)); + }); } test_interface_arguments() async { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var U = typeParameter('U'); - var type = interfaceTypeNone(A, typeArguments: [typeParameterTypeNone(U)]); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('A'); - assertType(type, 'A'); - _assertSubstitution(type, {U: intNone}, 'A'); + assertType(type, 'A'); + _assertSubstitution(type, {U: parseType('int')}, 'A'); + }); } test_interface_arguments_deep() async { buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var U = typeParameter('U'); - var type = interfaceTypeNone( - A, - typeArguments: [ - interfaceTypeNone( - typeProvider.listElement, - typeArguments: [typeParameterTypeNone(U)], - ), - ], - ); - assertType(type, 'A>'); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('A>'); + assertType(type, 'A>'); - _assertSubstitution(type, {U: intNone}, 'A>'); + _assertSubstitution(type, {U: parseType('int')}, 'A>'); + }); } test_interface_noArguments() async { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var type = interfaceTypeNone(A); - var T = typeParameter('T'); - _assertIdenticalType(type, {T: intNone}); + var type = parseInterfaceType('A'); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(type, {T: scope.parseType('int')}); + }); } test_interface_noArguments_inArguments() async { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var type = interfaceTypeNone(A, typeArguments: [intNone]); + var type = parseInterfaceType('A'); - var U = typeParameter('U'); - _assertIdenticalType(type, {U: doubleNone}); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + _assertIdenticalType(type, {U: scope.parseType('double')}); + }); } test_interface_noTypeParameters_fromAlias_hasRef() async { @@ -326,15 +318,13 @@ class SubstituteTest extends _Base { classes: [ClassSpec('class A')], typeAliases: [TypeAliasSpec('typedef Alias = A')], ); - var Alias = typeAliasElement('Alias'); - var U = typeParameter('U'); - var type = typeAliasTypeNone( - Alias, - typeArguments: [typeParameterTypeNone(U)], - ); - assertType(type, 'A via Alias'); - _assertSubstitution(type, {U: intNone}, 'A via Alias'); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('Alias'); + assertType(type, 'A via Alias'); + _assertSubstitution(type, {U: parseType('int')}, 'A via Alias'); + }); } test_interface_noTypeParameters_fromAlias_noRef() async { @@ -343,13 +333,14 @@ class SubstituteTest extends _Base { classes: [ClassSpec('class A')], typeAliases: [TypeAliasSpec('typedef Alias = A')], ); - var Alias = typeAliasElement('Alias'); - var type = typeAliasTypeNone(Alias, typeArguments: [doubleNone]); + var type = parseType('Alias'); assertType(type, 'A via Alias'); - var U = typeParameter('U'); - _assertIdenticalType(type, {U: intNone}); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + _assertIdenticalType(type, {U: scope.parseType('int')}); + }); } test_interface_noTypeParameters_fromAlias_noTypeParameters() async { @@ -358,27 +349,34 @@ class SubstituteTest extends _Base { classes: [ClassSpec('class A')], typeAliases: [TypeAliasSpec('typedef Alias = A')], ); - var Alias = typeAliasElement('Alias'); - var type = typeAliasTypeNone(Alias); + var type = parseType('Alias'); assertType(type, 'A via Alias'); - var T = typeParameter('T'); - _assertIdenticalType(type, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(type, {T: scope.parseType('int')}); + }); } test_invalid() async { - var T = typeParameter('T'); - _assertIdenticalType(InvalidTypeImpl.instance, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(InvalidTypeImpl.instance, { + T: scope.parseType('int'), + }); + }); } test_record_doesNotUseTypeParameter2() async { - var T = typeParameter('T'); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - var type = recordTypeNone(positionalTypes: [intNone]); + var type = parseRecordType('(int,)'); + assertType(type, '(int,)'); - assertType(type, '(int,)'); - _assertIdenticalType(type, {T: intNone}); + _assertIdenticalType(type, {T: scope.parseType('int')}); + }); } test_record_fromAlias() async { @@ -386,15 +384,15 @@ class SubstituteTest extends _Base { buildTestLibrary( typeAliases: [TypeAliasSpec('typedef Alias = (int, String)')], ); - var Alias = typeAliasElement('Alias'); - var U = typeParameter('U'); - var type = typeAliasTypeNone( - Alias, - typeArguments: [typeParameterTypeNone(U)], - ); - assertType(type, '(int, String) via Alias'); - _assertSubstitution(type, {U: intNone}, '(int, String) via Alias'); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('Alias'); + assertType(type, '(int, String) via Alias'); + _assertSubstitution(type, { + U: parseType('int'), + }, '(int, String) via Alias'); + }); } test_record_fromAlias2() async { @@ -402,68 +400,70 @@ class SubstituteTest extends _Base { buildTestLibrary( typeAliases: [TypeAliasSpec('typedef Alias = (T, List)')], ); - var Alias = typeAliasElement('Alias'); - var type = typeAliasTypeNone(Alias, typeArguments: [intNone]); + var type = parseType('Alias'); assertType(type, '(int, List) via Alias'); } test_record_named() async { - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var type = scope.parseType('({T f1, List f2})'); - var type = recordTypeNone( - namedTypes: {'f1': T_none, 'f2': listNone(T_none)}, - ); - - assertType(type, '({T f1, List f2})'); - _assertSubstitution(type, {T: intNone}, '({int f1, List f2})'); + assertType(type, '({T f1, List f2})'); + _assertSubstitution(type, { + T: parseType('int'), + }, '({int f1, List f2})'); + }); } test_record_positional() async { - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var type = scope.parseType('(T, List)'); - var type = recordTypeNone(positionalTypes: [T_none, listNone(T_none)]); - - assertType(type, '(T, List)'); - _assertSubstitution(type, {T: intNone}, '(int, List)'); + assertType(type, '(T, List)'); + _assertSubstitution(type, {T: parseType('int')}, '(int, List)'); + }); } test_typeParameter_nullability() async { - var tElement = typeParameter('T'); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - void check( - NullabilitySuffix typeParameterNullability, - InterfaceType typeArgument, - InterfaceType expectedType, - ) { - var result = Substitution.fromMap({tElement: typeArgument}) - .substituteType( - tElement.instantiate(nullabilitySuffix: typeParameterNullability), - ); - expect(result, expectedType); - } + void check(String type, DartType typeArgument, DartType expectedType) { + var result = Substitution.fromMap({ + T: typeArgument, + }).substituteType(scope.parseType(type)); + expect(result, expectedType); + } - check(NullabilitySuffix.none, intNone, intNone); - check(NullabilitySuffix.none, intQuestion, intQuestion); + check('T', parseType('int'), parseType('int')); + check('T', parseType('int?'), parseType('int?')); - check(NullabilitySuffix.question, intNone, intQuestion); - check(NullabilitySuffix.question, intQuestion, intQuestion); + check('T?', parseType('int'), parseType('int?')); + check('T?', parseType('int?'), parseType('int?')); + }); } test_unknownInferredType() async { - var T = typeParameter('T'); - _assertIdenticalType(UnknownInferredType.instance, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(UnknownInferredType.instance, { + T: scope.parseType('int'), + }); + }); } test_void() async { - var T = typeParameter('T'); - _assertIdenticalType(typeProvider.voidType, {T: intNone}); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _assertIdenticalType(typeProvider.voidType, {T: scope.parseType('int')}); + }); } test_void_emptyMap() async { - _assertIdenticalType(intNone, {}); + _assertIdenticalType(parseType('int'), {}); } void _assertIdenticalType( @@ -482,27 +482,23 @@ class SubstituteWithNullabilityTest extends _Base { test_interface_none() async { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var U = typeParameter('U'); - var type = A.instantiateImpl( - typeArguments: [U.instantiate(nullabilitySuffix: NullabilitySuffix.none)], - nullabilitySuffix: NullabilitySuffix.none, - ); - _assertSubstitution(type, {U: intNone}, 'A'); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('A'); + _assertSubstitution(type, {U: parseType('int')}, 'A'); + }); } test_interface_question() async { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - var U = typeParameter('U'); - var type = A.instantiateImpl( - typeArguments: [U.instantiate(nullabilitySuffix: NullabilitySuffix.none)], - nullabilitySuffix: NullabilitySuffix.question, - ); - _assertSubstitution(type, {U: intNone}, 'A?'); + withTypeParameterScope('U', (scope) { + var U = scope.typeParameter('U'); + var type = scope.parseType('A?'); + _assertSubstitution(type, {U: parseType('int')}, 'A?'); + }); } test_withNullability_updatesAlias_function() { @@ -550,15 +546,16 @@ class SubstituteWithNullabilityTest extends _Base { buildTestLibrary(typeAliases: [TypeAliasSpec('typedef A = T')]); var alias = typeAliasElement('A'); - var U = typeParameter('U'); - var type = alias.instantiateImpl( - typeArguments: [typeParameterTypeNone(U)], - nullabilitySuffix: NullabilitySuffix.question, - ); + withTypeParameterScope('U', (scope) { + var type = alias.instantiateImpl( + typeArguments: [scope.parseType('U')], + nullabilitySuffix: NullabilitySuffix.question, + ); - var result = type.withNullability(NullabilitySuffix.none); - expect(result.alias, isNotNull); - expect(result.alias?.nullabilitySuffix, NullabilitySuffix.none); + var result = type.withNullability(NullabilitySuffix.none); + expect(result.alias, isNotNull); + expect(result.alias?.nullabilitySuffix, NullabilitySuffix.none); + }); } } diff --git a/pkg/analyzer/test/src/dart/element/type_bounded_test.dart b/pkg/analyzer/test/src/dart/element/type_bounded_test.dart index 3feb1d17544..7f49d885ea3 100644 --- a/pkg/analyzer/test/src/dart/element/type_bounded_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_bounded_test.dart @@ -19,57 +19,57 @@ main() { @reflectiveTest class DynamicBoundedTest extends AbstractTypeSystemTest { test_dynamic() { - _assertDynamicBounded(dynamicType); + _assertDynamicBounded(parseType('dynamic')); } test_dynamic_typeParameter_hasBound_dynamic() { - var T = typeParameter('T', bound: dynamicType); - - _assertDynamicBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends dynamic', (scope) { + _assertDynamicBounded(scope.parseType('T')); + }); } test_dynamic_typeParameter_hasBound_notDynamic() { - var T = typeParameter('T', bound: intNone); - - _assertNotDynamicBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends int', (scope) { + _assertNotDynamicBounded(scope.parseType('T')); + }); } test_dynamic_typeParameter_hasPromotedBound_dynamic() { - var T = typeParameter('T'); - - _assertDynamicBounded(typeParameterTypeNone(T, promotedBound: dynamicType)); + withTypeParameterScope('T', (scope) { + _assertDynamicBounded(scope.parseType('T & dynamic')); + }); } test_dynamic_typeParameter_hasPromotedBound_notDynamic() { - var T = typeParameter('T'); - - _assertNotDynamicBounded(typeParameterTypeNone(T, promotedBound: intNone)); + withTypeParameterScope('T', (scope) { + _assertNotDynamicBounded(scope.parseType('T & int')); + }); } test_dynamic_typeParameter_noBound() { - var T = typeParameter('T'); - - _assertNotDynamicBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T', (scope) { + _assertNotDynamicBounded(scope.parseType('T')); + }); } test_functionType() { - _assertNotDynamicBounded(functionTypeNone(returnType: voidNone)); + _assertNotDynamicBounded(parseType('void Function()')); - _assertNotDynamicBounded(functionTypeNone(returnType: dynamicType)); + _assertNotDynamicBounded(parseType('dynamic Function()')); } test_interfaceType() { - _assertNotDynamicBounded(intNone); - _assertNotDynamicBounded(intQuestion); + _assertNotDynamicBounded(parseType('int')); + _assertNotDynamicBounded(parseType('int?')); } test_never() { - _assertNotDynamicBounded(neverNone); - _assertNotDynamicBounded(neverQuestion); + _assertNotDynamicBounded(parseType('Never')); + _assertNotDynamicBounded(parseType('Never?')); } test_void() { - _assertNotDynamicBounded(voidNone); + _assertNotDynamicBounded(parseType('void')); } void _assertDynamicBounded(DartType type) { @@ -84,83 +84,70 @@ class DynamicBoundedTest extends AbstractTypeSystemTest { @reflectiveTest class FunctionBoundedTest extends AbstractTypeSystemTest { test_dynamic() { - _assertNotFunctionBounded(dynamicType); + _assertNotFunctionBounded(parseType('dynamic')); } test_dynamic_typeParameter_hasBound_functionType_none() { - var T = typeParameter('T', bound: functionTypeNone(returnType: voidNone)); - - _assertFunctionBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends void Function()', (scope) { + _assertFunctionBounded(scope.parseType('T')); + }); } test_dynamic_typeParameter_hasBound_functionType_question() { - var T = typeParameter( - 'T', - bound: functionTypeQuestion(returnType: voidNone), - ); - - _assertNotFunctionBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends void Function()?', (scope) { + _assertNotFunctionBounded(scope.parseType('T')); + }); } test_dynamic_typeParameter_hasBound_notFunction() { - var T = typeParameter('T', bound: intNone); - - _assertNotFunctionBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends int', (scope) { + _assertNotFunctionBounded(scope.parseType('T')); + }); } test_dynamic_typeParameter_hasPromotedBound_functionType_none() { - var T = typeParameter('T'); - - _assertFunctionBounded( - typeParameterTypeNone( - T, - promotedBound: functionTypeNone(returnType: voidNone), - ), - ); + withTypeParameterScope('T', (scope) { + _assertFunctionBounded(scope.parseType('T & void Function()')); + }); } test_dynamic_typeParameter_hasPromotedBound_functionType_question() { - var T = typeParameter('T'); - - _assertNotFunctionBounded( - typeParameterTypeNone( - T, - promotedBound: functionTypeQuestion(returnType: voidNone), - ), - ); + withTypeParameterScope('T', (scope) { + _assertNotFunctionBounded(scope.parseType('T & void Function()?')); + }); } test_dynamic_typeParameter_hasPromotedBound_notFunction() { - var T = typeParameter('T'); - - _assertNotFunctionBounded(typeParameterTypeNone(T, promotedBound: intNone)); + withTypeParameterScope('T', (scope) { + _assertNotFunctionBounded(scope.parseType('T & int')); + }); } test_dynamic_typeParameter_noBound() { - var T = typeParameter('T'); - - _assertNotFunctionBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T', (scope) { + _assertNotFunctionBounded(scope.parseType('T')); + }); } test_functionType() { - _assertFunctionBounded(functionTypeNone(returnType: voidNone)); - _assertNotFunctionBounded(functionTypeQuestion(returnType: voidNone)); + _assertFunctionBounded(parseType('void Function()')); + _assertNotFunctionBounded(parseType('void Function()?')); - _assertFunctionBounded(functionTypeNone(returnType: dynamicType)); + _assertFunctionBounded(parseType('dynamic Function()')); } test_interfaceType() { - _assertNotFunctionBounded(intNone); - _assertNotFunctionBounded(intQuestion); + _assertNotFunctionBounded(parseType('int')); + _assertNotFunctionBounded(parseType('int?')); } test_never() { - _assertNotFunctionBounded(neverNone); - _assertNotFunctionBounded(neverQuestion); + _assertNotFunctionBounded(parseType('Never')); + _assertNotFunctionBounded(parseType('Never?')); } test_void() { - _assertNotFunctionBounded(voidNone); + _assertNotFunctionBounded(parseType('void')); } void _assertFunctionBounded(DartType type) { @@ -175,57 +162,57 @@ class FunctionBoundedTest extends AbstractTypeSystemTest { @reflectiveTest class InvalidBoundedTest extends AbstractTypeSystemTest { test_dynamic_typeParameter_hasPromotedBound_notDynamic() { - var T = typeParameter('T'); - - _assertNotInvalidBounded(typeParameterTypeNone(T, promotedBound: intNone)); + withTypeParameterScope('T', (scope) { + _assertNotInvalidBounded(scope.parseType('T & int')); + }); } test_functionType() { - _assertNotInvalidBounded(functionTypeNone(returnType: voidNone)); + _assertNotInvalidBounded(parseType('void Function()')); - _assertNotInvalidBounded(functionTypeNone(returnType: invalidType)); + _assertNotInvalidBounded(parseType('InvalidType Function()')); } test_interfaceType() { - _assertNotInvalidBounded(intNone); - _assertNotInvalidBounded(intQuestion); + _assertNotInvalidBounded(parseType('int')); + _assertNotInvalidBounded(parseType('int?')); } test_invalid() { - _assertInvalidBounded(invalidType); + _assertInvalidBounded(parseType('InvalidType')); } test_never() { - _assertNotInvalidBounded(neverNone); - _assertNotInvalidBounded(neverQuestion); + _assertNotInvalidBounded(parseType('Never')); + _assertNotInvalidBounded(parseType('Never?')); } test_typeParameter_hasBound_invalid() { - var T = typeParameter('T', bound: invalidType); - - _assertInvalidBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends InvalidType', (scope) { + _assertInvalidBounded(scope.parseType('T')); + }); } test_typeParameter_hasBound_notInvalid() { - var T = typeParameter('T', bound: intNone); - - _assertNotInvalidBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T extends int', (scope) { + _assertNotInvalidBounded(scope.parseType('T')); + }); } test_typeParameter_hasPromotedBound_invalidType() { - var T = typeParameter('T'); - - _assertInvalidBounded(typeParameterTypeNone(T, promotedBound: invalidType)); + withTypeParameterScope('T', (scope) { + _assertInvalidBounded(scope.parseType('T & InvalidType')); + }); } test_typeParameter_noBound() { - var T = typeParameter('T'); - - _assertNotInvalidBounded(typeParameterTypeNone(T)); + withTypeParameterScope('T', (scope) { + _assertNotInvalidBounded(scope.parseType('T')); + }); } test_void() { - _assertNotInvalidBounded(voidNone); + _assertNotInvalidBounded(parseType('void')); } void _assertInvalidBounded(DartType type) { diff --git a/pkg/analyzer/test/src/dart/element/type_constraint_gatherer_test.dart b/pkg/analyzer/test/src/dart/element/type_constraint_gatherer_test.dart index 65f25575c1f..8a4e49ee5ef 100644 --- a/pkg/analyzer/test/src/dart/element/type_constraint_gatherer_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_constraint_gatherer_test.dart @@ -20,505 +20,393 @@ main() { @reflectiveTest class TypeConstraintGathererTest extends AbstractTypeSystemTest { - late final TypeParameterElementImpl T; - late final TypeParameterTypeImpl T_none; - late final TypeParameterTypeImpl T_question; - - @override - void setUp() { - super.setUp(); - T = typeParameter('T'); - T_none = typeParameterTypeNone(T); - T_question = typeParameterTypeQuestion(T); - } - /// If `P` and `Q` are identical types, then the subtype match holds /// under no constraints. test_equal_left_right() { - _checkMatch([T], intNone, intNone, true, ['_ <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone)], - ), - true, - ['_ <: T <: _'], - ); + _checkMatch( + [T], + parseType('int'), + parseType('int'), + true, + ['_ <: T <: _'], + ); - var T1 = typeParameter('T1'); - var T2 = typeParameter('T2'); - _checkMatch( - [T], - functionTypeNone( - returnType: typeParameterTypeNone(T1), - typeParameters: [T1], - ), - functionTypeNone( - returnType: typeParameterTypeNone(T2), - typeParameters: [T2], - ), - true, - ['_ <: T <: _'], - ); + _checkMatch( + [T], + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(int)'), + true, + ['_ <: T <: _'], + ); + + _checkMatch( + [T], + parseFunctionType('T1 Function()'), + parseFunctionType('T2 Function()'), + true, + ['_ <: T <: _'], + ); + }); } test_functionType_hasTypeFormals() { - var T1 = typeParameter('T1'); - var S1 = typeParameter('S1'); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - var T1_none = typeParameterTypeNone(T1); - var S1_none = typeParameterTypeNone(S1); + _checkMatch( + [T], + scope.parseType('T Function(T1)'), + parseFunctionType('int Function(S1)'), + false, + ['_ <: T <: int'], + ); - _checkMatch( - [T], - functionTypeNone( - returnType: T_none, - typeParameters: [T1], - formalParameters: [requiredParameter(type: T1_none)], - ), - functionTypeNone( - returnType: intNone, - typeParameters: [S1], - formalParameters: [requiredParameter(type: S1_none)], - ), - false, - ['_ <: T <: int'], - ); + _checkMatch( + [T], + parseFunctionType('int Function(T1)'), + scope.parseType('T Function(S1)'), + true, + ['int <: T <: _'], + ); - _checkMatch( - [T], - functionTypeNone( - returnType: intNone, - typeParameters: [T1], - formalParameters: [requiredParameter(type: T1_none)], - ), - functionTypeNone( - returnType: T_none, - typeParameters: [S1], - formalParameters: [requiredParameter(type: S1_none)], - ), - true, - ['int <: T <: _'], - ); - - // We unified type formals, but still not match because return types. - _checkNotMatch( - [T], - functionTypeNone( - returnType: intNone, - typeParameters: [T1], - formalParameters: [requiredParameter(type: T1_none)], - ), - functionTypeNone( - returnType: stringNone, - typeParameters: [S1], - formalParameters: [requiredParameter(type: S1_none)], - ), - false, - ); + // We unified type formals, but still not match because return types. + _checkNotMatch( + [T], + parseFunctionType('int Function(T1)'), + parseFunctionType('String Function(S1)'), + false, + ); + }); } test_functionType_hasTypeFormals_bounds_different_subtype() { - var T1 = typeParameter('T1', bound: intNone); - var S1 = typeParameter('S1', bound: numNone); - _checkNotMatch( - [T], - functionTypeNone(returnType: T_none, typeParameters: [T1]), - functionTypeNone(returnType: intNone, typeParameters: [S1]), - false, - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkNotMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ); + }); } test_functionType_hasTypeFormals_bounds_different_top() { - var T1 = typeParameter('T1', bound: voidNone); - var S1 = typeParameter('S1', bound: dynamicType); - _checkMatch( - [T], - functionTypeNone(returnType: T_none, typeParameters: [T1]), - functionTypeNone(returnType: intNone, typeParameters: [S1]), - false, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ['_ <: T <: int'], + ); + }); } test_functionType_hasTypeFormals_bounds_different_unrelated() { - var T1 = typeParameter('T1', bound: intNone); - var S1 = typeParameter('S1', bound: stringNone); - _checkNotMatch( - [T], - functionTypeNone(returnType: T_none, typeParameters: [T1]), - functionTypeNone(returnType: intNone, typeParameters: [S1]), - false, - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkNotMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ); + }); } test_functionType_hasTypeFormals_bounds_same_leftDefault_rightDefault() { - var T1 = typeParameter('T1'); - var S1 = typeParameter('S1'); - _checkMatch( - [T], - functionTypeNone(returnType: T_none, typeParameters: [T1]), - functionTypeNone(returnType: intNone, typeParameters: [S1]), - false, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ['_ <: T <: int'], + ); + }); } test_functionType_hasTypeFormals_bounds_same_leftDefault_rightObjectQ() { - var T1 = typeParameter('T1'); - var S1 = typeParameter('S1', bound: objectQuestion); - _checkMatch( - [T], - functionTypeNone(returnType: T_none, typeParameters: [T1]), - functionTypeNone(returnType: intNone, typeParameters: [S1]), - false, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ['_ <: T <: int'], + ); + }); } @FailingTest(reason: 'Closure of type constraints is not implemented yet') test_functionType_hasTypeFormals_closure() { - var T = typeParameter('T'); - var X = typeParameter('X'); - var Y = typeParameter('Y'); - - var T_none = typeParameterTypeNone(T); - var X_none = typeParameterTypeNone(X); - var Y_none = typeParameterTypeNone(Y); - - _checkMatch( - [T], - functionTypeNone( - typeParameters: [X], - returnType: T_none, - formalParameters: [requiredParameter(type: X_none)], - ), - functionTypeNone( - typeParameters: [Y], - returnType: listNone(Y_none), - formalParameters: [requiredParameter(type: Y_none)], - ), - true, - ['_ <: T <: List'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + scope.parseType('T Function(X)'), + parseFunctionType('List Function(Y)'), + true, + ['_ <: T <: List'], + ); + }); } test_functionType_hasTypeFormals_differentCount() { - var T1 = typeParameter('T1'); - var S1 = typeParameter('S1'); - var S2 = typeParameter('S2'); - _checkNotMatch( - [T], - functionTypeNone(returnType: T_none, typeParameters: [T1]), - functionTypeNone(returnType: intNone, typeParameters: [S1, S2]), - false, - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkNotMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ); + }); } test_functionType_noTypeFormals_parameters_extraOptionalLeft() { - _checkMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: intNone)], - ), - functionTypeNone(returnType: voidNone, formalParameters: []), - true, - ['_ <: T <: _'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - functionTypeNone(returnType: voidNone, formalParameters: []), - true, - ['_ <: T <: _'], - ); + _checkMatch( + [T], + parseFunctionType('void Function([int])'), + parseFunctionType('void Function()'), + true, + ['_ <: T <: _'], + ); + + _checkMatch( + [T], + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function()'), + true, + ['_ <: T <: _'], + ); + }); } test_functionType_noTypeFormals_parameters_extraRequiredLeft() { - _checkNotMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: intNone)], - ), - functionTypeNone(returnType: voidNone, formalParameters: []), - true, - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionTypeNone(returnType: voidNone, formalParameters: []), - true, - ); + _checkNotMatch( + [T], + parseFunctionType('void Function(int)'), + parseFunctionType('void Function()'), + true, + ); + + _checkNotMatch( + [T], + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function()'), + true, + ); + }); } test_functionType_noTypeFormals_parameters_extraRight() { - _checkNotMatch( - [T], - functionTypeNone(returnType: voidNone), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ), - true, - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkNotMatch( + [T], + parseFunctionType('void Function()'), + scope.parseType('void Function(T)'), + true, + ); + }); } test_functionType_noTypeFormals_parameters_leftOptionalNamed() { - _checkMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: T_none)], - ), - true, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: T_none)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - false, - ['int <: T <: _'], - ); + _checkMatch( + [T], + parseFunctionType('void Function({int a})'), + scope.parseType('void Function({T a})'), + true, + ['_ <: T <: int'], + ); - // int vs. String - _checkNotMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: stringNone)], - ), - true, - ); + _checkMatch( + [T], + scope.parseType('void Function({T a})'), + parseFunctionType('void Function({int a})'), + false, + ['int <: T <: _'], + ); - // Skip left non-required named. - _checkMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - namedParameter(name: 'c', type: intNone), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'b', type: T_none)], - ), - true, - ['_ <: T <: int'], - ); + // int vs. String + _checkNotMatch( + [T], + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({String a})'), + true, + ); - // Not match if skip left required named. - _checkNotMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedRequiredParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: intNone), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'b', type: T_none)], - ), - true, - ); + // Skip left non-required named. + _checkMatch( + [T], + parseFunctionType('void Function({int a, int b, int c})'), + scope.parseType('void Function({T b})'), + true, + ['_ <: T <: int'], + ); - // Not match if skip right named. - _checkNotMatch( - [T], - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'b', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedParameter(name: 'b', type: T_none), - ], - ), - true, - ); + // Not match if skip left required named. + _checkNotMatch( + [T], + parseFunctionType('void Function({required int a, int b})'), + scope.parseType('void Function({T b})'), + true, + ); + + // Not match if skip right named. + _checkNotMatch( + [T], + parseFunctionType('void Function({int b})'), + scope.parseType('void Function({int a, T b})'), + true, + ); + }); } test_functionType_noTypeFormals_parameters_leftOptionalPositional() { - void check({ - required TypeImpl left, - required FormalParameterElementImpl right, - required bool leftSchema, - required String? expected, - }) { - var P = functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(type: left)], + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + + _checkMatch( + [T], + scope.parseType('void Function([int])'), + scope.parseType('void Function(T)'), + true, + ['_ <: T <: int'], ); - var Q = functionTypeNone(returnType: voidNone, formalParameters: [right]); - if (expected != null) { - _checkMatch([T], P, Q, leftSchema, [expected]); - } else { - _checkNotMatch([T], P, Q, leftSchema); - } - } + _checkMatch( + [T], + scope.parseType('void Function([T])'), + scope.parseType('void Function(int)'), + false, + ['int <: T <: _'], + ); + _checkMatch( + [T], + scope.parseType('void Function([int])'), + scope.parseType('void Function([T])'), + true, + ['_ <: T <: int'], + ); - check( - left: intNone, - right: requiredParameter(type: T_none), - leftSchema: true, - expected: '_ <: T <: int', - ); - check( - left: T_none, - right: requiredParameter(type: intNone), - leftSchema: false, - expected: 'int <: T <: _', - ); + _checkMatch( + [T], + scope.parseType('void Function([T])'), + scope.parseType('void Function([int])'), + false, + ['int <: T <: _'], + ); - check( - left: intNone, - right: positionalParameter(type: T_none), - leftSchema: true, - expected: '_ <: T <: int', - ); - check( - left: T_none, - right: positionalParameter(type: intNone), - leftSchema: false, - expected: 'int <: T <: _', - ); + _checkNotMatch( + [T], + scope.parseType('void Function([int])'), + scope.parseType('void Function(String)'), + true, + ); - check( - left: intNone, - right: requiredParameter(type: stringNone), - leftSchema: true, - expected: null, - ); - check( - left: intNone, - right: positionalParameter(type: stringNone), - leftSchema: true, - expected: null, - ); + _checkNotMatch( + [T], + scope.parseType('void Function([int])'), + scope.parseType('void Function([String])'), + true, + ); - check( - left: intNone, - right: namedParameter(type: intNone, name: 'a'), - leftSchema: true, - expected: null, - ); - check( - left: intNone, - right: namedParameter(type: intNone, name: 'a'), - leftSchema: false, - expected: null, - ); + _checkNotMatch( + [T], + scope.parseType('void Function([int])'), + scope.parseType('void Function({int a})'), + true, + ); + + _checkNotMatch( + [T], + scope.parseType('void Function([int])'), + scope.parseType('void Function({int a})'), + false, + ); + }); } test_functionType_noTypeFormals_parameters_leftRequiredPositional() { - void check({ - required TypeImpl left, - required FormalParameterElementImpl right, - required bool leftSchema, - required String? expected, - }) { - var P = functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: left)], + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + + _checkMatch( + [T], + scope.parseType('void Function(int)'), + scope.parseType('void Function(T)'), + true, + ['_ <: T <: int'], ); - var Q = functionTypeNone(returnType: voidNone, formalParameters: [right]); - if (expected != null) { - _checkMatch([T], P, Q, leftSchema, [expected]); - } else { - _checkNotMatch([T], P, Q, leftSchema); - } - } + _checkMatch( + [T], + scope.parseType('void Function(T)'), + scope.parseType('void Function(int)'), + false, + ['int <: T <: _'], + ); - check( - left: intNone, - right: requiredParameter(type: T_none), - leftSchema: true, - expected: '_ <: T <: int', - ); - check( - left: T_none, - right: requiredParameter(type: intNone), - leftSchema: false, - expected: 'int <: T <: _', - ); + _checkNotMatch( + [T], + scope.parseType('void Function(int)'), + scope.parseType('void Function(String)'), + true, + ); - check( - left: intNone, - right: requiredParameter(type: stringNone), - leftSchema: true, - expected: null, - ); + _checkNotMatch( + [T], + scope.parseType('void Function(int)'), + scope.parseType('void Function([T])'), + true, + ); - check( - left: intNone, - right: positionalParameter(type: T_none), - leftSchema: true, - expected: null, - ); - - check( - left: intNone, - right: namedParameter(type: T_none, name: 'a'), - leftSchema: true, - expected: null, - ); + _checkNotMatch( + [T], + scope.parseType('void Function(int)'), + scope.parseType('void Function({T a})'), + true, + ); + }); } test_functionType_noTypeFormals_returnType() { - _checkMatch( - [T], - functionTypeNone(returnType: T_none), - functionTypeNone(returnType: intNone), - false, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch( - [T], - functionTypeNone(returnType: stringNone), - functionTypeNone(returnType: intNone), - false, - ); + _checkMatch( + [T], + scope.parseType('T Function()'), + parseFunctionType('int Function()'), + false, + ['_ <: T <: int'], + ); + + _checkNotMatch( + [T], + parseFunctionType('String Function()'), + parseFunctionType('int Function()'), + false, + ); + }); } /// If `P` is `C` and `Q` is `C`, then the match @@ -526,44 +414,53 @@ class TypeConstraintGathererTest extends AbstractTypeSystemTest { /// If `Mi` is a subtype match for `Ni` with respect to L under /// constraints `Ci`. test_interfaceType_same() { - _checkMatch( - [T], - listNone(T_none), - listNone(numNone), - false, - ['_ <: T <: num'], - ); - _checkMatch( - [T], - listNone(intNone), - listNone(T_none), - true, - ['int <: T <: _'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch([T], listNone(intNone), listNone(stringNone), false); + _checkMatch( + [T], + scope.parseType('List'), + parseType('List'), + false, + ['_ <: T <: num'], + ); + _checkMatch( + [T], + parseType('List'), + scope.parseType('List'), + true, + ['int <: T <: _'], + ); - _checkMatch( - [T], - mapNone(intNone, listNone(T_none)), - mapNone(numNone, listNone(stringNone)), - false, - ['_ <: T <: String'], - ); - _checkMatch( - [T], - mapNone(intNone, listNone(stringNone)), - mapNone(numNone, listNone(T_none)), - true, - ['String <: T <: _'], - ); + _checkNotMatch( + [T], + parseType('List'), + parseType('List'), + false, + ); - _checkNotMatch( - [T], - mapNone(T_none, listNone(intNone)), - mapNone(numNone, listNone(stringNone)), - false, - ); + _checkMatch( + [T], + scope.parseType('Map>'), + parseType('Map>'), + false, + ['_ <: T <: String'], + ); + _checkMatch( + [T], + parseType('Map>'), + scope.parseType('Map>'), + true, + ['String <: T <: _'], + ); + + _checkNotMatch( + [T], + scope.parseType('Map>'), + parseType('Map>'), + false, + ); + }); } /// If `P` is `C0` and `Q` is `C1` then the match @@ -572,22 +469,31 @@ class TypeConstraintGathererTest extends AbstractTypeSystemTest { /// `C1` is a subtype match for `C1` with /// respect to `L` under constraints `C`. test_interfaceType_superInterface() { - _checkMatch( - [T], - listNone(T_none), - iterableNone(numNone), - false, - ['_ <: T <: num'], - ); - _checkMatch( - [T], - listNone(intNone), - iterableNone(T_none), - true, - ['int <: T <: _'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch([T], listNone(intNone), iterableNone(stringNone), true); + _checkMatch( + [T], + scope.parseType('List'), + parseType('Iterable'), + false, + ['_ <: T <: num'], + ); + _checkMatch( + [T], + parseType('List'), + scope.parseType('Iterable'), + true, + ['int <: T <: _'], + ); + + _checkNotMatch( + [T], + parseType('List'), + parseType('Iterable'), + true, + ); + }); } void test_interfaceType_topMerge() { @@ -609,19 +515,21 @@ class TypeConstraintGathererTest extends AbstractTypeSystemTest { ], ); testClassIndex++; - var A = classElement('A'); // class B extends A {} // class Cx extends A<> implements B<> {} var C = classElement('C${testClassIndex - 1}'); - _checkMatch( - [T], - interfaceTypeNone(C), - interfaceTypeNone(A, typeArguments: [T_none]), - true, - [expectedConstraint], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + parseType(C.name!), + scope.parseType('A'), + true, + [expectedConstraint], + ); + }); } void check( @@ -641,83 +549,145 @@ class TypeConstraintGathererTest extends AbstractTypeSystemTest { /// If `Future` is a subtype match for `Q` under constraint set `C1`. /// And if `P0` is a subtype match for `Q` under constraint set `C2`. test_left_futureOr() { - _checkMatch( - [T], - futureOrNone(T_none), - futureOrNone(intNone), - false, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - // This is 'T <: int' and 'T <: Future'. - _checkMatch( - [T], - futureOrNone(T_none), - futureNone(intNone), - false, - ['_ <: T <: Never'], - ); + _checkMatch( + [T], + scope.parseType('FutureOr'), + parseType('FutureOr'), + false, + ['_ <: T <: int'], + ); - _checkNotMatch([T], futureOrNone(T_none), intNone, false); + // This is 'T <: int' and 'T <: Future'. + _checkMatch( + [T], + scope.parseType('FutureOr'), + parseType('Future'), + false, + ['_ <: T <: Never'], + ); + + _checkNotMatch( + [T], + scope.parseType('FutureOr'), + parseType('int'), + false, + ); + }); } /// If `P` is `Never` then the match holds under no constraints. test_left_never() { - _checkMatch([T], neverNone, intNone, false, ['_ <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + parseType('Never'), + parseType('int'), + false, + ['_ <: T <: _'], + ); + }); } /// If `P` is `Null`, then the match holds under no constraints: /// Only if `Q` is nullable. test_left_null() { - _checkNotMatch([T], nullNone, intNone, true); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch([T], nullNone, T_none, true, ['Null <: T <: _']); + _checkNotMatch([T], parseType('Null'), parseType('int'), true); - _checkMatch([T], nullNone, futureOrNone(T_none), true, ['Null <: T <: _']); + _checkMatch( + [T], + parseType('Null'), + scope.parseType('T'), + true, + ['Null <: T <: _'], + ); - void matchNoConstraints(TypeImpl Q) { - _checkMatch([T], nullNone, Q, true, ['_ <: T <: _']); - } + _checkMatch( + [T], + parseType('Null'), + scope.parseType('FutureOr'), + true, + ['Null <: T <: _'], + ); - matchNoConstraints(listQuestion(T_none)); - matchNoConstraints(stringQuestion); - matchNoConstraints(voidNone); - matchNoConstraints(dynamicType); - matchNoConstraints(objectQuestion); - matchNoConstraints(nullNone); - matchNoConstraints(functionTypeQuestion(returnType: voidNone)); + void matchNoConstraints(TypeImpl Q) { + _checkMatch([T], parseType('Null'), Q, true, ['_ <: T <: _']); + } + + matchNoConstraints(scope.parseType('List?')); + matchNoConstraints(parseType('String?')); + matchNoConstraints(parseType('void')); + matchNoConstraints(parseType('dynamic')); + matchNoConstraints(parseType('Object?')); + matchNoConstraints(parseType('Null')); + matchNoConstraints(parseFunctionType('void Function()?')); + }); } /// If `P` is `P0?` the match holds under constraint set `C1 + C2`: /// If `P0` is a subtype match for `Q` under constraint set `C1`. /// And if `Null` is a subtype match for `Q` under constraint set `C2`. test_left_suffixQuestion() { - // TODO(scheglov): any better test case? - _checkMatch([T], numQuestion, dynamicType, true, ['_ <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch([T], T_question, intNone, true); + // TODO(scheglov): any better test case? + _checkMatch( + [T], + parseType('num?'), + parseType('dynamic'), + true, + ['_ <: T <: _'], + ); + + _checkNotMatch([T], scope.parseType('T?'), parseType('int'), true); + }); } /// If `Q` is `Q0?` the match holds under constraint set `C`: /// Or if `P` is `dynamic` or `void` and `Object` is a subtype match /// for `Q0` under constraint set `C`. test_left_top_right_nullable() { - var U = typeParameter('U', bound: objectNone); - var U_question = typeParameterTypeQuestion(U); + withTypeParameterScope('U extends Object', (scope) { + var U = scope.typeParameter('U'); + var U_question = scope.parseType('U?'); - _checkMatch([U], dynamicType, U_question, false, ['Object <: U <: _']); - _checkMatch([U], voidNone, U_question, false, ['Object <: U <: _']); + _checkMatch( + [U], + parseType('dynamic'), + U_question, + false, + ['Object <: U <: _'], + ); + _checkMatch( + [U], + parseType('void'), + U_question, + false, + ['Object <: U <: _'], + ); + }); } /// If `P` is a type variable `X` in `L`, then the match holds: /// Under constraint `_ <: X <: Q`. test_left_typeParameter2() { - void checkMatch(TypeImpl right, String expected) { - _checkMatch([T], T_none, right, false, [expected]); - } + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - checkMatch(numNone, '_ <: T <: num'); - checkMatch(numQuestion, '_ <: T <: num?'); + void checkMatch(TypeImpl right, String expected) { + _checkMatch([T], scope.parseType('T'), right, false, [expected]); + } + + checkMatch(parseType('num'), '_ <: T <: num'); + checkMatch(parseType('num?'), '_ <: T <: num?'); + }); } /// If `P` is a type variable `X` with bound `B` (or a promoted type @@ -725,332 +695,444 @@ class TypeConstraintGathererTest extends AbstractTypeSystemTest { /// If `B` is a subtype match for `Q` with constraint set `C`. /// Note: we have already eliminated the case that `X` is a variable in `L`. test_left_typeParameterOther() { - _checkMatch( - [T], - typeParameterTypeNone(typeParameter('U', bound: intNone)), - numNone, - false, - ['_ <: T <: _'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch( - [T], - promotedTypeParameterTypeNone(typeParameter('U'), intNone), - numNone, - false, - ['_ <: T <: _'], - ); + scope.withTypeParameterScope('U extends int', (scope) { + _checkMatch( + [T], + scope.parseType('U'), + parseType('num'), + false, + ['_ <: T <: _'], + ); + }); - _checkNotMatch( - [T], - typeParameterTypeNone(typeParameter('U')), - numNone, - false, - ); + scope.withTypeParameterScope('U', (scope) { + _checkMatch( + [T], + scope.parseType('U & int'), + parseType('num'), + false, + ['_ <: T <: _'], + ); + + _checkNotMatch([T], scope.parseType('U'), parseType('num'), false); + }); + }); } /// If `P` is `_` then the match holds with no constraints. test_left_unknown() { - _checkMatch([T], unknownInferredType, numNone, true, ['_ <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + parseType('UnknownInferredType'), + parseType('num'), + true, + ['_ <: T <: _'], + ); + }); } test_recordType_differentShape() { - _checkNotMatch( - [T], - recordTypeNone(positionalTypes: [T_none, intNone]), - recordTypeNone(positionalTypes: [intNone]), - true, - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch( - [T], - recordTypeNone(positionalTypes: [T_none]), - recordTypeNone(positionalTypes: [intNone, intNone]), - true, - ); + _checkNotMatch( + [T], + scope.parseType('(T, int)'), + scope.parseType('(int,)'), + true, + ); - _checkNotMatch( - [T], - recordTypeNone(namedTypes: {'f1': T_none}), - recordTypeNone(namedTypes: {'f2': intNone}), - true, - ); + _checkNotMatch( + [T], + scope.parseType('(T,)'), + scope.parseType('(int, int)'), + true, + ); - _checkNotMatch( - [T], - recordTypeNone(namedTypes: {'f1': T_none, 'f2': intNone}), - recordTypeNone(namedTypes: {'f1': intNone}), - true, - ); + _checkNotMatch( + [T], + scope.parseType('({T f1})'), + scope.parseType('({int f2})'), + true, + ); - _checkNotMatch( - [T], - recordTypeNone(namedTypes: {'f1': T_none}), - recordTypeNone(namedTypes: {'f1': intNone, 'f2': intNone}), - true, - ); + _checkNotMatch( + [T], + scope.parseType('({T f1, int f2})'), + scope.parseType('({int f1})'), + true, + ); - _checkNotMatch( - [T], - recordTypeNone(positionalTypes: [intNone], namedTypes: {'f2': T_none}), - recordTypeNone(namedTypes: {'f1': intNone, 'f2': intNone}), - true, - ); + _checkNotMatch( + [T], + scope.parseType('({T f1})'), + scope.parseType('({int f1, int f2})'), + true, + ); + + _checkNotMatch( + [T], + scope.parseType('(int, {T f2})'), + scope.parseType('({int f1, int f2})'), + true, + ); + }); } test_recordType_recordClass() { - _checkMatch( - [T], - recordTypeNone(positionalTypes: [T_none]), - recordNone, - true, - ['_ <: T <: _'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + scope.parseType('(T,)'), + parseType('Record'), + true, + ['_ <: T <: _'], + ); + }); } test_recordType_sameShape_named() { - _checkMatch( - [T], - recordTypeNone(namedTypes: {'f1': T_none}), - recordTypeNone(namedTypes: {'f1': intNone}), - true, - ['_ <: T <: int'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch( - [T], - recordTypeNone(namedTypes: {'f1': intNone}), - recordTypeNone(namedTypes: {'f1': T_none}), - false, - ['int <: T <: _'], - ); + _checkMatch( + [T], + scope.parseType('({T f1})'), + scope.parseType('({int f1})'), + true, + ['_ <: T <: int'], + ); - _checkNotMatch( - [T], - recordTypeNone(namedTypes: {'f1': intNone}), - recordTypeNone(namedTypes: {'f1': stringNone}), - false, - ); + _checkMatch( + [T], + scope.parseType('({int f1})'), + scope.parseType('({T f1})'), + false, + ['int <: T <: _'], + ); - _checkMatch( - [T], - recordTypeNone(namedTypes: {'f1': intNone, 'f2': T_none}), - recordTypeNone(namedTypes: {'f1': numNone, 'f2': stringNone}), - true, - ['_ <: T <: String'], - ); + _checkNotMatch( + [T], + scope.parseType('({int f1})'), + scope.parseType('({String f1})'), + false, + ); - _checkMatch( - [T], - recordTypeNone(namedTypes: {'f1': intNone, 'f2': stringNone}), - recordTypeNone(namedTypes: {'f1': numNone, 'f2': T_none}), - false, - ['String <: T <: _'], - ); + _checkMatch( + [T], + scope.parseType('({int f1, T f2})'), + scope.parseType('({num f1, String f2})'), + true, + ['_ <: T <: String'], + ); - _checkNotMatch( - [T], - recordTypeNone( - namedTypes: {'f1': T_none, 'f2': intNone}, - positionalTypes: [T_none, intNone], - ), - recordTypeNone(namedTypes: {'f1': intNone, 'f2': stringNone}), - true, - ); + _checkMatch( + [T], + scope.parseType('({int f1, String f2})'), + scope.parseType('({num f1, T f2})'), + false, + ['String <: T <: _'], + ); + + _checkNotMatch( + [T], + scope.parseType('(T, int, {T f1, int f2})'), + scope.parseType('({int f1, String f2})'), + true, + ); + }); } test_recordType_sameShape_positional() { - _checkMatch( - [T], - recordTypeNone(positionalTypes: [T_none]), - recordTypeNone(positionalTypes: [numNone]), - true, - ['_ <: T <: num'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkMatch( - [T], - recordTypeNone(positionalTypes: [intNone]), - recordTypeNone(positionalTypes: [T_none]), - false, - ['int <: T <: _'], - ); + _checkMatch( + [T], + scope.parseType('(T,)'), + scope.parseType('(num,)'), + true, + ['_ <: T <: num'], + ); - _checkNotMatch( - [T], - recordTypeNone(positionalTypes: [intNone]), - recordTypeNone(positionalTypes: [stringNone]), - false, - ); + _checkMatch( + [T], + scope.parseType('(int,)'), + scope.parseType('(T,)'), + false, + ['int <: T <: _'], + ); - _checkMatch( - [T], - recordTypeNone(positionalTypes: [intNone, T_none]), - recordTypeNone(positionalTypes: [numNone, stringNone]), - true, - ['_ <: T <: String'], - ); + _checkNotMatch( + [T], + scope.parseType('(int,)'), + scope.parseType('(String,)'), + false, + ); - _checkMatch( - [T], - recordTypeNone(positionalTypes: [intNone, stringNone]), - recordTypeNone(positionalTypes: [numNone, T_none]), - false, - ['String <: T <: _'], - ); + _checkMatch( + [T], + scope.parseType('(int, T)'), + scope.parseType('(num, String)'), + true, + ['_ <: T <: String'], + ); - _checkNotMatch( - [T], - recordTypeNone(positionalTypes: [T_none, intNone]), - recordTypeNone(positionalTypes: [numNone, stringNone]), - true, - ); + _checkMatch( + [T], + scope.parseType('(int, String)'), + scope.parseType('(num, T)'), + false, + ['String <: T <: _'], + ); + + _checkNotMatch( + [T], + scope.parseType('(T, int)'), + scope.parseType('(num, String)'), + true, + ); + }); } test_right_functionClass() { - _checkMatch( - [T], - functionTypeNone(returnType: voidNone), - functionNone, - true, - ['_ <: T <: _'], - ); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + parseFunctionType('void Function()'), + parseType('Function'), + true, + ['_ <: T <: _'], + ); + }); } /// If `Q` is `FutureOr` the match holds under constraint set `C`: test_right_futureOr() { - // If `P` is `FutureOr` and `P0` is a subtype match for `Q0` under - // constraint set `C`. - _checkMatch( - [T], - futureOrNone(T_none), - futureOrNone(numNone), - false, - ['_ <: T <: num'], - ); - _checkMatch( - [T], - futureOrNone(numNone), - futureOrNone(T_none), - true, - ['num <: T <: _'], - ); - _checkNotMatch([T], futureOrNone(stringNone), futureOrNone(intNone), true); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - // Or if `P` is a subtype match for `Future` under non-empty - // constraint set `C`. - _checkMatch( - [T], - futureNone(T_none), - futureOrNone(numNone), - false, - ['_ <: T <: num'], - ); - _checkMatch( - [T], - futureNone(intNone), - futureOrNone(T_none), - true, - ['int <: T <: _'], - ); - _checkMatch( - [T], - futureNone(intNone), - futureOrNone(objectNone), - true, - ['_ <: T <: _'], - ); - _checkNotMatch([T], futureNone(stringNone), futureOrNone(intNone), true); + // If `P` is `FutureOr` and `P0` is a subtype match for `Q0` under + // constraint set `C`. + _checkMatch( + [T], + scope.parseType('FutureOr'), + parseType('FutureOr'), + false, + ['_ <: T <: num'], + ); + _checkMatch( + [T], + parseType('FutureOr'), + scope.parseType('FutureOr'), + true, + ['num <: T <: _'], + ); + _checkNotMatch( + [T], + parseType('FutureOr'), + parseType('FutureOr'), + true, + ); - // Or if `P` is a subtype match for `Q0` under constraint set `C`. - _checkMatch( - [T], - listNone(T_none), - futureOrNone(listNone(intNone)), - false, - ['_ <: T <: int'], - ); - _checkMatch( - [T], - neverNone, - futureOrNone(T_none), - true, - ['Never <: T <: _'], - ); + // Or if `P` is a subtype match for `Future` under non-empty + // constraint set `C`. + _checkMatch( + [T], + scope.parseType('Future'), + parseType('FutureOr'), + false, + ['_ <: T <: num'], + ); + _checkMatch( + [T], + parseType('Future'), + scope.parseType('FutureOr'), + true, + ['int <: T <: _'], + ); + _checkMatch( + [T], + parseType('Future'), + parseType('FutureOr'), + true, + ['_ <: T <: _'], + ); + _checkNotMatch( + [T], + parseType('Future'), + parseType('FutureOr'), + true, + ); - // Or if `P` is a subtype match for `Future` under empty - // constraint set `C`. - _checkMatch( - [T], - futureNone(intNone), - futureOrNone(numNone), - false, - ['_ <: T <: _'], - ); + // Or if `P` is a subtype match for `Q0` under constraint set `C`. + _checkMatch( + [T], + scope.parseType('List'), + parseType('FutureOr>'), + false, + ['_ <: T <: int'], + ); + _checkMatch( + [T], + parseType('Never'), + scope.parseType('FutureOr'), + true, + ['Never <: T <: _'], + ); - // Otherwise. - _checkNotMatch([T], listNone(T_none), futureOrNone(intNone), false); + // Or if `P` is a subtype match for `Future` under empty + // constraint set `C`. + _checkMatch( + [T], + parseType('Future'), + parseType('FutureOr'), + false, + ['_ <: T <: _'], + ); + + // Otherwise. + _checkNotMatch( + [T], + scope.parseType('List'), + parseType('FutureOr'), + false, + ); + }); } /// If `Q` is `Object`, then the match holds under no constraints: /// Only if `P` is non-nullable. test_right_object() { - _checkMatch([T], intNone, objectNone, false, ['_ <: T <: _']); - _checkNotMatch([T], intQuestion, objectNone, false); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkNotMatch([T], dynamicType, objectNone, false); + _checkMatch( + [T], + parseType('int'), + parseType('Object'), + false, + ['_ <: T <: _'], + ); + _checkNotMatch([T], parseType('int?'), parseType('Object'), false); - { - var U = typeParameter('U', bound: numQuestion); - _checkNotMatch([T], typeParameterTypeNone(U), objectNone, false); - } + _checkNotMatch([T], parseType('dynamic'), parseType('Object'), false); + + scope.withTypeParameterScope('U extends num?', (scope) { + _checkNotMatch([T], scope.parseType('U'), parseType('Object'), false); + }); + }); } /// If `Q` is `Q0?` the match holds under constraint set `C`: test_right_suffixQuestion() { - // If `P` is `P0?` and `P0` is a subtype match for `Q0` under - // constraint set `C`. - _checkMatch([T], T_question, numQuestion, false, ['_ <: T <: num']); - _checkMatch([T], intQuestion, T_question, true, ['int <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + var T_question = scope.parseType('T?'); - // Or if `P` is a subtype match for `Q0` under non-empty - // constraint set `C`. - _checkMatch([T], intNone, T_question, false, ['int <: T <: _']); + // If `P` is `P0?` and `P0` is a subtype match for `Q0` under + // constraint set `C`. + _checkMatch([T], T_question, parseType('num?'), false, ['_ <: T <: num']); + _checkMatch([T], parseType('int?'), T_question, true, ['int <: T <: _']); - // Or if `P` is a subtype match for `Null` under constraint set `C`. - _checkMatch([T], nullNone, intQuestion, true, ['_ <: T <: _']); + // Or if `P` is a subtype match for `Q0` under non-empty + // constraint set `C`. + _checkMatch([T], parseType('int'), T_question, false, ['int <: T <: _']); - // Or if `P` is a subtype match for `Q0` under empty - // constraint set `C`. - _checkMatch([T], intNone, intQuestion, true, ['_ <: T <: _']); + // Or if `P` is a subtype match for `Null` under constraint set `C`. + _checkMatch( + [T], + parseType('Null'), + parseType('int?'), + true, + ['_ <: T <: _'], + ); - _checkNotMatch([T], intNone, stringQuestion, true); - _checkNotMatch([T], intQuestion, stringQuestion, true); + // Or if `P` is a subtype match for `Q0` under empty + // constraint set `C`. + _checkMatch( + [T], + parseType('int'), + parseType('int?'), + true, + ['_ <: T <: _'], + ); + + _checkNotMatch([T], parseType('int'), parseType('String?'), true); + _checkNotMatch([T], parseType('int?'), parseType('String?'), true); + }); } /// If `Q` is `dynamic`, `Object?`, or `void` then the match holds under /// no constraints. test_right_top() { - _checkMatch([T], intNone, dynamicType, false, ['_ <: T <: _']); - _checkMatch([T], intNone, objectQuestion, false, ['_ <: T <: _']); - _checkMatch([T], intNone, voidNone, false, ['_ <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + parseType('int'), + parseType('dynamic'), + false, + ['_ <: T <: _'], + ); + _checkMatch( + [T], + parseType('int'), + parseType('Object?'), + false, + ['_ <: T <: _'], + ); + _checkMatch( + [T], + parseType('int'), + parseType('void'), + false, + ['_ <: T <: _'], + ); + }); } /// If `Q` is a type variable `X` in `L`, then the match holds: /// Under constraint `P <: X <: _`. test_right_typeParameter2() { - void checkMatch(TypeImpl left, String expected) { - _checkMatch([T], left, T_none, true, [expected]); - } + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - checkMatch(numNone, 'num <: T <: _'); - checkMatch(numQuestion, 'num? <: T <: _'); + void checkMatch(TypeImpl left, String expected) { + _checkMatch([T], left, scope.parseType('T'), true, [expected]); + } + + checkMatch(parseType('num'), 'num <: T <: _'); + checkMatch(parseType('num?'), 'num? <: T <: _'); + }); } /// If `Q` is `_` then the match holds with no constraints. test_right_unknown() { - _checkMatch([T], numNone, unknownInferredType, true, ['_ <: T <: _']); - _checkMatch([T], numNone, unknownInferredType, true, ['_ <: T <: _']); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + _checkMatch( + [T], + parseType('num'), + parseType('UnknownInferredType'), + true, + ['_ <: T <: _'], + ); + _checkMatch( + [T], + parseType('num'), + parseType('UnknownInferredType'), + true, + ['_ <: T <: _'], + ); + }); } void _checkMatch( diff --git a/pkg/analyzer/test/src/dart/element/type_parameter_element_test.dart b/pkg/analyzer/test/src/dart/element/type_parameter_element_test.dart index 0e445dc6891..30059544d41 100644 --- a/pkg/analyzer/test/src/dart/element/type_parameter_element_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_parameter_element_test.dart @@ -18,76 +18,51 @@ main() { @reflectiveTest class TypeParameterElementTest extends AbstractTypeSystemTest { test_equal() { - var T1 = typeParameter('T'); - var T2 = typeParameter('T'); + withTypeParameterScope('T', (scope1) { + var T1 = scope1.typeParameter('T'); + scope1.withTypeParameterScope('T', (scope2) { + var T2 = scope2.typeParameter('T'); - expect(T1 == T1, isTrue); - expect(T2 == T2, isTrue); + expect(T1 == T1, isTrue); + expect(T2 == T2, isTrue); - expect(T1 == T2, isFalse); - expect(T2 == T1, isFalse); + expect(T1 == T2, isFalse); + expect(T2 == T1, isFalse); + }); + }); } } @reflectiveTest class TypeParameterTypeTest extends AbstractTypeSystemTest { test_equal_differentElements() { - var T1 = typeParameter('T'); - var T2 = typeParameter('T'); - - _assertEqual(typeParameterTypeNone(T1), typeParameterTypeNone(T2), isFalse); + withTypeParameterScope('T', (scope1) { + var T1 = scope1.parseType('T'); + scope1.withTypeParameterScope('T', (scope2) { + var T2 = scope2.parseType('T'); + _assertEqual(T1, T2, isFalse); + }); + }); } test_equal_sameElement() { - var T = typeParameter('T'); - - _assertEqual(typeParameterTypeNone(T), typeParameterTypeNone(T), isTrue); - - _assertEqual( - typeParameterTypeNone(T), - typeParameterTypeQuestion(T), - isFalse, - ); - - _assertEqual( - typeParameterTypeQuestion(T), - typeParameterTypeNone(T), - isFalse, - ); - - _assertEqual( - typeParameterTypeQuestion(T), - typeParameterTypeQuestion(T), - isTrue, - ); + withTypeParameterScope('T', (scope) { + var T = scope.parseType('T'); + _assertEqual(T, T, isTrue); + _assertEqual(T, scope.parseType('T?'), isFalse); + _assertEqual(scope.parseType('T?'), T, isFalse); + _assertEqual(scope.parseType('T?'), scope.parseType('T?'), isTrue); + }); } test_equal_sameElement_promotedBounds() { - var T = typeParameter('T'); - - _assertEqual( - promotedTypeParameterTypeNone(T, intNone), - promotedTypeParameterTypeNone(T, intNone), - isTrue, - ); - - _assertEqual( - promotedTypeParameterTypeNone(T, intNone), - promotedTypeParameterTypeNone(T, doubleNone), - isFalse, - ); - - _assertEqual( - promotedTypeParameterTypeNone(T, intNone), - typeParameterTypeNone(T), - isFalse, - ); - - _assertEqual( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, intNone), - isFalse, - ); + withTypeParameterScope('T', (scope) { + var T = scope.parseType('T & int'); + _assertEqual(T, T, isTrue); + _assertEqual(T, scope.parseType('T & double'), isFalse); + _assertEqual(T, scope.parseType('T'), isFalse); + _assertEqual(scope.parseType('T'), T, isFalse); + }); } void _assertEqual(DartType T1, DartType T2, matcher) { diff --git a/pkg/analyzer/test/src/dart/element/type_references_any_test.dart b/pkg/analyzer/test/src/dart/element/type_references_any_test.dart index b0fdbded517..e20c2928cca 100644 --- a/pkg/analyzer/test/src/dart/element/type_references_any_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_references_any_test.dart @@ -2,7 +2,6 @@ // 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:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/type.dart'; import 'package:test/test.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; @@ -17,55 +16,39 @@ main() { @reflectiveTest class TypeReferencesAnyTest extends AbstractTypeSystemTest { - late TypeParameterElementImpl T; - late TypeParameterTypeImpl T_none; - - @override - void setUp() { - super.setUp(); - - T = typeParameter('T'); - T_none = typeParameterTypeNone(T); - } - test_false() { - _checkFalse(dynamicType); - _checkFalse(intNone); - _checkFalse(neverNone); - _checkFalse(voidNone); - _checkFalse(listNone(intNone)); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); + + void checkFalse(TypeImpl type) { + var actual = type.referencesAny({T}); + expect(actual, isFalse); + } + + checkFalse(parseType('dynamic')); + checkFalse(parseType('int')); + checkFalse(parseType('Never')); + checkFalse(parseType('void')); + checkFalse(parseType('List')); + }); } test_true() { - _checkTrue(T_none); - _checkTrue(listNone(T_none)); - _checkTrue(mapNone(T_none, intNone)); - _checkTrue(mapNone(intNone, T_none)); + withTypeParameterScope('T', (scope) { + var T = scope.typeParameter('T'); - _checkTrue(functionTypeNone(returnType: T_none)); + void checkTrue(TypeImpl type) { + var actual = type.referencesAny({T}); + expect(actual, isTrue); + } - _checkTrue( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ), - ); - - _checkTrue( - functionTypeNone( - typeParameters: [typeParameter('U', bound: T_none)], - returnType: voidNone, - ), - ); - } - - void _checkFalse(TypeImpl type) { - var actual = type.referencesAny({T}); - expect(actual, isFalse); - } - - void _checkTrue(TypeImpl type) { - var actual = type.referencesAny({T}); - expect(actual, isTrue); + checkTrue(scope.parseType('T')); + checkTrue(scope.parseType('List')); + checkTrue(scope.parseType('Map')); + checkTrue(scope.parseType('Map')); + checkTrue(scope.parseType('T Function()')); + checkTrue(scope.parseType('void Function(T)')); + checkTrue(scope.parseType('void Function()')); + }); } } diff --git a/pkg/analyzer/test/src/dart/element/type_system_test.dart b/pkg/analyzer/test/src/dart/element/type_system_test.dart index a6f18a3d7dd..efa66ce84df 100644 --- a/pkg/analyzer/test/src/dart/element/type_system_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_system_test.dart @@ -18,54 +18,54 @@ main() { @reflectiveTest class IsValidExtensionTypeSuperinterfaceTest extends AbstractTypeSystemTest { test_functionType() { - _assertNotValid(functionTypeNone(returnType: voidNone)); + _assertNotValid(parseType('void Function()')); } test_interfaceType() { - _assertValid(numNone); + _assertValid(parseType('num')); } test_interfaceType_extensionType() { buildTestLibrary( extensionTypes: [ExtensionTypeSpec('extension type A(int it)')], ); - var element = extensionTypeElement('A'); - _assertValid(interfaceTypeNone(element)); + _assertValid(parseType('A')); } test_interfaceType_function() { - _assertNotValid(functionNone); + _assertNotValid(parseType('Function')); } test_interfaceType_futureOr() { - _assertNotValid(futureOrNone(intNone)); + _assertNotValid(parseType('FutureOr')); } test_interfaceType_null() { - _assertNotValid(nullNone); + _assertNotValid(parseType('Null')); } test_interfaceType_nullable() { - _assertNotValid(numQuestion); + _assertNotValid(parseType('num?')); } test_interfaceType_record() { - _assertNotValid(recordNone); + _assertNotValid(parseType('Record')); } test_recordType() { - _assertNotValid(recordTypeNone(positionalTypes: [intNone, stringNone])); + _assertNotValid(parseType('(int, String)')); } test_topType() { - _assertNotValid(dynamicType); - _assertNotValid(voidNone); - _assertNotValid(objectQuestion); + _assertNotValid(parseType('dynamic')); + _assertNotValid(parseType('void')); + _assertNotValid(parseType('Object?')); } test_typeParameterType() { - var T = typeParameter('T'); - _assertNotValid(typeParameterTypeNone(T)); + withTypeParameterScope('T', (scope) { + _assertNotValid(scope.parseType('T')); + }); } void _assertNotValid(DartType type) { diff --git a/pkg/analyzer/test/src/dart/element/type_visitor_test.dart b/pkg/analyzer/test/src/dart/element/type_visitor_test.dart index 4d2670e6257..7a8f42e9f01 100644 --- a/pkg/analyzer/test/src/dart/element/type_visitor_test.dart +++ b/pkg/analyzer/test/src/dart/element/type_visitor_test.dart @@ -2,7 +2,6 @@ // 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:analyzer/dart/element/nullability_suffix.dart'; import 'package:analyzer/dart/element/type.dart'; import 'package:analyzer/src/dart/element/type_visitor.dart'; import 'package:test/test.dart'; @@ -29,181 +28,144 @@ class RecursiveTypeVisitorTest extends AbstractTypeSystemTest with StringTypes { } void test_callsDefaultBehavior() { - expect(intNone.accept(visitor), true); - visitor.assertVisitedType(intNone); + expect(parseType('int').accept(visitor), true); + visitor.assertVisitedType(parseType('int')); } void test_functionType_complex() { - var T = typeParameter('T', bound: intNone); - var K = typeParameter('K', bound: stringNone); - var a = positionalParameter(type: numNone); - var b = positionalParameter(type: doubleNone); - var c = namedParameter(name: 'c', type: voidNone); - var d = namedParameter(name: 'd', type: objectNone); - var type = functionType( - returnType: dynamicType, - typeParameters: [T, K], - formalParameters: [a, b, c, d], - nullabilitySuffix: NullabilitySuffix.none, + var type = parseFunctionType( + 'dynamic Function(' + 'num, double, {void c, Object d})', ); expect(type.accept(visitor), true); visitor.assertVisitedTypes([ - dynamicType, - intNone, - stringNone, - numNone, - doubleNone, - voidNone, - objectNone, + parseType('dynamic'), + parseType('int'), + parseType('String'), + parseType('num'), + parseType('double'), + parseType('void'), + parseType('Object'), ]); } void test_functionType_positionalParameter() { - var a = positionalParameter(type: intNone); - var type = functionType( - returnType: dynamicType, - typeParameters: [], - formalParameters: [a], - nullabilitySuffix: NullabilitySuffix.none, - ); + var type = parseFunctionType('dynamic Function([int])'); expect(type.accept(visitor), true); - visitor.assertVisitedType(intNone); + visitor.assertVisitedType(parseType('int')); } void test_functionType_returnType() { - var type = functionType( - returnType: intNone, - typeParameters: [], - formalParameters: [], - nullabilitySuffix: NullabilitySuffix.none, - ); + var type = parseFunctionType('int Function()'); expect(type.accept(visitor), true); - visitor.assertVisitedType(intNone); + visitor.assertVisitedType(parseType('int')); } void test_functionType_typeFormal_bound() { - var T = typeParameter('T', bound: intNone); - var type = functionType( - returnType: dynamicType, - typeParameters: [T], - formalParameters: [], - nullabilitySuffix: NullabilitySuffix.none, - ); + var type = parseFunctionType('dynamic Function()'); expect(type.accept(visitor), true); - visitor.assertVisitedTypes([dynamicType, intNone]); + visitor.assertVisitedTypes([parseType('dynamic'), parseType('int')]); } void test_functionType_typeFormal_noBound() { - var T = typeParameter('T'); - var type = functionType( - returnType: dynamicType, - typeParameters: [T], - formalParameters: [], - nullabilitySuffix: NullabilitySuffix.none, - ); + var type = parseFunctionType('dynamic Function()'); expect(type.accept(visitor), true); - visitor.assertVisitedType(dynamicType); + visitor.assertVisitedType(parseType('dynamic')); } void test_interfaceType_typeParameter() { - var type = typeProvider.listType(intNone); + var type = typeProvider.listType(parseType('int')); expect(type.accept(visitor), true); - visitor.assertVisitedType(intNone); + visitor.assertVisitedType(parseType('int')); } void test_interfaceType_typeParameters() { - var type = typeProvider.mapType(intNone, stringNone); + var type = typeProvider.mapType(parseType('int'), parseType('String')); expect(type.accept(visitor), true); - visitor.assertVisitedTypes([intNone, stringNone]); + visitor.assertVisitedTypes([parseType('int'), parseType('String')]); } void test_interfaceType_typeParameters_nested() { - var innerList = typeProvider.listType(intNone); + var innerList = typeProvider.listType(parseType('int')); var outerList = typeProvider.listType(innerList); expect(outerList.accept(visitor), true); - visitor.assertVisitedType(intNone); + visitor.assertVisitedType(parseType('int')); } void test_recordType_named() { var type = typeOfString('({int f1, double f2})'); expect(type.accept(visitor), true); - visitor.assertVisitedType(intNone); - visitor.assertVisitedType(doubleNone); + visitor.assertVisitedType(parseType('int')); + visitor.assertVisitedType(parseType('double')); + } + + void test_recordType_named_dollarIdentifier() { + var type = typeOfString(r'({int $1})'); + expect(type.accept(visitor), true); + visitor.assertVisitedType(parseType('int')); } void test_recordType_positional() { var type = typeOfString('(int, double)'); expect(type.accept(visitor), true); - visitor.assertVisitedType(intNone); - visitor.assertVisitedType(doubleNone); + visitor.assertVisitedType(parseType('int')); + visitor.assertVisitedType(parseType('double')); } void test_stopVisiting_first() { - var T = typeParameter('T', bound: intNone); - var K = typeParameter('K', bound: stringNone); - var a = positionalParameter(type: numNone); - var b = positionalParameter(type: doubleNone); - var c = namedParameter(name: 'c', type: voidNone); - var d = namedParameter(name: 'd', type: objectNone); - var type = functionType( - returnType: dynamicType, - typeParameters: [T, K], - formalParameters: [a, b, c, d], - nullabilitySuffix: NullabilitySuffix.none, + var type = parseFunctionType( + 'dynamic Function(' + 'num, double, {void c, Object d})', ); - visitor.stopOnType = dynamicType; + visitor.stopOnType = parseType('dynamic'); expect(type.accept(visitor), false); visitor.assertNotVisitedTypes([ - intNone, - stringNone, - numNone, - doubleNone, - voidNone, - objectNone, + parseType('int'), + parseType('String'), + parseType('num'), + parseType('double'), + parseType('void'), + parseType('Object'), ]); } void test_stopVisiting_halfway() { - var T = typeParameter('T', bound: intNone); - var K = typeParameter('K', bound: stringNone); - var a = positionalParameter(type: numNone); - var b = positionalParameter(type: doubleNone); - var c = namedParameter(name: 'c', type: voidNone); - var d = namedParameter(name: 'd', type: objectNone); - var type = functionType( - returnType: dynamicType, - typeParameters: [T, K], - formalParameters: [a, b, c, d], - nullabilitySuffix: NullabilitySuffix.none, + var type = parseFunctionType( + 'dynamic Function(' + 'num, double, {void c, Object d})', ); - visitor.stopOnType = intNone; + visitor.stopOnType = parseType('int'); expect(type.accept(visitor), false); - visitor.assertNotVisitedTypes([stringNone, voidNone, objectNone]); + visitor.assertNotVisitedTypes([ + parseType('String'), + parseType('void'), + parseType('Object'), + ]); } void test_stopVisiting_nested() { - var innerType = typeProvider.mapType(intNone, stringNone); + var innerType = typeProvider.mapType(parseType('int'), parseType('String')); var outerList = typeProvider.listType(innerType); - visitor.stopOnType = intNone; + visitor.stopOnType = parseType('int'); expect(outerList.accept(visitor), false); - visitor.assertNotVisitedType(stringNone); + visitor.assertNotVisitedType(parseType('String')); } void test_stopVisiting_nested_parent() { - var innerTypeStop = typeProvider.listType(intNone); - var innerTypeSkipped = typeProvider.listType(stringNone); + var innerTypeStop = typeProvider.listType(parseType('int')); + var innerTypeSkipped = typeProvider.listType(parseType('String')); var outerType = typeProvider.mapType(innerTypeStop, innerTypeSkipped); - visitor.stopOnType = intNone; + visitor.stopOnType = parseType('int'); expect(outerType.accept(visitor), false); - visitor.assertNotVisitedType(stringNone); + visitor.assertNotVisitedType(parseType('String')); } void test_stopVisiting_typeParameters() { - var type = typeProvider.mapType(intNone, stringNone); - visitor.stopOnType = intNone; + var type = typeProvider.mapType(parseType('int'), parseType('String')); + visitor.stopOnType = parseType('int'); expect(type.accept(visitor), false); - visitor.assertVisitedType(intNone); - visitor.assertNotVisitedType(stringNone); + visitor.assertVisitedType(parseType('int')); + visitor.assertNotVisitedType(parseType('String')); } } diff --git a/pkg/analyzer/test/src/dart/element/upper_lower_bound_test.dart b/pkg/analyzer/test/src/dart/element/upper_lower_bound_test.dart index b1f2b2ddd62..d75aadec625 100644 --- a/pkg/analyzer/test/src/dart/element/upper_lower_bound_test.dart +++ b/pkg/analyzer/test/src/dart/element/upper_lower_bound_test.dart @@ -3,7 +3,6 @@ // BSD-style license that can be found in the LICENSE file. import 'package:analyzer/dart/element/nullability_suffix.dart'; -import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/element/type.dart'; import 'package:analyzer/src/dart/element/type_schema.dart'; import 'package:analyzer/src/dart/element/type_system.dart'; @@ -103,270 +102,273 @@ class BoundsHelperPredicatesTest extends _BoundsTestBase { } test_isBottom() { - TypeParameterElementImpl T; - // BOTTOM(Never) is true - isBottom(neverNone); - isNotBottom(neverQuestion); + isBottom(parseType('Never')); + isNotBottom(parseType('Never?')); // BOTTOM(X&T) is true iff BOTTOM(T) - T = typeParameter('T', bound: objectQuestion); - - isBottom(promotedTypeParameterTypeNone(T, neverNone)); - isNotBottom(promotedTypeParameterTypeQuestion(T, neverNone)); - - isNotBottom(promotedTypeParameterTypeNone(T, neverQuestion)); - isNotBottom(promotedTypeParameterTypeQuestion(T, neverQuestion)); + withTypeParameterScope('T extends Object?', (scope) { + isBottom(scope.parseType('T & Never')); + isNotBottom(scope.parseType('(T & Never)?')); + isNotBottom(scope.parseType('T & Never?')); + isNotBottom(scope.parseType('(T & Never?)?')); + }); // BOTTOM(X extends T) is true iff BOTTOM(T) - T = typeParameter('T', bound: neverNone); - isBottom(typeParameterTypeNone(T)); - isNotBottom(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends Never', (scope) { + isBottom(scope.parseType('T')); + isNotBottom(scope.parseType('T?')); + }); - T = typeParameter('T', bound: neverQuestion); - isNotBottom(typeParameterTypeNone(T)); - isNotBottom(typeParameterTypeQuestion(T)); + withTypeParameterScope('T extends Never?', (scope) { + isNotBottom(scope.parseType('T')); + isNotBottom(scope.parseType('T?')); + }); // BOTTOM(T) is false otherwise - isNotBottom(dynamicType); - isNotBottom(invalidType); - isNotBottom(voidNone); + isNotBottom(parseType('dynamic')); + isNotBottom(parseType('InvalidType')); + isNotBottom(parseType('void')); - isNotBottom(objectNone); - isNotBottom(objectQuestion); + isNotBottom(parseType('Object')); + isNotBottom(parseType('Object?')); - isNotBottom(intNone); - isNotBottom(intQuestion); + isNotBottom(parseType('int')); + isNotBottom(parseType('int?')); - T = typeParameter('T', bound: numNone); - isNotBottom(typeParameterTypeNone(T)); - isNotBottom(typeParameterTypeQuestion(T)); - - isNotBottom(promotedTypeParameterTypeNone(T, intNone)); - isNotBottom(promotedTypeParameterTypeQuestion(T, intNone)); + withTypeParameterScope('T extends num', (scope) { + isNotBottom(scope.parseType('T')); + isNotBottom(scope.parseType('T?')); + isNotBottom(scope.parseType('T & int')); + isNotBottom(scope.parseType('(T & int)?')); + }); } test_isMoreBottom() { // MOREBOTTOM(Never, T) = true - isMoreBottom(neverNone, neverNone); - isMoreBottom(neverNone, neverQuestion); + isMoreBottom(parseType('Never'), parseType('Never')); + isMoreBottom(parseType('Never'), parseType('Never?')); - isMoreBottom(neverNone, nullNone); + isMoreBottom(parseType('Never'), parseType('Null')); // MOREBOTTOM(T, Never) = false - isNotMoreBottom(neverQuestion, neverNone); + isNotMoreBottom(parseType('Never?'), parseType('Never')); - isNotMoreBottom(nullNone, neverNone); + isNotMoreBottom(parseType('Null'), parseType('Never')); // MOREBOTTOM(Null, T) = true - isMoreBottom(nullNone, neverQuestion); + isMoreBottom(parseType('Null'), parseType('Never?')); - isMoreBottom(nullNone, nullNone); + isMoreBottom(parseType('Null'), parseType('Null')); // MOREBOTTOM(T, Null) = false - isNotMoreBottom(neverQuestion, nullNone); + isNotMoreBottom(parseType('Never?'), parseType('Null')); // MOREBOTTOM(X&T, Y&S) = MOREBOTTOM(T, S) - isMoreBottom( - promotedTypeParameterTypeNone( - typeParameter('T', bound: objectQuestion), - neverNone, - ), - promotedTypeParameterTypeQuestion( - typeParameter('S', bound: objectQuestion), - neverNone, - ), - ); + withTypeParameterScope('T extends Object?, S extends Object?', (scope) { + isMoreBottom( + scope.parseType('T & Never'), + scope.parseType('(S & Never)?'), + ); + }); // MOREBOTTOM(X&T, S) = true - isMoreBottom( - promotedTypeParameterTypeNone( - typeParameter('T', bound: objectQuestion), - neverNone, - ), - typeParameterTypeNone(typeParameter('S', bound: neverNone)), - ); + withTypeParameterScope('T extends Object?, S extends Never', (scope) { + isMoreBottom(scope.parseType('T & Never'), scope.parseType('S')); + }); // MOREBOTTOM(T, X&S) = false - isNotMoreBottom( - typeParameterTypeNone(typeParameter('T', bound: neverNone)), - promotedTypeParameterTypeNone( - typeParameter('S', bound: objectQuestion), - neverNone, - ), - ); + withTypeParameterScope('T extends Never, S extends Object?', (scope) { + isNotMoreBottom(scope.parseType('T'), scope.parseType('S & Never')); + }); // MOREBOTTOM(X extends T, Y extends S) = MOREBOTTOM(T, S) - isMoreBottom( - typeParameterTypeNone(typeParameter('T', bound: neverNone)), - typeParameterTypeQuestion(typeParameter('S', bound: neverNone)), - ); + withTypeParameterScope('T extends Never, S extends Never', (scope) { + isMoreBottom(scope.parseType('T'), scope.parseType('S?')); + }); } test_isMoreTop() { // MORETOP(void, T) = true - isMoreTop(voidNone, voidNone); - isMoreTop(voidNone, dynamicType); - isMoreTop(voidNone, invalidType); - isMoreTop(voidNone, objectNone); - isMoreTop(voidNone, objectQuestion); - isMoreTop(voidNone, futureOrNone(objectNone)); - isMoreTop(voidNone, futureOrNone(objectQuestion)); + isMoreTop(parseType('void'), parseType('void')); + isMoreTop(parseType('void'), parseType('dynamic')); + isMoreTop(parseType('void'), parseType('InvalidType')); + isMoreTop(parseType('void'), parseType('Object')); + isMoreTop(parseType('void'), parseType('Object?')); + isMoreTop(parseType('void'), parseType('FutureOr')); + isMoreTop(parseType('void'), parseType('FutureOr')); // MORETOP(T, void) = false - isNotMoreTop(dynamicType, voidNone); - isNotMoreTop(invalidType, voidNone); - isNotMoreTop(objectNone, voidNone); - isNotMoreTop(objectQuestion, voidNone); - isNotMoreTop(futureOrNone(objectNone), voidNone); - isNotMoreTop(futureOrNone(objectQuestion), voidNone); + isNotMoreTop(parseType('dynamic'), parseType('void')); + isNotMoreTop(parseType('InvalidType'), parseType('void')); + isNotMoreTop(parseType('Object'), parseType('void')); + isNotMoreTop(parseType('Object?'), parseType('void')); + isNotMoreTop(parseType('FutureOr'), parseType('void')); + isNotMoreTop(parseType('FutureOr'), parseType('void')); // MORETOP(dynamic, T) = true - isMoreTop(dynamicType, dynamicType); - isMoreTop(dynamicType, objectNone); - isMoreTop(dynamicType, objectQuestion); - isMoreTop(dynamicType, futureOrNone(objectNone)); - isMoreTop(dynamicType, futureOrNone(objectQuestion)); + isMoreTop(parseType('dynamic'), parseType('dynamic')); + isMoreTop(parseType('dynamic'), parseType('Object')); + isMoreTop(parseType('dynamic'), parseType('Object?')); + isMoreTop(parseType('dynamic'), parseType('FutureOr')); + isMoreTop(parseType('dynamic'), parseType('FutureOr')); - // MORETOP(invalidType, T) = true - isMoreTop(invalidType, dynamicType); - isMoreTop(invalidType, objectNone); - isMoreTop(invalidType, objectQuestion); - isMoreTop(invalidType, futureOrNone(objectNone)); - isMoreTop(invalidType, futureOrNone(objectQuestion)); + // MORETOP(parseType('InvalidType'), T) = true + isMoreTop(parseType('InvalidType'), parseType('dynamic')); + isMoreTop(parseType('InvalidType'), parseType('Object')); + isMoreTop(parseType('InvalidType'), parseType('Object?')); + isMoreTop(parseType('InvalidType'), parseType('FutureOr')); + isMoreTop(parseType('InvalidType'), parseType('FutureOr')); // MORETOP(T, dynamic) = false - isNotMoreTop(objectNone, dynamicType); - isNotMoreTop(objectQuestion, dynamicType); - isNotMoreTop(futureOrNone(objectNone), dynamicType); - isNotMoreTop(futureOrNone(objectQuestion), dynamicType); + isNotMoreTop(parseType('Object'), parseType('dynamic')); + isNotMoreTop(parseType('Object?'), parseType('dynamic')); + isNotMoreTop(parseType('FutureOr'), parseType('dynamic')); + isNotMoreTop(parseType('FutureOr'), parseType('dynamic')); - // MORETOP(T, invalidType) = false - isNotMoreTop(objectNone, invalidType); - isNotMoreTop(objectQuestion, invalidType); - isNotMoreTop(futureOrNone(objectNone), invalidType); - isNotMoreTop(futureOrNone(objectQuestion), invalidType); + // MORETOP(T, parseType('InvalidType')) = false + isNotMoreTop(parseType('Object'), parseType('InvalidType')); + isNotMoreTop(parseType('Object?'), parseType('InvalidType')); + isNotMoreTop(parseType('FutureOr'), parseType('InvalidType')); + isNotMoreTop(parseType('FutureOr'), parseType('InvalidType')); // MORETOP(Object, T) = true - isMoreTop(objectNone, objectNone); - isMoreTop(objectNone, objectQuestion); - isMoreTop(objectNone, futureOrNone(objectNone)); - isMoreTop(objectNone, futureOrQuestion(objectNone)); + isMoreTop(parseType('Object'), parseType('Object')); + isMoreTop(parseType('Object'), parseType('Object?')); + isMoreTop(parseType('Object'), parseType('FutureOr')); + isMoreTop(parseType('Object'), parseType('FutureOr?')); // MORETOP(T, Object) = false - isNotMoreTop(objectQuestion, objectNone); - isNotMoreTop(futureOrNone(objectNone), objectNone); - isNotMoreTop(futureOrQuestion(objectNone), objectNone); + isNotMoreTop(parseType('Object?'), parseType('Object')); + isNotMoreTop(parseType('FutureOr'), parseType('Object')); + isNotMoreTop(parseType('FutureOr?'), parseType('Object')); // MORETOP(T?, S?) = MORETOP(T, S) - isMoreTop(objectQuestion, objectQuestion); - isMoreTop(futureOrQuestion(voidNone), futureOrQuestion(voidNone)); - isMoreTop(futureOrQuestion(voidNone), futureOrQuestion(dynamicType)); - isMoreTop(futureOrQuestion(voidNone), futureOrQuestion(invalidType)); - isMoreTop(futureOrQuestion(voidNone), futureOrQuestion(objectNone)); + isMoreTop(parseType('Object?'), parseType('Object?')); + isMoreTop(parseType('FutureOr?'), parseType('FutureOr?')); + isMoreTop(parseType('FutureOr?'), parseType('FutureOr?')); + isMoreTop( + parseType('FutureOr?'), + parseType('FutureOr?'), + ); + isMoreTop(parseType('FutureOr?'), parseType('FutureOr?')); // MORETOP(T, S?) = true - isMoreTop(futureOrNone(objectNone), futureOrQuestion(voidNone)); - isMoreTop(futureOrNone(objectNone), futureOrQuestion(dynamicType)); - isMoreTop(futureOrNone(objectNone), futureOrQuestion(invalidType)); - isMoreTop(futureOrNone(objectNone), futureOrQuestion(objectNone)); + isMoreTop(parseType('FutureOr'), parseType('FutureOr?')); + isMoreTop(parseType('FutureOr'), parseType('FutureOr?')); + isMoreTop( + parseType('FutureOr'), + parseType('FutureOr?'), + ); + isMoreTop(parseType('FutureOr'), parseType('FutureOr?')); // MORETOP(T?, S) = false - isNotMoreTop(futureOrQuestion(voidNone), futureOrNone(objectNone)); - isNotMoreTop(futureOrQuestion(dynamicType), futureOrNone(objectNone)); - isNotMoreTop(futureOrQuestion(invalidType), futureOrNone(objectNone)); - isNotMoreTop(futureOrQuestion(objectNone), futureOrNone(objectNone)); + isNotMoreTop(parseType('FutureOr?'), parseType('FutureOr')); + isNotMoreTop( + parseType('FutureOr?'), + parseType('FutureOr'), + ); + isNotMoreTop( + parseType('FutureOr?'), + parseType('FutureOr'), + ); + isNotMoreTop(parseType('FutureOr?'), parseType('FutureOr')); // MORETOP(FutureOr, FutureOr) = MORETOP(T, S) - isMoreTop(futureOrNone(voidNone), futureOrNone(voidNone)); - isMoreTop(futureOrNone(voidNone), futureOrNone(dynamicType)); - isMoreTop(futureOrNone(voidNone), futureOrNone(invalidType)); - isMoreTop(futureOrNone(voidNone), futureOrNone(objectNone)); - isNotMoreTop(futureOrNone(dynamicType), futureOrNone(voidNone)); - isNotMoreTop(futureOrNone(invalidType), futureOrNone(voidNone)); - isNotMoreTop(futureOrNone(objectNone), futureOrNone(voidNone)); + isMoreTop(parseType('FutureOr'), parseType('FutureOr')); + isMoreTop(parseType('FutureOr'), parseType('FutureOr')); + isMoreTop(parseType('FutureOr'), parseType('FutureOr')); + isMoreTop(parseType('FutureOr'), parseType('FutureOr')); + isNotMoreTop(parseType('FutureOr'), parseType('FutureOr')); + isNotMoreTop( + parseType('FutureOr'), + parseType('FutureOr'), + ); + isNotMoreTop(parseType('FutureOr'), parseType('FutureOr')); } test_isNull() { // NULL(Null) is true - isNull(nullNone); + isNull(parseType('Null')); // NULL(T?) is true iff NULL(T) or BOTTOM(T) - isNull(neverQuestion); - isNull(typeParameterTypeQuestion(typeParameter('T', bound: neverNone))); + isNull(parseType('Never?')); + withTypeParameterScope('T extends Never', (scope) { + isNull(scope.parseType('T?')); + }); // NULL(T) is false otherwise - isNotNull(dynamicType); - isNotNull(invalidType); - isNotNull(voidNone); + isNotNull(parseType('dynamic')); + isNotNull(parseType('InvalidType')); + isNotNull(parseType('void')); - isNotNull(objectNone); - isNotNull(objectQuestion); + isNotNull(parseType('Object')); + isNotNull(parseType('Object?')); - isNotNull(intNone); - isNotNull(intQuestion); + isNotNull(parseType('int')); + isNotNull(parseType('int?')); - isNotNull(futureOrNone(nullNone)); + isNotNull(parseType('FutureOr')); - isNotNull(futureOrQuestion(nullNone)); + isNotNull(parseType('FutureOr?')); } test_isObject() { // OBJECT(Object) is true - isObject(objectNone); - isNotObject(objectQuestion); + isObject(parseType('Object')); + isNotObject(parseType('Object?')); // OBJECT(FutureOr) is OBJECT(T) - isObject(futureOrNone(objectNone)); - isNotObject(futureOrNone(objectQuestion)); + isObject(parseType('FutureOr')); + isNotObject(parseType('FutureOr')); - isNotObject(futureOrQuestion(objectNone)); - isNotObject(futureOrQuestion(objectQuestion)); + isNotObject(parseType('FutureOr?')); + isNotObject(parseType('FutureOr?')); // OBJECT(T) is false otherwise - isNotObject(dynamicType); - isNotObject(invalidType); - isNotObject(voidNone); - isNotObject(intNone); + isNotObject(parseType('dynamic')); + isNotObject(parseType('InvalidType')); + isNotObject(parseType('void')); + isNotObject(parseType('int')); } test_isTop() { // TOP(T?) is true iff TOP(T) or OBJECT(T) - isTop(objectQuestion); - isTop(futureOrQuestion(dynamicType)); - isTop(futureOrQuestion(invalidType)); - isTop(futureOrQuestion(voidNone)); + isTop(parseType('Object?')); + isTop(parseType('FutureOr?')); + isTop(parseType('FutureOr?')); + isTop(parseType('FutureOr?')); - isTop(futureOrQuestion(objectNone)); - isTop(futureOrQuestion(objectQuestion)); + isTop(parseType('FutureOr?')); + isTop(parseType('FutureOr?')); - isNotTop(futureOrQuestion(intNone)); - isNotTop(futureOrQuestion(intQuestion)); + isNotTop(parseType('FutureOr?')); + isNotTop(parseType('FutureOr?')); // TOP(dynamic) is true - isTop(dynamicType); - isTop(invalidType); + isTop(parseType('dynamic')); + isTop(parseType('InvalidType')); expect(typeSystem.isTop(UnknownInferredType.instance), isTrue); // TOP(void) is true - isTop(voidNone); + isTop(parseType('void')); // TOP(FutureOr) is TOP(T) - isTop(futureOrNone(dynamicType)); - isTop(futureOrNone(invalidType)); - isTop(futureOrNone(voidNone)); + isTop(parseType('FutureOr')); + isTop(parseType('FutureOr')); + isTop(parseType('FutureOr')); - isNotTop(futureOrNone(objectNone)); - isTop(futureOrNone(objectQuestion)); + isNotTop(parseType('FutureOr')); + isTop(parseType('FutureOr')); // TOP(T) is false otherwise - isNotTop(objectNone); + isNotTop(parseType('Object')); - isNotTop(intNone); - isNotTop(intQuestion); + isNotTop(parseType('int')); + isNotTop(parseType('int?')); - isNotTop(neverNone); - isNotTop(neverQuestion); + isNotTop(parseType('Never')); + isNotTop(parseType('Never?')); } /// [TypeSystemImpl.isMoreBottom] can be used only for `BOTTOM` or `NULL` @@ -408,32 +410,29 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, T1); } - check(neverNone, objectNone); - check(neverNone, objectQuestion); + check(parseType('Never'), parseType('Object')); + check(parseType('Never'), parseType('Object?')); - check(neverNone, intNone); - check(neverNone, intQuestion); + check(parseType('Never'), parseType('int')); + check(parseType('Never'), parseType('int?')); - check(neverNone, listNone(intNone)); - check(neverNone, listQuestion(intNone)); + check(parseType('Never'), parseType('List')); + check(parseType('Never'), parseType('List?')); - check(neverNone, futureOrNone(intNone)); - check(neverNone, futureOrQuestion(intNone)); + check(parseType('Never'), parseType('FutureOr')); + check(parseType('Never'), parseType('FutureOr?')); - { - var T = typeParameterTypeNone(typeParameter('T', bound: neverNone)); - check(T, intNone); - check(T, intQuestion); - } + withTypeParameterScope('T extends Never', (scope) { + var T = scope.parseType('T'); + check(T, parseType('int')); + check(T, parseType('int?')); + }); - { - var T = promotedTypeParameterTypeNone( - typeParameter('T', bound: objectQuestion), - neverNone, - ); - check(T, intNone); - check(T, intQuestion); - } + withTypeParameterScope('T extends Object?', (scope) { + var T = scope.parseType('T & Never'); + check(T, parseType('int')); + check(T, parseType('int?')); + }); } test_bottom_bottom() { @@ -443,209 +442,185 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, T1); } - check( - neverNone, - typeParameterTypeNone(typeParameter('T', bound: neverNone)), - ); + withTypeParameterScope('T extends Never', (scope) { + check(parseType('Never'), scope.parseType('T')); + }); - check( - neverNone, - promotedTypeParameterTypeNone( - typeParameter('T', bound: objectQuestion), - neverNone, - ), - ); + withTypeParameterScope('T extends Object?', (scope) { + check(parseType('Never'), scope.parseType('T & Never')); + }); } test_functionType2_parameters_conflicts() { _checkGreatestLowerBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - neverNone, + parseFunctionType('void Function(int a)'), + parseFunctionType('void Function({int a})'), + parseType('Never'), ); _checkGreatestLowerBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - neverNone, + parseFunctionType('void Function([int a])'), + parseFunctionType('void Function({int a})'), + parseType('Never'), ); } test_functionType2_parameters_named() { - FunctionTypeImpl build( - List requiredTypes, - Map namedMap, - Map namedRequiredMap, - ) { - var formalParameters = []; - - for (var requiredType in requiredTypes) { - formalParameters.add(requiredParameter(type: requiredType)); - } - - for (var entry in namedMap.entries) { - formalParameters.add( - namedParameter(name: entry.key, type: entry.value), - ); - } - - for (var entry in namedRequiredMap.entries) { - formalParameters.add( - namedRequiredParameter(name: entry.key, type: entry.value), - ); - } - - return functionTypeNone( - returnType: voidNone, - formalParameters: formalParameters, - ); - } - - void check(FunctionTypeImpl T1, FunctionTypeImpl T2, TypeImpl expected) { - _checkGreatestLowerBound(T1, T2, expected); - } - - check(build([], {}, {}), build([], {}, {}), build([], {}, {})); + _checkGreatestLowerBound( + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + ); { - check( - build([], {'a': intNone}, {}), - build([], {'a': intNone}, {}), - build([], {'a': intNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int a})'), ); - check( - build([], {'a': intNone}, {}), - build([], {}, {'a': intNone}), - build([], {'a': intNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function({int a})'), ); - check( - build([], {}, {'a': intNone}), - build([], {}, {'a': intNone}), - build([], {}, {'a': intNone}), + _checkGreatestLowerBound( + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function({required int a})'), ); } { - check( - build([], {'a': intNone, 'b': intNone}, {}), - build([], {'a': intNone, 'c': intNone}, {}), - build([], {'a': intNone, 'b': intNone, 'c': intNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a, int b})'), + parseFunctionType('void Function({int a, int c})'), + parseFunctionType('void Function({int a, int b, int c})'), ); - check( - build([], {'a': intNone}, {'b': intNone}), - build([], {'a': intNone}, {'c': intNone}), - build([], {'a': intNone, 'b': intNone, 'c': intNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a, required int b})'), + parseFunctionType('void Function({int a, required int c})'), + parseFunctionType('void Function({int a, int b, int c})'), ); } { - check( - build([], {'a': intNone}, {}), - build([], {'a': numNone}, {}), - build([], {'a': numNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({num a})'), + parseFunctionType('void Function({num a})'), ); - check( - build([], {'a': intNone}, {}), - build([], {'a': doubleNone}, {}), - build([], {'a': numNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({double a})'), + parseFunctionType('void Function({num a})'), ); - check( - build([], {'a': intNone}, {}), - build([], {'a': doubleQuestion}, {}), - build([], {'a': numQuestion}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({double? a})'), + parseFunctionType('void Function({num? a})'), ); - check( - build([], {'a': intNone}, {}), - build([], {'a': doubleNone}, {}), - build([], {'a': numNone}, {}), + _checkGreatestLowerBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({double a})'), + parseFunctionType('void Function({num a})'), ); } } test_functionType2_parameters_positional() { - FunctionTypeImpl build( - List requiredTypes, - List positionalTypes, - ) { - var formalParameters = []; - - for (var requiredType in requiredTypes) { - formalParameters.add(requiredParameter(type: requiredType)); - } - - for (var positionalType in positionalTypes) { - formalParameters.add(positionalParameter(type: positionalType)); - } - - return functionTypeNone( - returnType: voidNone, - formalParameters: formalParameters, - ); - } - - void check(FunctionTypeImpl T1, FunctionTypeImpl T2, TypeImpl expected) { - _checkGreatestLowerBound(T1, T2, expected); - } - - check(build([], []), build([], []), build([], [])); - - check(build([intNone], []), build([intNone], []), build([intNone], [])); - - check(build([intNone], []), build([numNone], []), build([numNone], [])); - - check(build([intNone], []), build([doubleNone], []), build([numNone], [])); - - check( - build([intNone], []), - build([doubleQuestion], []), - build([numQuestion], []), + _checkGreatestLowerBound( + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), ); - check(build([intNone], []), build([doubleNone], []), build([numNone], [])); + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(int)'), + ); + + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(num)'), + parseFunctionType('void Function(num)'), + ); + + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(double)'), + parseFunctionType('void Function(num)'), + ); + + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(double?)'), + parseFunctionType('void Function(num?)'), + ); + + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(double)'), + parseFunctionType('void Function(num)'), + ); { - check(build([intNone], []), build([], [intNone]), build([], [intNone])); + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + ); - check(build([intNone], []), build([], []), build([], [intNone])); + _checkGreatestLowerBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function()'), + parseFunctionType('void Function([int])'), + ); - check(build([], [intNone]), build([], [intNone]), build([], [intNone])); + _checkGreatestLowerBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + ); - check(build([], [intNone]), build([], []), build([], [intNone])); + _checkGreatestLowerBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function()'), + parseFunctionType('void Function([int])'), + ); } } test_functionType2_returnType() { - void check(TypeImpl T1_ret, TypeImpl T2_ret, TypeImpl expected_ret) { - _checkGreatestLowerBound( - functionTypeNone(returnType: T1_ret), - functionTypeNone(returnType: T2_ret), - functionTypeNone(returnType: expected_ret), - ); - } + _checkGreatestLowerBound( + parseFunctionType('int Function()'), + parseFunctionType('int Function()'), + parseFunctionType('int Function()'), + ); - check(intNone, intNone, intNone); - check(intNone, numNone, intNone); + _checkGreatestLowerBound( + parseFunctionType('int Function()'), + parseFunctionType('num Function()'), + parseFunctionType('int Function()'), + ); - check(intNone, voidNone, intNone); - check(intNone, neverNone, neverNone); + _checkGreatestLowerBound( + parseFunctionType('int Function()'), + parseFunctionType('void Function()'), + parseFunctionType('int Function()'), + ); + + _checkGreatestLowerBound( + parseFunctionType('int Function()'), + parseFunctionType('Never Function()'), + parseFunctionType('Never Function()'), + ); } test_functionType2_typeParameters() { @@ -657,112 +632,91 @@ class LowerBoundTest extends _BoundsTestBase { } check( - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T')], - ), - functionTypeNone(returnType: voidNone), - neverNone, + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + parseType('Never'), ); check( - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T', bound: intNone)], - ), - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T', bound: numNone)], - ), - neverNone, + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + parseType('Never'), ); - { - var T = typeParameter('T', bound: numNone); - var U = typeParameter('U', bound: numNone); - var R = typeParameter('R', bound: numNone); - check( - functionTypeNone( - returnType: typeParameterTypeNone(T), - typeParameters: [T], - ), - functionTypeNone( - returnType: typeParameterTypeNone(U), - typeParameters: [U], - ), - functionTypeNone( - returnType: typeParameterTypeNone(R), - typeParameters: [R], - ), - ); - } + check( + parseFunctionType('T Function()'), + parseFunctionType('U Function()'), + parseFunctionType('R Function()'), + ); } test_functionType_interfaceType() { - void check(FunctionTypeImpl T1, InterfaceTypeImpl T2, TypeImpl expected) { + void check(FunctionTypeImpl T1, TypeImpl T2, TypeImpl expected) { _checkGreatestLowerBound(T1, T2, expected); } - check(functionTypeNone(returnType: voidNone), intNone, neverNone); + check( + parseFunctionType('void Function()'), + parseType('int'), + parseType('Never'), + ); } test_functionType_interfaceType_Function() { void check(FunctionTypeImpl T1) { _assertNullabilityNone(T1); - _checkGreatestLowerBound(T1, functionNone, T1); + _checkGreatestLowerBound(T1, parseType('Function'), T1); } - check(functionTypeNone(returnType: voidNone)); + check(parseFunctionType('void Function()')); - check( - functionTypeNone( - returnType: intNone, - formalParameters: [requiredParameter(type: numQuestion)], - ), - ); + check(parseFunctionType('int Function(num?)')); } test_futureOr() { - InterfaceTypeImpl futureOrFunction(TypeImpl T, String str) { - var result = futureOrNone( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T)], - ), - ); + InterfaceTypeImpl futureOrFunction(String str) { + var result = parseInterfaceType(str); expect(result.getDisplayString(), str); return result; } // DOWN(FutureOr, FutureOr) = FutureOr, S = DOWN(T1, T2) _checkGreatestLowerBound( - futureOrNone(intNone), - futureOrNone(numNone), - futureOrNone(intNone), + parseType('FutureOr'), + parseType('FutureOr'), + parseType('FutureOr'), ); _checkGreatestLowerBound( - futureOrFunction(intNone, 'FutureOr'), - futureOrFunction(doubleNone, 'FutureOr'), - futureOrFunction(numNone, 'FutureOr'), + futureOrFunction('FutureOr'), + futureOrFunction('FutureOr'), + futureOrFunction('FutureOr'), ); // DOWN(FutureOr, Future) = Future, S = DOWN(T1, T2) // DOWN(Future, FutureOr) = Future, S = DOWN(T1, T2) _checkGreatestLowerBound( - futureOrNone(numNone), - futureNone(intNone), - futureNone(intNone), + parseType('FutureOr'), + parseType('Future'), + parseType('Future'), ); _checkGreatestLowerBound( - futureOrNone(intNone), - futureNone(numNone), - futureNone(intNone), + parseType('FutureOr'), + parseType('Future'), + parseType('Future'), ); // DOWN(FutureOr, T2) = S, S = DOWN(T1, T2) // DOWN(T1, FutureOr) = S, S = DOWN(T1, T2) - _checkGreatestLowerBound(futureOrNone(numNone), intNone, intNone); - _checkGreatestLowerBound(futureOrNone(intNone), numNone, intNone); + _checkGreatestLowerBound( + parseType('FutureOr'), + parseType('int'), + parseType('int'), + ); + _checkGreatestLowerBound( + parseType('FutureOr'), + parseType('num'), + parseType('int'), + ); } test_identical() { @@ -770,26 +724,38 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(type, type, type); } - check(intNone); - check(intQuestion); - check(listNone(intNone)); + check(parseType('int')); + check(parseType('int?')); + check(parseType('List')); } test_interfaceType2() { - void check(InterfaceTypeImpl T1, InterfaceTypeImpl T2, TypeImpl expected) { + void check(TypeImpl T1, TypeImpl T2, TypeImpl expected) { _assertNullabilityNone(T1); _assertNullabilityNone(T2); _checkGreatestLowerBound(T1, T2, expected); } - check(intNone, intNone, intNone); - check(numNone, intNone, intNone); - check(doubleNone, intNone, neverNone); + check(parseType('int'), parseType('int'), parseType('int')); + check(parseType('num'), parseType('int'), parseType('int')); + check(parseType('double'), parseType('int'), parseType('Never')); - check(listNone(intNone), listNone(intNone), listNone(intNone)); - check(listNone(numNone), listNone(intNone), listNone(intNone)); - check(listNone(doubleNone), listNone(intNone), neverNone); + check( + parseType('List'), + parseType('List'), + parseType('List'), + ); + check( + parseType('List'), + parseType('List'), + parseType('List'), + ); + check( + parseType('List'), + parseType('List'), + parseType('Never'), + ); } void test_interfaceType2_interfaces() { @@ -803,12 +769,10 @@ class LowerBoundTest extends _BoundsTestBase { ClassSpec('class C implements B'), ], ); - var A = classElement('A'); - var C = classElement('C'); _checkGreatestLowerBound( - interfaceTypeNone(A), - interfaceTypeNone(C), - interfaceTypeNone(C), + parseInterfaceType('A'), + parseInterfaceType('C'), + parseInterfaceType('C'), ); } @@ -825,21 +789,21 @@ class LowerBoundTest extends _BoundsTestBase { ClassSpec('class D extends A with B, C'), ], ); - var A = classElement('A'); - var typeA = interfaceTypeNone(A); - - var B = classElement('B'); - var typeB = interfaceTypeNone(B); - - var C = classElement('C'); - var typeC = interfaceTypeNone(C); - - var D = classElement('D'); - var typeD = interfaceTypeNone(D); - - _checkGreatestLowerBound(typeA, typeD, typeD); - _checkGreatestLowerBound(typeB, typeD, typeD); - _checkGreatestLowerBound(typeC, typeD, typeD); + _checkGreatestLowerBound( + parseInterfaceType('A'), + parseInterfaceType('D'), + parseInterfaceType('D'), + ); + _checkGreatestLowerBound( + parseInterfaceType('B'), + parseInterfaceType('D'), + parseInterfaceType('D'), + ); + _checkGreatestLowerBound( + parseInterfaceType('C'), + parseInterfaceType('D'), + parseInterfaceType('D'), + ); } void test_interfaceType2_superType() { @@ -853,12 +817,10 @@ class LowerBoundTest extends _BoundsTestBase { ClassSpec('class C extends B'), ], ); - var A = classElement('A'); - var C = classElement('C'); _checkGreatestLowerBound( - interfaceTypeNone(A), - interfaceTypeNone(C), - interfaceTypeNone(C), + parseInterfaceType('A'), + parseInterfaceType('C'), + parseInterfaceType('C'), ); } @@ -873,13 +835,13 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, expected); } - check(intNone, intQuestion, intNone); + check(parseType('int'), parseType('int?'), parseType('int')); - check(numNone, intQuestion, intNone); - check(intNone, numQuestion, intNone); + check(parseType('num'), parseType('int?'), parseType('int')); + check(parseType('int'), parseType('num?'), parseType('int')); - check(doubleNone, intQuestion, neverNone); - check(intNone, doubleQuestion, neverNone); + check(parseType('double'), parseType('int?'), parseType('Never')); + check(parseType('int'), parseType('double?'), parseType('Never')); } test_null_any() { @@ -888,31 +850,31 @@ class LowerBoundTest extends _BoundsTestBase { _assertNotNull(T2); _assertNotTop(T2); - _checkGreatestLowerBound(nullNone, T2, expected); + _checkGreatestLowerBound(parseType('Null'), T2, expected); } void checkNull(TypeImpl T2) { - check(T2, nullNone); + check(T2, parseType('Null')); } void checkNever(TypeImpl T2) { - check(T2, neverNone); + check(T2, parseType('Never')); } - checkNull(futureOrNone(nullNone)); + checkNull(parseType('FutureOr')); - checkNull(futureOrQuestion(nullNone)); + checkNull(parseType('FutureOr?')); - checkNever(objectNone); + checkNever(parseType('Object')); - checkNever(intNone); - checkNull(intQuestion); + checkNever(parseType('int')); + checkNull(parseType('int?')); - checkNever(listNone(intNone)); - checkNull(listQuestion(intNone)); + checkNever(parseType('List')); + checkNull(parseType('List?')); - checkNever(listNone(intQuestion)); - checkNull(listQuestion(intQuestion)); + checkNever(parseType('List')); + checkNull(parseType('List?')); } test_null_null() { @@ -926,54 +888,45 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, T1); } - check(nullNone, nullNone); + check(parseType('Null'), parseType('Null')); } test_object_any() { void check(TypeImpl T2, TypeImpl expected) { _assertNotObject(T2); - _checkGreatestLowerBound(objectNone, T2, expected); + _checkGreatestLowerBound(parseType('Object'), T2, expected); } void checkNever(TypeImpl T2) { - check(T2, neverNone); + check(T2, parseType('Never')); } - check(intNone, intNone); - check(intQuestion, intNone); + check(parseType('int'), parseType('int')); + check(parseType('int?'), parseType('int')); - check(futureOrNone(intNone), futureOrNone(intNone)); - check(futureOrQuestion(intNone), futureOrNone(intNone)); - check(futureOrNone(intNone), futureOrNone(intNone)); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr?'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); - checkNever(futureOrNone(intQuestion)); - checkNever(futureOrQuestion(intQuestion)); - checkNever(futureOrNone(intQuestion)); + checkNever(parseType('FutureOr')); + checkNever(parseType('FutureOr?')); + checkNever(parseType('FutureOr')); - { - var T = typeParameter('T', bound: objectNone); - check(typeParameterTypeNone(T), typeParameterTypeNone(T)); - check(typeParameterTypeQuestion(T), typeParameterTypeNone(T)); - } + withTypeParameterScope('T extends Object', (scope) { + check(scope.parseType('T'), scope.parseType('T')); + check(scope.parseType('T?'), scope.parseType('T')); + }); - { - var T = typeParameter('T', bound: objectQuestion); - check( - typeParameterTypeNone(T), - promotedTypeParameterTypeNone(T, objectNone), - ); - check( - typeParameterTypeQuestion(T), - promotedTypeParameterTypeNone(T, objectNone), - ); - } + withTypeParameterScope('T extends Object?', (scope) { + check(scope.parseType('T'), scope.parseType('T & Object')); + check(scope.parseType('T?'), scope.parseType('T & Object')); + }); - { - var T = typeParameter('T', bound: futureOrNone(objectQuestion)); - checkNever(typeParameterTypeNone(T)); - checkNever(typeParameterTypeQuestion(T)); - } + withTypeParameterScope('T extends FutureOr', (scope) { + checkNever(scope.parseType('T')); + checkNever(scope.parseType('T?')); + }); } test_object_object() { @@ -984,9 +937,12 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, T1); } - check(futureOrNone(objectNone), objectNone); + check(parseType('FutureOr'), parseType('Object')); - check(futureOrNone(futureOrNone(objectNone)), futureOrNone(objectNone)); + check( + parseType('FutureOr>'), + parseType('FutureOr'), + ); } test_question_question() { @@ -1000,13 +956,13 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, expected); } - check(intQuestion, intQuestion, intQuestion); + check(parseType('int?'), parseType('int?'), parseType('int?')); - check(numQuestion, intQuestion, intQuestion); - check(intQuestion, numQuestion, intQuestion); + check(parseType('num?'), parseType('int?'), parseType('int?')); + check(parseType('int?'), parseType('num?'), parseType('int?')); - check(doubleQuestion, intQuestion, neverQuestion); - check(intQuestion, doubleQuestion, neverQuestion); + check(parseType('double?'), parseType('int?'), parseType('Never?')); + check(parseType('int?'), parseType('double?'), parseType('Never?')); } test_recordType2_differentShape() { @@ -1068,21 +1024,21 @@ class LowerBoundTest extends _BoundsTestBase { } test_self() { - var T = typeParameter('T'); + withTypeParameterScope('T', (scope) { + List types = [ + parseType('dynamic'), + parseType('InvalidType'), + parseType('void'), + parseType('Never'), + scope.parseType('T'), + parseType('int'), + parseFunctionType('void Function()'), + ]; - List types = [ - dynamicType, - invalidType, - voidNone, - neverNone, - typeParameterTypeNone(T), - intNone, - functionTypeNone(returnType: voidNone), - ]; - - for (var type in types) { - _checkGreatestLowerBound(type, type, type); - } + for (var type in types) { + _checkGreatestLowerBound(type, type, type); + } + }); } test_top_any() { @@ -1092,44 +1048,44 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, T2); } - check(voidNone, objectNone); - check(voidNone, intNone); - check(voidNone, intQuestion); - check(voidNone, listNone(intNone)); - check(voidNone, futureOrNone(intNone)); - check(voidNone, neverNone); - check(voidNone, functionTypeNone(returnType: voidNone)); - check(voidNone, typeOfString('(int, int)')); + check(parseType('void'), parseType('Object')); + check(parseType('void'), parseType('int')); + check(parseType('void'), parseType('int?')); + check(parseType('void'), parseType('List')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('Never')); + check(parseType('void'), parseFunctionType('void Function()')); + check(parseType('void'), typeOfString('(int, int)')); - check(dynamicType, objectNone); - check(dynamicType, intNone); - check(dynamicType, intQuestion); - check(dynamicType, listNone(intNone)); - check(dynamicType, futureOrNone(intNone)); - check(dynamicType, neverNone); - check(dynamicType, functionTypeNone(returnType: voidNone)); - check(dynamicType, typeOfString('(int, int)')); + check(parseType('dynamic'), parseType('Object')); + check(parseType('dynamic'), parseType('int')); + check(parseType('dynamic'), parseType('int?')); + check(parseType('dynamic'), parseType('List')); + check(parseType('dynamic'), parseType('FutureOr')); + check(parseType('dynamic'), parseType('Never')); + check(parseType('dynamic'), parseFunctionType('void Function()')); + check(parseType('dynamic'), typeOfString('(int, int)')); - check(invalidType, objectNone); - check(invalidType, intNone); - check(invalidType, intQuestion); - check(invalidType, listNone(intNone)); - check(invalidType, futureOrNone(intNone)); - check(invalidType, neverNone); - check(invalidType, functionTypeNone(returnType: voidNone)); - check(invalidType, typeOfString('(int, int)')); + check(parseType('InvalidType'), parseType('Object')); + check(parseType('InvalidType'), parseType('int')); + check(parseType('InvalidType'), parseType('int?')); + check(parseType('InvalidType'), parseType('List')); + check(parseType('InvalidType'), parseType('FutureOr')); + check(parseType('InvalidType'), parseType('Never')); + check(parseType('InvalidType'), parseFunctionType('void Function()')); + check(parseType('InvalidType'), typeOfString('(int, int)')); - check(objectQuestion, objectNone); - check(objectQuestion, intNone); - check(objectQuestion, intQuestion); - check(objectQuestion, listNone(intNone)); - check(objectQuestion, futureOrNone(intNone)); - check(objectQuestion, neverNone); - check(objectQuestion, functionTypeNone(returnType: voidNone)); - check(objectQuestion, typeOfString('(int, int)')); + check(parseType('Object?'), parseType('Object')); + check(parseType('Object?'), parseType('int')); + check(parseType('Object?'), parseType('int?')); + check(parseType('Object?'), parseType('List')); + check(parseType('Object?'), parseType('FutureOr')); + check(parseType('Object?'), parseType('Never')); + check(parseType('Object?'), parseFunctionType('void Function()')); + check(parseType('Object?'), typeOfString('(int, int)')); - check(futureOrNone(voidNone), intNone); - check(futureOrQuestion(voidNone), intNone); + check(parseType('FutureOr'), parseType('int')); + check(parseType('FutureOr?'), parseType('int')); } test_top_top() { @@ -1139,51 +1095,52 @@ class LowerBoundTest extends _BoundsTestBase { _checkGreatestLowerBound(T1, T2, T2); } - check(voidNone, dynamicType); - check(voidNone, invalidType); - check(voidNone, objectQuestion); - check(voidNone, futureOrNone(voidNone)); - check(voidNone, futureOrNone(dynamicType)); - check(voidNone, futureOrNone(invalidType)); - check(voidNone, futureOrNone(objectQuestion)); + check(parseType('void'), parseType('dynamic')); + check(parseType('void'), parseType('InvalidType')); + check(parseType('void'), parseType('Object?')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('FutureOr')); - check(dynamicType, objectQuestion); - check(dynamicType, futureOrNone(voidNone)); - check(dynamicType, futureOrNone(dynamicType)); - check(dynamicType, futureOrNone(objectQuestion)); + check(parseType('dynamic'), parseType('Object?')); + check(parseType('dynamic'), parseType('FutureOr')); + check(parseType('dynamic'), parseType('FutureOr')); + check(parseType('dynamic'), parseType('FutureOr')); - check(invalidType, objectQuestion); - check(invalidType, futureOrNone(voidNone)); - check(invalidType, futureOrNone(dynamicType)); - check(invalidType, futureOrNone(objectQuestion)); + check(parseType('InvalidType'), parseType('Object?')); + check(parseType('InvalidType'), parseType('FutureOr')); + check(parseType('InvalidType'), parseType('FutureOr')); + check(parseType('InvalidType'), parseType('FutureOr')); - check(objectQuestion, futureOrQuestion(voidNone)); - check(objectQuestion, futureOrQuestion(dynamicType)); - check(objectQuestion, futureOrQuestion(invalidType)); - check(objectQuestion, futureOrQuestion(objectNone)); - check(objectQuestion, futureOrQuestion(objectQuestion)); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); - check(futureOrNone(voidNone), objectQuestion); - check(futureOrNone(dynamicType), objectQuestion); - check(futureOrNone(invalidType), objectQuestion); - check(futureOrNone(objectQuestion), objectQuestion); + check(parseType('FutureOr'), parseType('Object?')); + check(parseType('FutureOr'), parseType('Object?')); + check(parseType('FutureOr'), parseType('Object?')); + check(parseType('FutureOr'), parseType('Object?')); - check(futureOrNone(voidNone), futureOrNone(dynamicType)); - check(futureOrNone(voidNone), futureOrNone(invalidType)); - check(futureOrNone(voidNone), futureOrNone(objectQuestion)); - check(futureOrNone(dynamicType), futureOrNone(objectQuestion)); - check(futureOrNone(invalidType), futureOrNone(objectQuestion)); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); } test_typeParameter() { - void check({TypeImpl? bound, required TypeImpl T2}) { - var T1 = typeParameterTypeNone(typeParameter('T', bound: bound)); - _checkGreatestLowerBound(T1, T2, neverNone); + void check({String? bound, required TypeImpl T2}) { + withTypeParameterScope(bound == null ? 'T' : 'T extends $bound', (scope) { + _checkGreatestLowerBound(scope.parseType('T'), T2, parseType('Never')); + }); } - check(T2: functionTypeNone(returnType: voidNone)); - check(T2: intNone); - check(bound: numNone, T2: intNone); + check(T2: parseFunctionType('void Function()')); + check(T2: parseType('int')); + check(bound: 'num', T2: parseType('int')); } void _checkGreatestLowerBound( @@ -1238,54 +1195,18 @@ actual: $resultStr @reflectiveTest class UpperBound_FunctionTypes_Test extends _BoundsTestBase { void test_nested2_upParameterType() { - var T1 = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: intNone), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + var T1 = parseFunctionType( + 'void Function(void Function(String, int, int))', ); expect(typeString(T1), 'void Function(void Function(String, int, int))'); - var T2 = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: doubleNone), - requiredParameter(type: numNone), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + var T2 = parseFunctionType( + 'void Function(void Function(int, double, num))', ); expect(typeString(T2), 'void Function(void Function(int, double, num))'); - var expected = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: objectNone), - requiredParameter(type: numNone), - requiredParameter(type: numNone), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + var expected = parseFunctionType( + 'void Function(void Function(Object, num, num))', ); expect( typeString(expected), @@ -1296,81 +1217,24 @@ class UpperBound_FunctionTypes_Test extends _BoundsTestBase { } void test_nested3_downParameterTypes() { - var T1 = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: intNone), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + var T1 = parseFunctionType( + 'void Function(void Function(void Function(String, int, int)))', ); expect( typeString(T1), 'void Function(void Function(void Function(String, int, int)))', ); - var T2 = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: doubleNone), - requiredParameter(type: numNone), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + var T2 = parseFunctionType( + 'void Function(void Function(void Function(int, double, num)))', ); expect( typeString(T2), 'void Function(void Function(void Function(int, double, num)))', ); - var expected = functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter( - type: functionTypeNone( - formalParameters: [ - requiredParameter(type: neverNone), - requiredParameter(type: neverNone), - requiredParameter(type: intNone), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, - ), - ), - ], - returnType: voidNone, + var expected = parseFunctionType( + 'void Function(void Function(void Function(Never, Never, int)))', ); expect( typeString(expected), @@ -1381,317 +1245,232 @@ class UpperBound_FunctionTypes_Test extends _BoundsTestBase { } void test_parameters_fuzzyArrows() { - var T1 = functionTypeNone( - formalParameters: [requiredParameter(type: dynamicType)], - returnType: voidNone, - ); + var T1 = parseFunctionType('void Function(dynamic)'); - var T2 = functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ); + var T2 = parseFunctionType('void Function(int)'); - var expected = functionTypeNone( - formalParameters: [requiredParameter(type: intNone)], - returnType: voidNone, - ); + var expected = parseFunctionType('void Function(int)'); _checkLeastUpperBound(T1, T2, expected); } test_parameters_optionalNamed() { - FunctionTypeImpl build(Map namedTypes) { - return functionTypeNone( - returnType: voidNone, - formalParameters: namedTypes.entries.map((entry) { - return namedParameter(name: entry.key, type: entry.value); - }).toList(), - ); - } + _checkLeastUpperBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + ); - void check( - Map T1_named, - Map T2_named, - Map expected_named, - ) { - var T1 = build(T1_named); - var T2 = build(T2_named); - var expected = build(expected_named); - _checkLeastUpperBound(T1, T2, expected); - } + _checkLeastUpperBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int b})'), + parseFunctionType('void Function()'), + ); - check({'a': intNone}, {}, {}); - check({'a': intNone}, {'b': intNone}, {}); + _checkLeastUpperBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int a})'), + ); - check({'a': intNone}, {'a': intNone}, {'a': intNone}); - check({'a': intNone}, {'a': intQuestion}, {'a': intNone}); + _checkLeastUpperBound( + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int? a})'), + parseFunctionType('void Function({int a})'), + ); - check({'a': intNone, 'b': doubleNone}, {'a': intNone}, {'a': intNone}); + _checkLeastUpperBound( + parseFunctionType('void Function({int a, double b})'), + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({int a})'), + ); } test_parameters_optionalPositional() { - FunctionTypeImpl build(List positionalTypes) { - return functionTypeNone( - returnType: voidNone, - formalParameters: positionalTypes.map((type) { - return positionalParameter(type: type); - }).toList(), - ); - } + _checkLeastUpperBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + ); - void check( - List T1_positional, - List T2_positional, - TypeImpl expected, - ) { - var T1 = build(T1_positional); - var T2 = build(T2_positional); - _checkLeastUpperBound(T1, T2, expected); - } + _checkLeastUpperBound( + parseFunctionType('void Function([int, double])'), + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + ); - check([intNone], [], build([])); - check([intNone, doubleNone], [intNone], build([intNone])); + _checkLeastUpperBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int])'), + ); - check([intNone], [intNone], build([intNone])); - check([intNone], [intQuestion], build([intNone])); + _checkLeastUpperBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([int?])'), + parseFunctionType('void Function([int])'), + ); - check([intNone], [doubleNone], build([neverNone])); + _checkLeastUpperBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([double])'), + parseFunctionType('void Function([Never])'), + ); - check([intNone], [numNone], build([intNone])); + _checkLeastUpperBound( + parseFunctionType('void Function([int])'), + parseFunctionType('void Function([num])'), + parseFunctionType('void Function([int])'), + ); - check( - [doubleNone, numNone], - [numNone, intNone], - build([doubleNone, intNone]), + _checkLeastUpperBound( + parseFunctionType('void Function([double, num])'), + parseFunctionType('void Function([num, int])'), + parseFunctionType('void Function([double, int])'), ); } test_parameters_requiredNamed() { _checkLeastUpperBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionNone, + parseFunctionType('void Function(int a)'), + parseFunctionType('void Function({required int a})'), + parseType('Function'), ); _checkLeastUpperBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [positionalParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionNone, + parseFunctionType('void Function([int a])'), + parseFunctionType('void Function({required int a})'), + parseType('Function'), ); _checkLeastUpperBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'b', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionNone, + parseFunctionType('void Function({int b})'), + parseFunctionType('void Function({required int a})'), + parseType('Function'), ); _checkLeastUpperBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [namedParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), + parseFunctionType('void Function({int a})'), + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function({required int a})'), ); _checkLeastUpperBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [ - namedParameter(name: 'a', type: intNone), - namedRequiredParameter(name: 'b', type: intNone), - ], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'b', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'b', type: intNone)], - ), + parseFunctionType('void Function({int a, required int b})'), + parseFunctionType('void Function({required int b})'), + parseFunctionType('void Function({required int b})'), ); _checkLeastUpperBound( - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: numNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [namedRequiredParameter(name: 'a', type: intNone)], - ), + parseFunctionType('void Function({required int a})'), + parseFunctionType('void Function({required num a})'), + parseFunctionType('void Function({required int a})'), ); } test_parameters_requiredPositional() { - FunctionTypeImpl build(List requiredTypes) { - return functionTypeNone( - returnType: voidNone, - formalParameters: requiredTypes.map((type) { - return requiredParameter(type: type); - }).toList(), - ); - } + _checkLeastUpperBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function()'), + parseType('Function'), + ); - void check( - List T1_required, - List T2_required, - TypeImpl expected, - ) { - var T1 = build(T1_required); - var T2 = build(T2_required); - _checkLeastUpperBound(T1, T2, expected); - } + _checkLeastUpperBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(int)'), + ); - check([intNone], [], functionNone); + _checkLeastUpperBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(int?)'), + parseFunctionType('void Function(int)'), + ); - check([intNone], [intNone], build([intNone])); - check([intNone], [intQuestion], build([intNone])); + _checkLeastUpperBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(double)'), + parseFunctionType('void Function(Never)'), + ); - check([intNone], [doubleNone], build([neverNone])); + _checkLeastUpperBound( + parseFunctionType('void Function(int)'), + parseFunctionType('void Function(num)'), + parseFunctionType('void Function(int)'), + ); - check([intNone], [numNone], build([intNone])); - - check( - [doubleNone, numNone], - [numNone, intNone], - build([doubleNone, intNone]), + _checkLeastUpperBound( + parseFunctionType('void Function(double, num)'), + parseFunctionType('void Function(num, int)'), + parseFunctionType('void Function(double, int)'), ); } void test_parameters_requiredPositional_differentArity() { - var T1 = functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: intNone), - ], - returnType: voidNone, - ); + var T1 = parseFunctionType('void Function(int, int)'); - var T2 = functionTypeNone( - formalParameters: [ - requiredParameter(type: intNone), - requiredParameter(type: intNone), - requiredParameter(type: intNone), - ], - returnType: voidNone, - ); + var T2 = parseFunctionType('void Function(int, int, int)'); _checkLeastUpperBound(T1, T2, typeProvider.functionType); } test_returnType() { - void check(TypeImpl T1_ret, TypeImpl T2_ret, TypeImpl expected_ret) { - _checkLeastUpperBound( - functionTypeNone(returnType: T1_ret), - functionTypeNone(returnType: T2_ret), - functionTypeNone(returnType: expected_ret), - ); - } + _checkLeastUpperBound( + parseFunctionType('int Function()'), + parseFunctionType('int Function()'), + parseFunctionType('int Function()'), + ); + _checkLeastUpperBound( + parseFunctionType('int Function()'), + parseFunctionType('int? Function()'), + parseFunctionType('int? Function()'), + ); - check(intNone, intNone, intNone); - check(intNone, intQuestion, intQuestion); + _checkLeastUpperBound( + parseFunctionType('int Function()'), + parseFunctionType('num Function()'), + parseFunctionType('num Function()'), + ); + _checkLeastUpperBound( + parseFunctionType('int? Function()'), + parseFunctionType('num Function()'), + parseFunctionType('num? Function()'), + ); - check(intNone, numNone, numNone); - check(intQuestion, numNone, numQuestion); - - check(intNone, dynamicType, dynamicType); - check(intNone, invalidType, invalidType); - check(intNone, neverNone, intNone); + _checkLeastUpperBound( + parseFunctionType('int Function()'), + parseFunctionType('dynamic Function()'), + parseFunctionType('dynamic Function()'), + ); + _checkLeastUpperBound( + parseFunctionType('int Function()'), + parseFunctionType('InvalidType Function()'), + parseFunctionType('InvalidType Function()'), + ); + _checkLeastUpperBound( + parseFunctionType('int Function()'), + parseFunctionType('Never Function()'), + parseFunctionType('int Function()'), + ); } void test_sameType_withNamed() { - var T1 = functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: numNone), - namedParameter(name: 'n', type: numNone), - ], - returnType: intNone, - ); + var T1 = parseFunctionType('int Function(String, int, num, {num n})'); - var T2 = functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: numNone), - namedParameter(name: 'n', type: numNone), - ], - returnType: intNone, - ); + var T2 = parseFunctionType('int Function(String, int, num, {num n})'); - var expected = functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: numNone), - namedParameter(name: 'n', type: numNone), - ], - returnType: intNone, - ); + var expected = parseFunctionType('int Function(String, int, num, {num n})'); _checkLeastUpperBound(T1, T2, expected); } void test_sameType_withOptional() { - var T1 = functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: numNone), - positionalParameter(type: doubleNone), - ], - returnType: intNone, - ); + var T1 = parseFunctionType('int Function(String, int, num, [double])'); - var T2 = functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: numNone), - positionalParameter(type: doubleNone), - ], - returnType: intNone, - ); + var T2 = parseFunctionType('int Function(String, int, num, [double])'); - var expected = functionTypeNone( - formalParameters: [ - requiredParameter(type: stringNone), - requiredParameter(type: intNone), - requiredParameter(type: numNone), - positionalParameter(type: doubleNone), - ], - returnType: intNone, + var expected = parseFunctionType( + 'int Function(String, int, num, [double])', ); _checkLeastUpperBound(T1, T2, expected); @@ -1706,37 +1485,20 @@ class UpperBound_FunctionTypes_Test extends _BoundsTestBase { } check( - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T')], - ), - functionTypeNone(returnType: voidNone), - functionNone, + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + parseType('Function'), ); check( - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T', bound: intNone)], - ), - functionTypeNone( - returnType: voidNone, - typeParameters: [typeParameter('T', bound: numNone)], - ), - functionNone, + parseFunctionType('void Function()'), + parseFunctionType('void Function()'), + parseType('Function'), ); { - var T = typeParameter('T', bound: numNone); - var U = typeParameter('U', bound: numNone); - var T1 = functionTypeNone( - returnType: typeParameterTypeNone(T), - typeParameters: [T], - ); - var T2 = functionTypeNone( - returnType: typeParameterTypeNone(U), - typeParameters: [U], - ); + var T1 = parseFunctionType('T Function()'); + var T2 = parseFunctionType('U Function()'); { var result = typeSystem.leastUpperBound(T1, T2); var resultStr = typeString(result); @@ -1751,12 +1513,16 @@ class UpperBound_FunctionTypes_Test extends _BoundsTestBase { } test_unrelated() { - var T1 = functionTypeNone(returnType: intNone); + var T1 = parseFunctionType('int Function()'); - _checkLeastUpperBound(T1, intNone, objectNone); - _checkLeastUpperBound(T1, intQuestion, objectQuestion); + _checkLeastUpperBound(T1, parseType('int'), parseType('Object')); + _checkLeastUpperBound(T1, parseType('int?'), parseType('Object?')); - _checkLeastUpperBound(T1, futureOrNone(functionQuestion), objectQuestion); + _checkLeastUpperBound( + T1, + parseType('FutureOr'), + parseType('Object?'), + ); } } @@ -1774,13 +1540,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C implements B'), ], ); - var B = classElement('B'); - var typeB = interfaceTypeNone(B); - - var C = classElement('C'); - var typeC = interfaceTypeNone(C); - - _checkLeastUpperBound(typeB, typeC, typeB); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('B'), + ); } test_directSuperclass() { @@ -1795,28 +1559,21 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C extends B'), ], ); - var B = classElement('B'); - var typeB = interfaceTypeNone(B); - - var C = classElement('C'); - var typeC = interfaceTypeNone(C); - - _checkLeastUpperBound(typeB, typeC, typeB); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('B'), + ); } void test_directSuperclass_nullability() { buildTestLibrary( classes: [ClassSpec('class A'), ClassSpec('class B extends A')], ); - var aElement = classElement('A'); - var aQuestion = interfaceTypeQuestion(aElement); - var aNone = interfaceTypeNone(aElement); - - var bElementNone = classElement('B'); - - var bNoneQuestion = interfaceTypeQuestion(bElementNone); - - var bNoneNone = interfaceTypeNone(bElementNone); + var aQuestion = parseInterfaceType('A?'); + var aNone = parseInterfaceType('A'); + var bNoneQuestion = parseInterfaceType('B?'); + var bNoneNone = parseInterfaceType('B'); void assertLUB(TypeImpl type1, TypeImpl type2, TypeImpl expected) { expect(typeSystem.leastUpperBound(type1, type2), expected); @@ -1831,7 +1588,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { } void test_implementationsOfComparable() { - _checkLeastUpperBound(stringNone, numNone, objectNone); + _checkLeastUpperBound( + parseType('String'), + parseType('num'), + parseType('Object'), + ); } void test_mixinAndClass_constraintAndInterface() { @@ -1839,13 +1600,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { classes: [ClassSpec('class A'), ClassSpec('class B implements A')], mixins: [MixinSpec('mixin M on A')], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var M = mixinElement('M'); - - _checkLeastUpperBound(interfaceTypeNone(B), interfaceTypeNone(M), A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('M'), + parseInterfaceType('A'), + ); } void test_mixinAndClass_object() { @@ -1853,13 +1612,10 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { classes: [ClassSpec('class A')], mixins: [MixinSpec('mixin M')], ); - var A = classElement('A'); - var M = mixinElement('M'); - _checkLeastUpperBound( - interfaceTypeNone(A), - interfaceTypeNone(M), - objectNone, + parseInterfaceType('A'), + parseInterfaceType('M'), + parseType('Object'), ); } @@ -1868,21 +1624,17 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { classes: [ClassSpec('class A'), ClassSpec('class B implements A')], mixins: [MixinSpec('mixin M implements A')], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var M = mixinElement('M'); - - _checkLeastUpperBound(interfaceTypeNone(B), interfaceTypeNone(M), A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('M'), + parseInterfaceType('A'), + ); } void test_sameElement_nullability() { buildTestLibrary(classes: [ClassSpec('class A')]); - var aElement = classElement('A'); - - var aQuestion = interfaceTypeQuestion(aElement); - var aNone = interfaceTypeNone(aElement); + var aQuestion = parseInterfaceType('A?'); + var aNone = parseInterfaceType('A'); void assertLUB(TypeImpl type1, TypeImpl type2, TypeImpl expected) { expect(typeSystem.leastUpperBound(type1, type2), expected); @@ -1905,16 +1657,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { classes: [ClassSpec('class B with M'), ClassSpec('class C with M')], mixins: [MixinSpec('mixin M')], ); - var M = mixinElement('M'); - var M_none = interfaceTypeNone(M); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - _checkLeastUpperBound(B_none, C_none, M_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('M'), + ); } void test_sharedMixin2() { @@ -1935,16 +1682,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { MixinSpec('mixin M3'), ], ); - var M1 = mixinElement('M1'); - var M1_none = interfaceTypeNone(M1); - - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - _checkLeastUpperBound(A_none, B_none, M1_none); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('B'), + parseInterfaceType('M1'), + ); } void test_sharedMixin3() { @@ -1965,16 +1707,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { MixinSpec('mixin M3'), ], ); - var M1 = mixinElement('M1'); - var M1_none = interfaceTypeNone(M1); - - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - _checkLeastUpperBound(A_none, B_none, M1_none); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('B'), + parseInterfaceType('M1'), + ); } void test_sharedSuperclass1() { @@ -1989,16 +1726,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C extends A'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - _checkLeastUpperBound(B_none, C_none, A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('A'), + ); } void test_sharedSuperclass1_nullability() { @@ -2009,18 +1741,12 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C extends A'), ], ); - var aElement = classElement('A'); - var aQuestion = interfaceTypeQuestion(aElement); - var aNone = interfaceTypeNone(aElement); - - var bElementNone = classElement('B'); - var cElementNone = classElement('C'); - - var bNoneQuestion = interfaceTypeQuestion(bElementNone); - var bNoneNone = interfaceTypeNone(bElementNone); - - var cNoneQuestion = interfaceTypeQuestion(cElementNone); - var cNoneNone = interfaceTypeNone(cElementNone); + var aQuestion = parseInterfaceType('A?'); + var aNone = parseInterfaceType('A'); + var bNoneQuestion = parseInterfaceType('B?'); + var bNoneNone = parseInterfaceType('B'); + var cNoneQuestion = parseInterfaceType('C?'); + var cNoneNone = parseInterfaceType('C'); void assertLUB(TypeImpl type1, TypeImpl type2, TypeImpl expected) { expect(typeSystem.leastUpperBound(type1, type2), expected); @@ -2048,16 +1774,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class D extends C'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var D = classElement('D'); - var D_none = interfaceTypeNone(D); - - _checkLeastUpperBound(B_none, D_none, A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('D'), + parseInterfaceType('A'), + ); } void test_sharedSuperclass3() { @@ -2074,16 +1795,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class D extends B'), ], ); - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - var D = classElement('D'); - var D_none = interfaceTypeNone(D); - - _checkLeastUpperBound(C_none, D_none, B_none); + _checkLeastUpperBound( + parseInterfaceType('C'), + parseInterfaceType('D'), + parseInterfaceType('B'), + ); } void test_sharedSuperclass4() { @@ -2102,16 +1818,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C extends A implements A3'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - _checkLeastUpperBound(B_none, C_none, A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('A'), + ); } void test_sharedSuperinterface1() { @@ -2126,16 +1837,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C implements A'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - _checkLeastUpperBound(B_none, C_none, A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('A'), + ); } void test_sharedSuperinterface2() { @@ -2152,16 +1858,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class D implements C'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var D = classElement('D'); - var D_none = interfaceTypeNone(D); - - _checkLeastUpperBound(B_none, D_none, A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('D'), + parseInterfaceType('A'), + ); } void test_sharedSuperinterface3() { @@ -2178,16 +1879,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class D implements B'), ], ); - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - var D = classElement('D'); - var D_none = interfaceTypeNone(D); - - _checkLeastUpperBound(C_none, D_none, B_none); + _checkLeastUpperBound( + parseInterfaceType('C'), + parseInterfaceType('D'), + parseInterfaceType('B'), + ); } void test_sharedSuperinterface4() { @@ -2206,16 +1902,11 @@ class UpperBound_InterfaceTypes_Test extends _BoundsTestBase { ClassSpec('class C implements A, A3'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - _checkLeastUpperBound(B_none, C_none, A_none); + _checkLeastUpperBound( + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('A'), + ); } } @@ -2290,43 +1981,45 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, T2); } - check(neverNone, dynamicType); - check(neverNone, invalidType); + check(parseType('Never'), parseType('dynamic')); + check(parseType('Never'), parseType('InvalidType')); - check(neverNone, objectNone); - check(neverNone, objectQuestion); + check(parseType('Never'), parseType('Object')); + check(parseType('Never'), parseType('Object?')); - check(neverNone, intNone); - check(neverNone, intQuestion); + check(parseType('Never'), parseType('int')); + check(parseType('Never'), parseType('int?')); - check(neverNone, listNone(intNone)); - check(neverNone, listQuestion(intNone)); + check(parseType('Never'), parseType('List')); + check(parseType('Never'), parseType('List?')); - check(neverNone, futureOrNone(intNone)); - check(neverNone, futureOrQuestion(intNone)); + check(parseType('Never'), parseType('FutureOr')); + check(parseType('Never'), parseType('FutureOr?')); - check(neverNone, functionTypeNone(returnType: voidNone)); - check(neverNone, functionTypeQuestion(returnType: voidNone)); + check(parseType('Never'), parseFunctionType('void Function()')); + check(parseType('Never'), parseFunctionType('void Function()?')); { - var T = typeParameter('T'); - check(neverNone, typeParameterTypeNone(T)); - check(neverNone, typeParameterTypeQuestion(T)); + withTypeParameterScope('T', (scope) { + check(parseType('Never'), scope.parseType('T')); + check(parseType('Never'), scope.parseType('T?')); + }); } { - var T = typeParameterTypeNone(typeParameter('T', bound: neverNone)); - check(T, intNone); - check(T, intQuestion); + withTypeParameterScope('T extends Never', (scope) { + var T = scope.parseType('T'); + check(T, parseType('int')); + check(T, parseType('int?')); + }); } { - var T = promotedTypeParameterTypeNone( - typeParameter('T', bound: objectQuestion), - neverNone, - ); - check(T, intNone); - check(T, intQuestion); + withTypeParameterScope('T extends Object?', (scope) { + var T = scope.parseType('T & Never'); + check(T, parseType('int')); + check(T, parseType('int?')); + }); } } @@ -2337,18 +2030,13 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, T2); } - check( - neverNone, - typeParameterTypeNone(typeParameter('T', bound: neverNone)), - ); + withTypeParameterScope('T extends Never', (scope) { + check(parseType('Never'), scope.parseType('T')); + }); - check( - neverNone, - promotedTypeParameterTypeNone( - typeParameter('T', bound: objectQuestion), - neverNone, - ), - ); + withTypeParameterScope('T extends Object?', (scope) { + check(parseType('Never'), scope.parseType('T & Never')); + }); } void test_extensionType_implementExtensionType_implicitObjectQuestion() { @@ -2363,12 +2051,10 @@ class UpperBoundTest extends _BoundsTestBase { ExtensionTypeSpec('extension type C(Object? it) implements A'), ], ); - var A_none = interfaceTypeNone(extensionTypeElement('A')); - _checkLeastUpperBound( - interfaceTypeNone(extensionTypeElement('B')), - interfaceTypeNone(extensionTypeElement('C')), - A_none, + parseInterfaceType('B'), + parseInterfaceType('C'), + parseInterfaceType('A'), ); } @@ -2383,9 +2069,9 @@ class UpperBoundTest extends _BoundsTestBase { ], ); _checkLeastUpperBound( - interfaceTypeNone(extensionTypeElement('A')), - interfaceTypeNone(extensionTypeElement('B')), - numNone, + parseInterfaceType('A'), + parseInterfaceType('B'), + parseType('num'), ); } @@ -2400,9 +2086,9 @@ class UpperBoundTest extends _BoundsTestBase { ], ); _checkLeastUpperBound( - interfaceTypeNone(extensionTypeElement('A')), - interfaceTypeNone(extensionTypeElement('B')), - objectQuestion, + parseInterfaceType('A'), + parseInterfaceType('B'), + parseType('Object?'), ); } @@ -2413,13 +2099,10 @@ class UpperBoundTest extends _BoundsTestBase { ExtensionTypeSpec('extension type B(T it) implements Object?'), ], ); - var A = extensionTypeElement('A'); - var B = extensionTypeElement('B'); - _checkLeastUpperBound( - interfaceTypeNone(A, typeArguments: [stringNone]), - interfaceTypeNone(B, typeArguments: [numNone]), - objectNone, + parseInterfaceType('A'), + parseInterfaceType('B'), + parseType('Object'), ); } @@ -2435,98 +2118,93 @@ class UpperBoundTest extends _BoundsTestBase { ), ], ); - var A = extensionTypeElement('A'); - var B = extensionTypeElement('B'); - // A implements E, String // B implements E, num _checkLeastUpperBound( - interfaceTypeNone(A, typeArguments: [stringNone]), - interfaceTypeNone(B, typeArguments: [numNone]), - objectNone, + parseInterfaceType('A'), + parseInterfaceType('B'), + parseType('Object'), ); } test_functionType_interfaceType() { - void check( - FunctionTypeImpl T1, - InterfaceTypeImpl T2, - InterfaceTypeImpl expected, - ) { + void check(FunctionTypeImpl T1, TypeImpl T2, TypeImpl expected) { _checkLeastUpperBound(T1, T2, expected); } - check(functionTypeNone(returnType: voidNone), intNone, objectNone); + check( + parseFunctionType('void Function()'), + parseType('int'), + parseType('Object'), + ); } test_functionType_interfaceType_Function() { - void check( - FunctionTypeImpl T1, - InterfaceTypeImpl T2, - InterfaceTypeImpl expected, - ) { + void check(FunctionTypeImpl T1, TypeImpl T2, TypeImpl expected) { _checkLeastUpperBound(T1, T2, expected); } void checkNone(FunctionTypeImpl T1) { _assertNullabilityNone(T1); - check(T1, functionNone, functionNone); + check(T1, parseType('Function'), parseType('Function')); } - checkNone(functionTypeNone(returnType: voidNone)); + checkNone(parseFunctionType('void Function()')); - checkNone( - functionTypeNone( - returnType: intNone, - formalParameters: [requiredParameter(type: numQuestion)], - ), - ); + checkNone(parseFunctionType('int Function(num?)')); check( - functionTypeQuestion(returnType: voidNone), - functionNone, - functionQuestion, + parseFunctionType('void Function()?'), + parseType('Function'), + parseType('Function?'), ); } /// `UP(Future, FutureOr) = FutureOr where T3 = UP(T1, T2)` /// `UP(FutureOr, Future) = FutureOr where T3 = UP(T1, T2)` test_futureOr_future() { - void check(TypeImpl T1, TypeImpl T2, TypeImpl expected) { - _checkLeastUpperBound( - futureNone(T1), - futureOrNone(T2), - futureOrNone(expected), - ); - } + _checkLeastUpperBound( + parseType('Future'), + parseType('FutureOr'), + parseType('FutureOr'), + ); - check(intNone, doubleNone, numNone); - check(intNone, stringNone, objectNone); + _checkLeastUpperBound( + parseType('Future'), + parseType('FutureOr'), + parseType('FutureOr'), + ); } /// `UP(FutureOr, FutureOr) = FutureOr where T3 = UP(T1, T2)` test_futureOr_futureOr() { - void check(TypeImpl T1, TypeImpl T2, TypeImpl expected) { - _checkLeastUpperBound( - futureOrNone(T1), - futureOrNone(T2), - futureOrNone(expected), - ); - } + _checkLeastUpperBound( + parseType('FutureOr'), + parseType('FutureOr'), + parseType('FutureOr'), + ); - check(intNone, doubleNone, numNone); - check(intNone, stringNone, objectNone); + _checkLeastUpperBound( + parseType('FutureOr'), + parseType('FutureOr'), + parseType('FutureOr'), + ); } /// `UP(T1, FutureOr) = FutureOr where T3 = UP(T1, T2)` /// `UP(FutureOr, T2) = FutureOr where T3 = UP(T1, T2)` test_futureOr_other() { - void check(TypeImpl T1, TypeImpl T2, TypeImpl expected) { - _checkLeastUpperBound(futureOrNone(T1), T2, futureOrNone(expected)); - } + _checkLeastUpperBound( + parseType('FutureOr'), + parseType('double'), + parseType('FutureOr'), + ); - check(intNone, doubleNone, numNone); - check(intNone, stringNone, objectNone); + _checkLeastUpperBound( + parseType('FutureOr'), + parseType('String'), + parseType('FutureOr'), + ); } test_identical() { @@ -2534,19 +2212,17 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(type, type, type); } - check(intNone); - check(intQuestion); - check(listNone(intNone)); + check(parseType('int')); + check(parseType('int?')); + check(parseType('List')); } void test_interfaceType_functionType() { buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - _checkLeastUpperBound( - interfaceTypeNone(A), - functionTypeNone(returnType: voidNone), - objectNone, + parseInterfaceType('A'), + parseFunctionType('void Function()'), + parseType('Object'), ); } @@ -2561,9 +2237,9 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, expected); } - check(doubleNone, intQuestion, numQuestion); - check(numNone, doubleQuestion, numQuestion); - check(numNone, intQuestion, numQuestion); + check(parseType('double'), parseType('int?'), parseType('num?')); + check(parseType('num'), parseType('double?'), parseType('num?')); + check(parseType('num'), parseType('int?'), parseType('num?')); } test_null_any() { @@ -2580,28 +2256,40 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, expected); } - check(nullNone, objectNone, objectQuestion); + check(parseType('Null'), parseType('Object'), parseType('Object?')); - check(nullNone, intNone, intQuestion); - check(nullNone, intQuestion, intQuestion); + check(parseType('Null'), parseType('int'), parseType('int?')); + check(parseType('Null'), parseType('int?'), parseType('int?')); - check(nullNone, listNone(intNone), listQuestion(intNone)); - check(nullNone, listQuestion(intNone), listQuestion(intNone)); + check(parseType('Null'), parseType('List'), parseType('List?')); + check(parseType('Null'), parseType('List?'), parseType('List?')); - check(nullNone, futureOrNone(intNone), futureOrQuestion(intNone)); - check(nullNone, futureOrQuestion(intNone), futureOrQuestion(intNone)); - - check(nullNone, futureOrNone(intQuestion), futureOrNone(intQuestion)); check( - nullNone, - futureOrQuestion(intQuestion), - futureOrQuestion(intQuestion), + parseType('Null'), + parseType('FutureOr'), + parseType('FutureOr?'), + ); + check( + parseType('Null'), + parseType('FutureOr?'), + parseType('FutureOr?'), ); check( - nullNone, - functionTypeNone(returnType: intNone), - functionTypeQuestion(returnType: intNone), + parseType('Null'), + parseType('FutureOr'), + parseType('FutureOr'), + ); + check( + parseType('Null'), + parseType('FutureOr?'), + parseType('FutureOr?'), + ); + + check( + parseType('Null'), + parseFunctionType('int Function()'), + parseFunctionType('int Function()?'), ); } @@ -2616,7 +2304,7 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, T2); } - check(nullNone, nullNone); + check(parseType('Null'), parseType('Null')); } test_object_any() { @@ -2627,13 +2315,25 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, expected); } - check(objectNone, intNone, objectNone); - check(objectNone, intQuestion, objectQuestion); + check(parseType('Object'), parseType('int'), parseType('Object')); + check(parseType('Object'), parseType('int?'), parseType('Object?')); - check(objectNone, futureOrNone(intQuestion), objectQuestion); + check( + parseType('Object'), + parseType('FutureOr'), + parseType('Object?'), + ); - check(futureOrNone(objectNone), intNone, futureOrNone(objectNone)); - check(futureOrNone(objectNone), intQuestion, futureOrQuestion(objectNone)); + check( + parseType('FutureOr'), + parseType('int'), + parseType('FutureOr'), + ); + check( + parseType('FutureOr'), + parseType('int?'), + parseType('FutureOr?'), + ); } test_object_object() { @@ -2644,9 +2344,12 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, T2); } - check(futureOrNone(objectNone), objectNone); + check(parseType('FutureOr'), parseType('Object')); - check(futureOrNone(futureOrNone(objectNone)), futureOrNone(objectNone)); + check( + parseType('FutureOr>'), + parseType('FutureOr'), + ); } test_question_question() { @@ -2660,9 +2363,9 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, expected); } - check(doubleQuestion, intQuestion, numQuestion); - check(numQuestion, doubleQuestion, numQuestion); - check(numQuestion, intQuestion, numQuestion); + check(parseType('double?'), parseType('int?'), parseType('num?')); + check(parseType('num?'), parseType('double?'), parseType('num?')); + check(parseType('num?'), parseType('int?'), parseType('num?')); } test_top_any() { @@ -2673,27 +2376,26 @@ class UpperBoundTest extends _BoundsTestBase { } void check2(TypeImpl T1) { - check(T1, objectNone); - check(T1, intNone); - check(T1, intQuestion); - check(T1, listNone(intNone)); - check(T1, futureOrNone(intNone)); - check(T1, functionTypeNone(returnType: voidNone)); + check(T1, parseType('Object')); + check(T1, parseType('int')); + check(T1, parseType('int?')); + check(T1, parseType('List')); + check(T1, parseType('FutureOr')); + check(T1, parseFunctionType('void Function()')); - { - var T = typeParameter('T'); - check(T1, typeParameterTypeNone(T)); - check(T1, typeParameterTypeQuestion(T)); - } + withTypeParameterScope('T', (scope) { + check(T1, scope.parseType('T')); + check(T1, scope.parseType('T?')); + }); } - check2(voidNone); - check2(dynamicType); - check2(invalidType); - check2(objectQuestion); + check2(parseType('void')); + check2(parseType('dynamic')); + check2(parseType('InvalidType')); + check2(parseType('Object?')); - check2(futureOrNone(voidNone)); - check2(futureOrQuestion(voidNone)); + check2(parseType('FutureOr')); + check2(parseType('FutureOr?')); } test_top_top() { @@ -2703,40 +2405,40 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, T1); } - check(voidNone, dynamicType); - check(voidNone, invalidType); - check(voidNone, objectQuestion); - check(voidNone, futureOrNone(voidNone)); - check(voidNone, futureOrNone(dynamicType)); - check(voidNone, futureOrNone(invalidType)); - check(voidNone, futureOrNone(objectQuestion)); + check(parseType('void'), parseType('dynamic')); + check(parseType('void'), parseType('InvalidType')); + check(parseType('void'), parseType('Object?')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('FutureOr')); + check(parseType('void'), parseType('FutureOr')); - check(dynamicType, objectQuestion); - check(dynamicType, futureOrNone(voidNone)); - check(dynamicType, futureOrNone(dynamicType)); - check(dynamicType, futureOrNone(objectQuestion)); + check(parseType('dynamic'), parseType('Object?')); + check(parseType('dynamic'), parseType('FutureOr')); + check(parseType('dynamic'), parseType('FutureOr')); + check(parseType('dynamic'), parseType('FutureOr')); - check(invalidType, objectQuestion); - check(invalidType, futureOrNone(voidNone)); - check(invalidType, futureOrNone(dynamicType)); - check(invalidType, futureOrNone(objectQuestion)); + check(parseType('InvalidType'), parseType('Object?')); + check(parseType('InvalidType'), parseType('FutureOr')); + check(parseType('InvalidType'), parseType('FutureOr')); + check(parseType('InvalidType'), parseType('FutureOr')); - check(objectQuestion, futureOrQuestion(voidNone)); - check(objectQuestion, futureOrQuestion(dynamicType)); - check(objectQuestion, futureOrQuestion(invalidType)); - check(objectQuestion, futureOrQuestion(objectNone)); - check(objectQuestion, futureOrQuestion(objectQuestion)); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); + check(parseType('Object?'), parseType('FutureOr?')); - check(futureOrNone(voidNone), objectQuestion); - check(futureOrNone(dynamicType), objectQuestion); - check(futureOrNone(invalidType), objectQuestion); - check(futureOrNone(objectQuestion), objectQuestion); + check(parseType('FutureOr'), parseType('Object?')); + check(parseType('FutureOr'), parseType('Object?')); + check(parseType('FutureOr'), parseType('Object?')); + check(parseType('FutureOr'), parseType('Object?')); - check(futureOrNone(voidNone), futureOrNone(dynamicType)); - check(futureOrNone(voidNone), futureOrNone(invalidType)); - check(futureOrNone(voidNone), futureOrNone(objectQuestion)); - check(futureOrNone(dynamicType), futureOrNone(objectQuestion)); - check(futureOrNone(invalidType), futureOrNone(objectQuestion)); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); + check(parseType('FutureOr'), parseType('FutureOr')); } test_typeParameter_bound() { @@ -2750,122 +2452,101 @@ class UpperBoundTest extends _BoundsTestBase { _checkLeastUpperBound(T1, T2, expected); } - { - var T = typeParameter('T', bound: intNone); - check(typeParameterTypeNone(T), numNone, numNone); - } + withTypeParameterScope('T extends int', (scope) { + check( + scope.parseTypeParameterType('T'), + parseType('num'), + parseType('num'), + ); + }); - { - var T = typeParameter('T', bound: intNone); - var U = typeParameter('U', bound: numNone); - check(typeParameterTypeNone(T), typeParameterTypeNone(U), numNone); - } + withTypeParameterScope('T extends int, U extends num', (scope) { + check( + scope.parseTypeParameterType('T'), + scope.parseTypeParameterType('U'), + parseType('num'), + ); + }); - { - var T = typeParameter('T', bound: intNone); - var U = typeParameter('U', bound: numQuestion); - check(typeParameterTypeNone(T), typeParameterTypeNone(U), numQuestion); - } + withTypeParameterScope('T extends int, U extends num?', (scope) { + check( + scope.parseTypeParameterType('T'), + scope.parseTypeParameterType('U'), + parseType('num?'), + ); + }); - { - var T = typeParameter('T', bound: intQuestion); - var U = typeParameter('U', bound: numNone); - check(typeParameterTypeNone(T), typeParameterTypeNone(U), numQuestion); - } + withTypeParameterScope('T extends int?, U extends num', (scope) { + check( + scope.parseTypeParameterType('T'), + scope.parseTypeParameterType('U'), + parseType('num?'), + ); + }); - { - var T = typeParameter('T', bound: numNone); - var T_none = typeParameterTypeNone(T); - var U = typeParameter('U', bound: T_none); - check(T_none, typeParameterTypeNone(U), T_none); - } + withTypeParameterScope('T extends num, U extends T', (scope) { + var T = scope.parseTypeParameterType('T'); + check(T, scope.parseTypeParameterType('U'), T); + }); } void test_typeParameter_fBounded() { // class A {} buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - // > - var S = typeParameter('S'); - var S_none = typeParameterTypeNone(S); - S.bound = interfaceTypeNone(A, typeArguments: [S_none]); + withTypeParameterScope('S, U', (scope) { + var S = scope.typeParameter('S'); + S.bound = scope.parseType('A'); - // > - var U = typeParameter('U'); - var U_none = typeParameterTypeNone(U); - U.bound = interfaceTypeNone(A, typeArguments: [U_none]); + var U = scope.typeParameter('U'); + U.bound = scope.parseType('A'); - _checkLeastUpperBound( - S_none, - typeParameterTypeNone(U), - interfaceTypeNone(A, typeArguments: [objectQuestion]), - ); + _checkLeastUpperBound( + scope.parseType('S'), + scope.parseType('U'), + parseType('A'), + ); + }); } void test_typeParameter_function_bounded() { - var T = typeParameter('T', bound: typeProvider.functionType); - - _checkLeastUpperBound( - typeParameterTypeNone(T), - functionTypeNone(returnType: voidNone), - typeProvider.functionType, - ); + withTypeParameterScope('T extends Function', (scope) { + _checkLeastUpperBound( + scope.parseType('T'), + parseFunctionType('void Function()'), + typeProvider.functionType, + ); + }); } void test_typeParameter_function_noBound() { - var T = typeParameter('T', bound: objectQuestion); - - _checkLeastUpperBound( - typeParameterTypeNone(T), - functionTypeNone(returnType: voidNone), - objectQuestion, - ); + withTypeParameterScope('T extends Object?', (scope) { + _checkLeastUpperBound( + scope.parseType('T'), + parseFunctionType('void Function()'), + parseType('Object?'), + ); + }); } void test_typeParameter_greatestClosure_functionBounded() { - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); - T.bound = functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ); - - _checkLeastUpperBound( - T_none, - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: nullNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: neverNone)], - ), - ); + withTypeParameterScope('T extends void Function(T)', (scope) { + _checkLeastUpperBound( + scope.parseType('T'), + parseFunctionType('void Function(Null)'), + parseFunctionType('void Function(Never)'), + ); + }); } void test_typeParameter_greatestClosure_functionPromoted() { - var T = typeParameter('T'); - var T_none = typeParameterTypeNone(T); - var T_none_promoted = typeParameterTypeNone( - T, - promotedBound: functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: T_none)], - ), - ); - - _checkLeastUpperBound( - T_none_promoted, - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: nullNone)], - ), - functionTypeNone( - returnType: voidNone, - formalParameters: [requiredParameter(type: neverNone)], - ), - ); + withTypeParameterScope('T', (scope) { + _checkLeastUpperBound( + scope.parseType('T & void Function(T)'), + parseFunctionType('void Function(Null)'), + parseFunctionType('void Function(Never)'), + ); + }); } void test_typeParameter_interface_bounded() { @@ -2876,240 +2557,195 @@ class UpperBoundTest extends _BoundsTestBase { ClassSpec('class C extends A'), ], ); - var A = classElement('A'); - var A_none = interfaceTypeNone(A); - - var B = classElement('B'); - var B_none = interfaceTypeNone(B); - - var C = classElement('C'); - var C_none = interfaceTypeNone(C); - - var T = typeParameter('T', bound: B_none); - var typeT = typeParameterTypeNone(T); - - _checkLeastUpperBound(typeT, C_none, A_none); + withTypeParameterScope('T extends B', (scope) { + _checkLeastUpperBound( + scope.parseType('T'), + parseInterfaceType('C'), + parseInterfaceType('A'), + ); + }); } void test_typeParameter_interface_bounded_objectQuestion() { - var T = typeParameter('T', bound: objectQuestion); - - _checkLeastUpperBound(typeParameterTypeNone(T), intNone, objectQuestion); + withTypeParameterScope('T extends Object?', (scope) { + _checkLeastUpperBound( + scope.parseType('T'), + parseType('int'), + parseType('Object?'), + ); + }); } void test_typeParameter_interface_noBound() { - var T = typeParameter('T'); - - _checkLeastUpperBound(typeParameterTypeNone(T), intNone, objectQuestion); + withTypeParameterScope('T', (scope) { + _checkLeastUpperBound( + scope.parseType('T'), + parseType('int'), + parseType('Object?'), + ); + }); } void test_typeParameter_intersection_basic() { - // `X extends num?`, `Y extends X`, `X & num`. - var X = typeParameter('X', bound: numQuestion); - var X_none = typeParameterTypeNone(X); - var Y = typeParameter('Y', bound: X_none); - var Y_none = typeParameterTypeNone(Y); - var X_none_promoted = typeParameterTypeNone(X, promotedBound: numNone); + withTypeParameterScope('X extends num?, Y extends X', (scope) { + var X_none = scope.parseType('X'); + var Y_none = scope.parseType('Y'); + var X_none_promoted = scope.parseType('X & num'); - // `UP(X & num, Y) == X`, because `Y <: X`. - _checkLeastUpperBound(X_none_promoted, Y_none, X_none); + // `UP(X & num, Y) == X`, because `Y <: X`. + _checkLeastUpperBound(X_none_promoted, Y_none, X_none); - // `UP(X & num, num?) == num?`, because `X <: num?`. - _checkLeastUpperBound(X_none_promoted, numQuestion, numQuestion); + // `UP(X & num, num?) == num?`, because `X <: num?`. + _checkLeastUpperBound( + X_none_promoted, + parseType('num?'), + parseType('num?'), + ); - // `UP(X & num, String) == Object`. - _checkLeastUpperBound(X_none_promoted, stringNone, objectNone); + // `UP(X & num, String) == Object`. + _checkLeastUpperBound( + X_none_promoted, + parseType('String'), + parseType('Object'), + ); + }); } void test_typeParameter_intersection_fbounded() { // `X`, `class C {}`, `Y extends C?`, `Y & C`. buildTestLibrary(classes: [ClassSpec('class C')]); - var C = classElement('C'); - var Y = typeParameter('Y'); - var Y_none = typeParameterTypeNone(Y); - Y.bound = interfaceTypeQuestion(C, typeArguments: [Y_none]); - var C_Y_none = interfaceTypeNone(C, typeArguments: [Y_none]); - var Y_none_promoted = typeParameterTypeNone(Y, promotedBound: C_Y_none); - var C_Never_none = interfaceTypeNone(C, typeArguments: [neverNone]); - var C_ObjectQuestion_none = interfaceTypeNone( - C, - typeArguments: [objectQuestion], - ); + withTypeParameterScope('Y', (scope) { + var Y = scope.typeParameter('Y'); + Y.bound = scope.parseType('C?'); - // `UP(Y & C, C) == C`. - _checkLeastUpperBound(Y_none_promoted, C_Never_none, C_ObjectQuestion_none); + // `UP(Y & C, C) == C`. + _checkLeastUpperBound( + scope.parseType('Y & C'), + parseInterfaceType('C'), + parseInterfaceType('C'), + ); + }); } void test_typeParameter_intersection_null() { - var X = typeParameter('X'); - var X_none_promoted_nullable = typeParameterTypeNone( - X, - promotedBound: numQuestion, - ); - var X_none_promoted_nonnullable = typeParameterTypeNone( - X, - promotedBound: numNone, - ); + withTypeParameterScope('X', (scope) { + // UP(X & num?, Null) == num? + _checkLeastUpperBound( + scope.parseType('X & num?'), + parseType('Null'), + parseType('num?'), + ); - // UP(X & num?, Null) == num? - _checkLeastUpperBound(X_none_promoted_nullable, nullNone, numQuestion); - - // UP(X & num, Null) == num? - _checkLeastUpperBound(X_none_promoted_nonnullable, nullNone, numQuestion); + // UP(X & num, Null) == num? + _checkLeastUpperBound( + scope.parseType('X & num'), + parseType('Null'), + parseType('num?'), + ); + }); } void test_typeParameters_contravariant_different() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - // A - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); - var A_int = interfaceTypeNone(A, typeArguments: [intNone]); - - _checkLeastUpperBound(A_int, A_num, A_int); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), + ); } void test_typeParameters_contravariant_same() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); - - _checkLeastUpperBound(A_num, A_num, A_num); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), + ); } void test_typeParameters_covariant_different() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - // A - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); - var A_int = interfaceTypeNone(A, typeArguments: [intNone]); - - _checkLeastUpperBound(A_int, A_num, A_num); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), + ); } void test_typeParameters_covariant_same() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); - - _checkLeastUpperBound(A_num, A_num, A_num); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), + ); } void test_typeParameters_invariant_object() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - // A - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); - var A_int = interfaceTypeNone(A, typeArguments: [intNone]); - - _checkLeastUpperBound(A_num, A_int, objectNone); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseType('Object'), + ); } void test_typeParameters_invariant_same() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - var A_num = interfaceTypeNone(A, typeArguments: [numNone]); - - _checkLeastUpperBound(A_num, A_num, A_num); + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), + ); } void test_typeParameters_multi_basic() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - // A - var A_num_num_num = interfaceTypeNone( - A, - typeArguments: [numNone, numNone, numNone], + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), ); - var A_int_num_int = interfaceTypeNone( - A, - typeArguments: [intNone, numNone, intNone], - ); - - // We expect A - var A_num_num_int = interfaceTypeNone( - A, - typeArguments: [numNone, numNone, intNone], - ); - - _checkLeastUpperBound(A_num_num_num, A_int_num_int, A_num_num_int); } void test_typeParameters_multi_objectInterface() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - // A - var A_num_String_num = interfaceTypeNone( - A, - typeArguments: [numNone, stringNone, numNone], + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseType('Object'), ); - var A_int_num_int = interfaceTypeNone( - A, - typeArguments: [intNone, numNone, intNone], - ); - - _checkLeastUpperBound(A_num_String_num, A_int_num_int, objectNone); } void test_typeParameters_multi_objectType() { // class A buildTestLibrary(classes: [ClassSpec('class A')]); - var A = classElement('A'); - - // A - // A - var A_String_num_num = interfaceTypeNone( - A, - typeArguments: [stringNone, numNone, numNone], + _checkLeastUpperBound( + parseInterfaceType('A'), + parseInterfaceType('A'), + parseInterfaceType('A'), ); - var A_int_num_int = interfaceTypeNone( - A, - typeArguments: [intNone, numNone, intNone], - ); - - // We expect A - var A_Object_num_int = interfaceTypeNone( - A, - typeArguments: [objectNone, numNone, intNone], - ); - - _checkLeastUpperBound(A_String_num_num, A_int_num_int, A_Object_num_int); } /// Check least upper bound of the same class with different type parameters. void test_typeParameters_noVariance_different() { _checkLeastUpperBound( - listNone(intNone), - listNone(doubleNone), - listNone(numNone), + parseType('List'), + parseType('List'), + parseType('List'), ); } void test_typeParameters_noVariance_same() { - var listOfInt = listNone(intNone); + var listOfInt = parseType('List'); _checkLeastUpperBound(listOfInt, listOfInt, listOfInt); } }