blob: 22ea76ba80f2b6f50573c94ae318359f1ae9f5fa [file] [log] [blame]
// 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:analyzer/dart/element/type.dart';
import 'package:nnbd_migration/src/decorated_type.dart';
import 'package:nnbd_migration/src/edit_plan.dart';
import 'package:nnbd_migration/src/hint_action.dart';
import 'package:nnbd_migration/src/nullability_node.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'migration_visitor_test_base.dart';
main() {
defineReflectiveSuite(() {
defineReflectiveTests(NodeBuilderTest);
});
}
@reflectiveTest
class NodeBuilderTest extends MigrationVisitorTestBase {
/// Gets the [DecoratedType] associated with the function declaration whose
/// name matches [search].
DecoratedType decoratedFunctionType(String search) =>
variables!.decoratedElementType(
findNode.functionDeclaration(search).declaredElement!);
DecoratedType? decoratedTypeParameterBound(String search) =>
variables!.decoratedTypeParameterBound(
findNode.typeParameter(search).declaredElement!);
Future<void> test_catch_clause_with_stacktrace_with_on() async {
await analyze('''
void f() {
try {} on String catch (ex, st) {}
}
''');
var exceptionType =
variables!.decoratedElementType(findNode.simple('ex').staticElement!);
expect(exceptionType.node, TypeMatcher<NullabilityNodeMutable>());
var stackTraceType =
variables!.decoratedElementType(findNode.simple('st').staticElement!);
assertEdge(stackTraceType.node, never, hard: true, checkable: false);
}
Future<void> test_catch_clause_with_stacktrace_without_on() async {
await analyze('''
void f() {
try {} catch (ex, st) {}
}
''');
var exceptionType =
variables!.decoratedElementType(findNode.simple('ex').staticElement!);
expect(exceptionType.node!.isImmutable, false);
var stackTraceType =
variables!.decoratedElementType(findNode.simple('st').staticElement!);
assertEdge(stackTraceType.node, never, hard: true, checkable: false);
}
Future<void> test_catch_clause_without_catch() async {
await analyze('''
void f() {
try {} on String {}
}
''');
// No assertions, since no variables are declared; we just want to make sure
// we don't crash.
}
Future<void> test_catch_clause_without_stacktrace_with_on() async {
await analyze('''
void f() {
try {} on String catch (ex) {}
}
''');
var exceptionType =
variables!.decoratedElementType(findNode.simple('ex').staticElement!);
expect(exceptionType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_catch_clause_without_stacktrace_without_on() async {
await analyze('''
void f() {
try {} catch (ex) {}
}
''');
var exceptionType =
variables!.decoratedElementType(findNode.simple('ex').staticElement!);
expect(exceptionType.node!.isImmutable, false);
}
Future<void> test_class_alias_synthetic_constructors_no_parameters() async {
await analyze('''
class C {
C.a();
C.b();
}
mixin M {}
class D = C with M;
''');
var constructors = findElement.class_('D').constructors;
expect(constructors, hasLength(2));
var a = findElement.constructor('a', of: 'D');
var aType = variables!.decoratedElementType(a);
_assertType(aType.type!, 'D Function()');
expect(aType.node, same(never));
expect(aType.typeArguments, isEmpty);
_assertType(aType.returnType!.type!, 'D');
expect(aType.returnType!.node, same(never));
var b = findElement.constructor('b', of: 'D');
var bType = variables!.decoratedElementType(b);
_assertType(bType.type!, 'D Function()');
expect(bType.node, same(never));
expect(bType.typeArguments, isEmpty);
_assertType(bType.returnType!.type!, 'D');
expect(bType.returnType!.node, same(never));
}
Future<void> test_class_alias_synthetic_constructors_with_parameters() async {
await analyze('''
class C {
C.a(int i);
C.b([int i]);
C.c({int i});
C.d(List<int> x);
}
mixin M {}
class D = C with M;
''');
var constructors = findElement.class_('D').constructors;
expect(constructors, hasLength(4));
var a = findElement.constructor('a', of: 'D');
var aType = variables!.decoratedElementType(a);
_assertType(aType.type!, 'D Function(int)');
expect(aType.node, same(never));
expect(aType.typeArguments, isEmpty);
_assertType(aType.returnType!.type!, 'D');
expect(aType.returnType!.node, same(never));
expect(aType.positionalParameters, hasLength(1));
_assertType(aType.positionalParameters![0]!.type!, 'int');
expect(aType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
expect(aType.namedParameters, isEmpty);
var b = findElement.constructor('b', of: 'D');
var bType = variables!.decoratedElementType(b);
_assertType(bType.type!, 'D Function([int])');
expect(bType.node, same(never));
expect(bType.typeArguments, isEmpty);
_assertType(bType.returnType!.type!, 'D');
expect(bType.returnType!.node, same(never));
expect(bType.positionalParameters, hasLength(1));
_assertType(bType.positionalParameters![0]!.type!, 'int');
expect(bType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
expect(bType.namedParameters, isEmpty);
var c = findElement.constructor('c', of: 'D');
var cType = variables!.decoratedElementType(c);
_assertType(cType.type!, 'D Function({int i})');
expect(cType.node, same(never));
expect(cType.typeArguments, isEmpty);
_assertType(cType.returnType!.type!, 'D');
expect(cType.returnType!.node, same(never));
expect(cType.positionalParameters, isEmpty);
expect(cType.namedParameters, hasLength(1));
expect(cType.namedParameters, contains('i'));
_assertType(cType.namedParameters!['i']!.type!, 'int');
expect(cType.namedParameters!['i']!.node,
TypeMatcher<NullabilityNodeMutable>());
var d = findElement.constructor('d', of: 'D');
var dType = variables!.decoratedElementType(d);
_assertType(dType.type!, 'D Function(List<int>)');
expect(dType.node, same(never));
expect(dType.typeArguments, isEmpty);
_assertType(dType.returnType!.type!, 'D');
expect(dType.returnType!.node, same(never));
expect(dType.positionalParameters, hasLength(1));
_assertType(dType.positionalParameters![0]!.type!, 'List<int>');
expect(dType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
expect(dType.positionalParameters![0]!.typeArguments, hasLength(1));
_assertType(dType.positionalParameters![0]!.typeArguments[0]!.type!, 'int');
expect(dType.positionalParameters![0]!.typeArguments[0]!.node,
TypeMatcher<NullabilityNodeMutable>());
expect(dType.namedParameters, isEmpty);
}
Future<void>
test_class_alias_synthetic_constructors_with_parameters_generic() async {
await analyze('''
class C<T> {
C(T t);
}
mixin M {}
class D<U> = C<U> with M;
''');
var dConstructor = findElement.unnamedConstructor('D');
var dConstructorType = variables!.decoratedElementType(dConstructor);
_assertType(dConstructorType.type!, 'D<U> Function(U)');
expect(dConstructorType.node, same(never));
expect(dConstructorType.typeFormals, isEmpty);
_assertType(dConstructorType.returnType!.type!, 'D<U>');
expect(dConstructorType.returnType!.node, same(never));
var typeArguments = dConstructorType.returnType!.typeArguments;
expect(typeArguments, hasLength(1));
_assertType(typeArguments[0]!.type!, 'U');
expect(typeArguments[0]!.node, same(never));
var dParams = dConstructorType.positionalParameters!;
expect(dParams, hasLength(1));
_assertType(dParams[0]!.type!, 'U');
expect(dParams[0]!.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_class_with_default_constructor() async {
await analyze('''
class C {}
''');
var defaultConstructor = findElement.class_('C').constructors.single;
var decoratedConstructorType =
variables!.decoratedElementType(defaultConstructor);
_assertType(decoratedConstructorType.type!, 'C Function()');
expect(decoratedConstructorType.node, same(never));
_assertType(decoratedConstructorType.returnType!.type!, 'C');
expect(decoratedConstructorType.returnType!.node, same(never));
}
Future<void> test_class_with_default_constructor_generic() async {
await analyze('''
class C<T, U> {}
''');
var defaultConstructor = findElement.class_('C').constructors.single;
var decoratedConstructorType =
variables!.decoratedElementType(defaultConstructor);
_assertType(decoratedConstructorType.type!, 'C<T, U> Function()');
expect(decoratedConstructorType.node, same(never));
expect(decoratedConstructorType.typeArguments, isEmpty);
var returnType = decoratedConstructorType.returnType!;
_assertType(returnType.type!, 'C<T, U>');
expect(returnType.node, same(never));
expect(returnType.typeArguments, hasLength(2));
_assertType(returnType.typeArguments[0]!.type!, 'T');
expect(returnType.typeArguments[0]!.node, same(never));
_assertType(returnType.typeArguments[1]!.type!, 'U');
expect(returnType.typeArguments[1]!.node, same(never));
}
Future<void> test_constructor_factory() async {
await analyze('''
class C {
C._();
factory C() => C._();
}
''');
var decoratedType = decoratedConstructorDeclaration('C(').returnType!;
expect(decoratedType.node, same(never));
}
Future<void> test_constructor_metadata() async {
await analyze('''
class A {
final Object x;
const A(this.x);
}
class C {
@A(<int>[])
C();
}
''');
var node = decoratedTypeAnnotation('int').node;
expect(node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_constructor_returnType_implicit_dynamic() async {
await analyze('''
class C {
C();
}
''');
var decoratedType = decoratedConstructorDeclaration('C(').returnType!;
expect(decoratedType.node, same(never));
}
Future<void> test_constructorFieldInitializer_visit_expression() async {
await analyze('''
class C {
C() : f = <int>[];
Object f;
}
''');
var node = decoratedTypeAnnotation('int').node;
expect(node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_directSupertypes_class_extends() async {
await analyze('''
class C<T, U> {}
class D<V> extends C<int, V> {}
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V> {').node));
}
Future<void> test_directSupertypes_class_extends_default() async {
await analyze('''
class C<T, U> {}
''');
var types = decoratedDirectSupertypes('C');
var decorated = types[typeProvider.objectType.element]!;
_assertType(decorated.type!, 'Object');
assertEdge(decorated.node, never, hard: true, checkable: false);
expect(decorated.typeArguments, isEmpty);
}
Future<void> test_directSupertypes_class_implements() async {
await analyze('''
class C<T, U> {}
class D<V> implements C<int, V> {}
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V> {').node));
}
Future<void> test_directSupertypes_class_with() async {
await analyze('''
class C<T, U> {}
class D<V> extends Object with C<int, V> {}
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V> {').node));
}
Future<void> test_directSupertypes_classAlias_extends() async {
await analyze('''
class M {}
class C<T, U> {}
class D<V> = C<int, V> with M;
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V> w').node));
}
Future<void> test_directSupertypes_classAlias_implements() async {
await analyze('''
class M {}
class C<T, U> {}
class D<V> = Object with M implements C<int, V>;
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V>;').node));
}
Future<void> test_directSupertypes_classAlias_with() async {
await analyze('''
class C<T, U> {}
class D<V> = Object with C<int, V>;
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V>;').node));
}
Future<void> test_directSupertypes_dartCoreClass() async {
await analyze('''
abstract class D<V> extends Iterable<V> {}
''');
var types = decoratedDirectSupertypes('D');
var super_ = types.values.single!;
_assertType(super_.type!, 'Iterable<V>');
expect(super_.node, same(never));
expect(super_.typeArguments, hasLength(1));
expect(super_.typeArguments[0]!.node,
same(decoratedTypeAnnotation('V> {').node));
}
Future<void> test_directSupertypes_mixin_extends_default() async {
await analyze('''
mixin C<T, U> {}
''');
var types = decoratedDirectSupertypes('C');
var decorated = types[typeProvider.objectType.element]!;
_assertType(decorated.type!, 'Object');
assertEdge(decorated.node, never, hard: true, checkable: false);
expect(decorated.typeArguments, isEmpty);
}
Future<void> test_directSupertypes_mixin_implements() async {
await analyze('''
class C<T, U> {}
mixin D<V> implements C<int, V> {}
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V> {').node));
}
Future<void> test_directSupertypes_mixin_on() async {
await analyze('''
class C<T, U> {}
mixin D<V> on C<int, V> {}
''');
var types = decoratedDirectSupertypes('D');
var decorated = types[findElement.class_('C')]!;
_assertType(decorated.type!, 'C<int, V>');
expect(decorated.node, same(never));
expect(decorated.typeArguments, hasLength(2));
expect(decorated.typeArguments[0]!.node,
same(decoratedTypeAnnotation('int').node));
expect(decorated.typeArguments[1]!.node,
same(decoratedTypeAnnotation('V> {').node));
}
Future<void> test_displayName_castType() async {
await analyze('f(x) => x as int;');
expect(decoratedTypeAnnotation('int').node!.displayName,
'cast type (test.dart:1:14)');
}
Future<void> test_displayName_constructedType() async {
await analyze('''
class C {
factory C() = D<int>;
}
class D<T> implements C {}
''');
expect(decoratedTypeAnnotation('int').node!.displayName,
'type argument 0 of constructed type (test.dart:2:19)');
}
Future<void> test_displayName_exceptionType_implicit() async {
await analyze('''
f(void Function() g) {
try {
g();
} catch (e) {}
}
''');
expect(
variables!
.decoratedElementType(findNode.simple('e)').staticElement!)
.node!
.displayName,
'f.e (test.dart:4:5)');
}
Future<void> test_displayName_exceptionType_no_variable() async {
await analyze('''
f(void Function() g) {
try {
g();
} on String {}
}
''');
expect(decoratedTypeAnnotation('String').node!.displayName,
'exception type (test.dart:4:8)');
}
Future<void> test_displayName_exceptionType_variable() async {
await analyze('''
f(void Function() g) {
try {
g();
} on String catch (s) {}
}
''');
expect(decoratedTypeAnnotation('String').node!.displayName,
'f.s (test.dart:4:8)');
}
Future<void> test_displayName_explicitParameterType_named() async {
await analyze('void f({int x, int y}) {}');
expect(decoratedTypeAnnotation('int x').node!.displayName,
'parameter x of f (test.dart:1:9)');
expect(decoratedTypeAnnotation('int y').node!.displayName,
'parameter y of f (test.dart:1:16)');
}
Future<void> test_displayName_explicitParameterType_positional() async {
await analyze('void f(int x, int y, [int z]) {}');
expect(decoratedTypeAnnotation('int x').node!.displayName,
'parameter 0 of f (test.dart:1:8)');
expect(decoratedTypeAnnotation('int y').node!.displayName,
'parameter 1 of f (test.dart:1:15)');
expect(decoratedTypeAnnotation('int z').node!.displayName,
'parameter 2 of f (test.dart:1:23)');
}
Future<void> test_displayName_extendedType() async {
await analyze('extension E on int {}');
expect(decoratedTypeAnnotation('int').node!.displayName,
'extended type (test.dart:1:16)');
}
Future<void> test_displayName_field() async {
await analyze('class C { int x; }');
expect(decoratedTypeAnnotation('int').node!.displayName,
'C.x (test.dart:1:11)');
}
Future<void> test_displayName_for_loop_variable() async {
await analyze('f(List<int> x) { for (int y in x) {} }');
expect(decoratedTypeAnnotation('int y').node!.displayName,
'f.y (test.dart:1:23)');
}
Future<void>
test_displayName_functionExpressionInvocation_type_argument() async {
await analyze('f(g) => g<int>();');
expect(decoratedTypeAnnotation('int').node!.displayName,
'type argument (test.dart:1:11)');
}
Future<void> test_displayName_listElementType() async {
await analyze('f() => <int>[];');
expect(decoratedTypeAnnotation('int').node!.displayName,
'list element type (test.dart:1:9)');
}
Future<void> test_displayName_mapKeyType() async {
await analyze('f() => <int, String>{};');
expect(decoratedTypeAnnotation('int').node!.displayName,
'map key type (test.dart:1:9)');
}
Future<void> test_displayName_mapValueType() async {
await analyze('f() => <int, String>{};');
expect(decoratedTypeAnnotation('String').node!.displayName,
'map value type (test.dart:1:14)');
}
Future<void> test_displayName_methodInvocation_type_argument() async {
await analyze('f(x) => x.g<int>();');
expect(decoratedTypeAnnotation('int').node!.displayName,
'type argument (test.dart:1:13)');
}
Future<void> test_displayName_setElementType() async {
await analyze('f() => <int>{};');
expect(decoratedTypeAnnotation('int').node!.displayName,
'set element type (test.dart:1:9)');
}
Future<void> test_displayName_supertype() async {
await analyze('''
class C<T> {}
class D extends C<int> {}
''');
expect(decoratedTypeAnnotation('int').node!.displayName,
'type argument 0 of supertype of D (test.dart:2:19)');
}
Future<void> test_displayName_testedType() async {
await analyze('f(x) => x is int;');
expect(decoratedTypeAnnotation('int').node!.displayName,
'tested type (test.dart:1:14)');
}
Future<void> test_displayName_typeArgument() async {
await analyze('var x = <List<int>>[];');
expect(decoratedTypeAnnotation('int').node!.displayName,
'type argument 0 of list element type (test.dart:1:15)');
}
Future<void> test_displayName_typedef_new_parameter() async {
await analyze('typedef F = void Function(int x);');
expect(decoratedTypeAnnotation('int').node!.displayName,
'parameter 0 of F (test.dart:1:27)');
}
Future<void> test_displayName_typedef_new_returnType() async {
await analyze('typedef F = int Function();');
expect(decoratedTypeAnnotation('int').node!.displayName,
'return type of F (test.dart:1:13)');
}
Future<void> test_displayName_typedef_old_parameter() async {
await analyze('typedef void F(int x);');
expect(decoratedTypeAnnotation('int').node!.displayName,
'parameter 0 of F (test.dart:1:16)');
}
Future<void> test_displayName_typedef_old_returnType() async {
await analyze('typedef int F();');
expect(decoratedTypeAnnotation('int').node!.displayName,
'return type of F (test.dart:1:9)');
}
Future<void> test_displayName_typeParameterBound() async {
await analyze('class C<T extends num> {}');
expect(decoratedTypeAnnotation('num').node!.displayName,
'bound of C.T (test.dart:1:19)');
}
Future<void> test_displayName_typeParameterBound_implicit() async {
await analyze('class C<T extends num> {}');
expect(
variables!
.decoratedTypeParameterBound(
findElement.class_('C').typeParameters[0])!
.node!
.displayName,
'bound of C.T (test.dart:1:19)');
}
Future<void> test_displayName_variable_local() async {
await analyze('f() { int x; }');
expect(decoratedTypeAnnotation('int').node!.displayName,
'f.x (test.dart:1:7)');
}
Future<void> test_displayName_variable_top_level() async {
await analyze('int x;');
expect(
decoratedTypeAnnotation('int').node!.displayName, 'x (test.dart:1:1)');
}
Future<void> test_dynamic_type() async {
await analyze('''
dynamic f() {}
''');
var decoratedType = decoratedTypeAnnotation('dynamic');
expect(decoratedFunctionType('f').returnType, same(decoratedType));
assertNoEdge(always, decoratedType.node);
}
Future<void> test_extended_type_no_add_hint_actions() async {
await analyze('''
class A extends Object {}
''');
final node = decoratedTypeAnnotation('Object').node!;
expect(node.hintActions, isEmpty);
}
Future<void> test_field_type_implicit_dynamic() async {
await analyze('''
class C {
var x;
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_field_type_inferred() async {
await analyze('''
class C {
var x = 1;
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_field_type_inferred_dynamic() async {
await analyze('''
dynamic f() {}
class C {
var x = f();
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_field_type_simple() async {
await analyze('''
class C {
int f = 0;
}
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
expect(
variables!.decoratedElementType(findNode
.fieldDeclaration('f')
.fields
.variables[0]
.declaredElement!),
same(decoratedType));
}
Future<void> test_fieldFormalParameter_function_namedParameter_typed() async {
await analyze('''
class C {
Object f;
C(void this.f({int i}));
}
''');
var ctor = findElement.unnamedConstructor('C');
var ctorParam = ctor.parameters[0];
var ctorType = variables!.decoratedElementType(ctor);
var ctorParamType = variables!.decoratedElementType(ctorParam);
expect(ctorType.positionalParameters![0], same(ctorParamType));
expect(ctorParamType.node, TypeMatcher<NullabilityNodeMutable>());
expect(ctorParamType.namedParameters!['i'],
same(decoratedTypeAnnotation('int')));
}
Future<void>
test_fieldFormalParameter_function_namedParameter_untyped() async {
await analyze('''
class C {
Object f;
C(void this.f({i}));
}
''');
var ctor = findElement.unnamedConstructor('C');
var ctorParam = ctor.parameters[0];
var ctorType = variables!.decoratedElementType(ctor);
var ctorParamType = variables!.decoratedElementType(ctorParam);
expect(ctorType.positionalParameters![0], same(ctorParamType));
expect(ctorParamType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(ctorParamType.namedParameters!['i']!.type!, 'dynamic');
expect(ctorParamType.namedParameters!['i']!.node!.isImmutable, false);
}
Future<void>
test_fieldFormalParameter_function_positionalParameter_typed() async {
await analyze('''
class C {
Object f;
C(void this.f(int i));
}
''');
var ctor = findElement.unnamedConstructor('C');
var ctorParam = ctor.parameters[0];
var ctorType = variables!.decoratedElementType(ctor);
var ctorParamType = variables!.decoratedElementType(ctorParam);
expect(ctorType.positionalParameters![0], same(ctorParamType));
expect(ctorParamType.node, TypeMatcher<NullabilityNodeMutable>());
expect(ctorParamType.positionalParameters![0],
same(decoratedTypeAnnotation('int')));
}
Future<void>
test_fieldFormalParameter_function_positionalParameter_untyped() async {
await analyze('''
class C {
Object f;
C(void this.f(i));
}
''');
var ctor = findElement.unnamedConstructor('C');
var ctorParam = ctor.parameters[0];
var ctorType = variables!.decoratedElementType(ctor);
var ctorParamType = variables!.decoratedElementType(ctorParam);
expect(ctorType.positionalParameters![0], same(ctorParamType));
expect(ctorParamType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(ctorParamType.positionalParameters![0]!.type!, 'dynamic');
expect(ctorParamType.positionalParameters![0]!.node!.isImmutable, false);
}
Future<void> test_fieldFormalParameter_function_return_typed() async {
await analyze('''
class C {
Object f;
C(int this.f());
}
''');
var ctor = findElement.unnamedConstructor('C');
var ctorParam = ctor.parameters[0];
var ctorType = variables!.decoratedElementType(ctor);
var ctorParamType = variables!.decoratedElementType(ctorParam);
expect(ctorType.positionalParameters![0], same(ctorParamType));
expect(ctorParamType.node, TypeMatcher<NullabilityNodeMutable>());
expect(ctorParamType.returnType, same(decoratedTypeAnnotation('int')));
}
Future<void> test_fieldFormalParameter_function_return_untyped() async {
await analyze('''
class C {
Object f;
C(this.f()) {}
}
''');
var ctor = findElement.unnamedConstructor('C');
var ctorParam = ctor.parameters[0];
var ctorType = variables!.decoratedElementType(ctor);
var ctorParamType = variables!.decoratedElementType(ctorParam);
expect(ctorType.positionalParameters![0], same(ctorParamType));
expect(ctorParamType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(ctorParamType.returnType!.type!, 'dynamic');
expect(ctorParamType.returnType!.node!.isImmutable, false);
}
Future<void>
test_fieldFormalParameter_named_no_default_required_hint() async {
await analyze('''
class C {
String s;
C({/*required*/ this.s});
}
''');
expect(
variables!.getRequiredHint(
testSource, findNode.fieldFormalParameter('this.s')),
isNotNull);
}
Future<void>
test_fieldFormalParameter_named_no_default_required_hint_annotation() async {
await analyze('''
class C {
String s;
C({@deprecated /*required*/ this.s});
}
''');
expect(
variables!.getRequiredHint(
testSource, findNode.fieldFormalParameter('this.s')),
isNotNull);
}
Future<void>
test_fieldFormalParameter_named_no_default_required_hint_function_typed() async {
await analyze('''
class C {
String Function() s;
C({/*required*/ String this.s()});
}
''');
expect(
variables!.getRequiredHint(
testSource, findNode.fieldFormalParameter('this.s')),
isNotNull);
}
Future<void>
test_fieldFormalParameter_named_no_default_required_hint_type() async {
await analyze('''
class C {
String s;
C({/*required*/ String this.s});
}
''');
expect(
variables!.getRequiredHint(
testSource, findNode.fieldFormalParameter('this.s')),
isNotNull);
}
Future<void> test_fieldFormalParameter_typed() async {
await analyze('''
class C {
int i;
C.named(int this.i);
}
''');
var decoratedConstructorParamType =
decoratedConstructorDeclaration('named').positionalParameters![0]!;
expect(decoratedTypeAnnotation('int this'),
same(decoratedConstructorParamType));
_assertType(decoratedConstructorParamType.type!, 'int');
expect(decoratedConstructorParamType.node,
TypeMatcher<NullabilityNodeMutable>());
// Note: the edge builder will connect this node to the node for the type of
// the field.
}
Future<void> test_fieldFormalParameter_untyped() async {
await analyze('''
class C {
int i;
C.named(this.i);
}
''');
var decoratedConstructorParamType =
decoratedConstructorDeclaration('named').positionalParameters![0]!;
_assertType(decoratedConstructorParamType.type!, 'int');
expect(decoratedConstructorParamType.node,
TypeMatcher<NullabilityNodeMutable>());
// Note: the edge builder will unify this implicit type with the type of the
// field.
}
Future<void> test_formalParameter_named_no_default_required_hint() async {
await analyze('''
void f({/*required*/ String s}) {}
''');
expect(
variables!.getRequiredHint(testSource, findNode.simpleParameter('s')),
isNotNull);
}
Future<void>
test_formalParameter_named_no_default_required_hint_annotation() async {
await analyze('''
void f({@deprecated /*required*/ String s}) {}
''');
expect(
variables!.getRequiredHint(testSource, findNode.simpleParameter('s')),
isNotNull);
}
Future<void>
test_formalParameter_named_no_default_required_hint_covariant() async {
await analyze('''
class C {
void f({/*required*/ covariant String s}) {}
}
''');
expect(
variables!
.getRequiredHint(testSource, findNode.simpleParameter('String s')),
isNotNull);
}
Future<void>
test_formalParameter_named_no_default_required_hint_final_type() async {
await analyze('''
void f({/*required*/ final String s}) {}
''');
expect(
variables!.getRequiredHint(testSource, findNode.simpleParameter('s')),
isNotNull);
}
Future<void>
test_formalParameter_named_no_default_required_hint_no_type() async {
await analyze('''
void f({/*required*/ s}) {}
''');
expect(
variables!.getRequiredHint(testSource, findNode.simpleParameter('s')),
isNotNull);
}
Future<void> test_formalParameter_named_no_default_required_hint_var() async {
await analyze('''
void f({/*required*/ var s}) {}
''');
expect(
variables!.getRequiredHint(testSource, findNode.simpleParameter('s')),
isNotNull);
}
Future<void> test_function_explicit_returnType() async {
await analyze('''
class C {
int f() => null;
}
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(
decoratedType.node!.displayName, 'return type of C.f (test.dart:2:3)');
}
Future<void> test_function_generic_bounded() async {
await analyze('''
T f<T extends Object>(T t) => t;
''');
var bound = decoratedTypeParameterBound('T extends')!;
expect(decoratedTypeAnnotation('Object'), same(bound));
expect(bound.node, isNot(always));
expect(bound.type, typeProvider.objectType);
}
Future<void> test_function_generic_implicit_bound() async {
await analyze('''
T f<T>(T t) => t;
''');
var bound = decoratedTypeParameterBound('T>')!;
assertEdge(always, bound.node, hard: false);
expect(bound.type, same(typeProvider.objectType));
}
Future<void> test_function_metadata() async {
await analyze('''
class A {
final Object x;
const A(this.x);
}
@A(<int>[])
f() {}
''');
var node = decoratedTypeAnnotation('int').node;
expect(node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_functionExpression() async {
await analyze('''
void f() {
var x = (int i) => 1;
}
''');
var functionExpressionElement =
findNode.simpleParameter('int i').declaredElement!.enclosingElement!;
var decoratedType =
variables!.decoratedElementType(functionExpressionElement);
expect(decoratedType.positionalParameters![0],
same(decoratedTypeAnnotation('int i')));
expect(decoratedType.node, same(never));
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_functionExpression_returns_bottom() async {
await analyze('''
void f() {
var x = (int i) => throw 'foo';
}
''');
var functionExpressionElement =
findNode.simpleParameter('int i').declaredElement!.enclosingElement!;
var decoratedType =
variables!.decoratedElementType(functionExpressionElement);
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_functionTypeAlias_generic() async {
await analyze('''
typedef T F<T, U>(U u);
''');
var element = findElement.typeAlias('F');
var decoratedType =
variables!.decoratedElementType(element.aliasedElement!);
var t = element.typeParameters[0];
var u = element.typeParameters[1];
// typeFormals should be empty because this is not a generic function type,
// it's a generic typedef that defines an ordinary (non-generic) function
// type.
expect(decoratedType.typeFormals, isEmpty);
expect(decoratedType.returnType, same(decoratedTypeAnnotation('T F')));
expect(
(decoratedType.returnType!.type as TypeParameterType).element, same(t));
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
expect(
(decoratedType.positionalParameters![0]!.type as TypeParameterType)
.element,
same(u));
expect(decoratedType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_functionTypeAlias_implicit_return_type() async {
await analyze('''
typedef F();
''');
var decoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
expect(decoratedType.returnType!.type!.isDynamic, isTrue);
expect(decoratedType.returnType!.node!.isImmutable, false);
expect(decoratedType.typeFormals, isEmpty);
}
Future<void> test_functionTypeAlias_simple() async {
await analyze('''
typedef int F(String s);
''');
var decoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
expect(decoratedType.returnType, same(decoratedTypeAnnotation('int')));
expect(decoratedType.typeFormals, isEmpty);
expect(decoratedType.positionalParameters![0],
same(decoratedTypeAnnotation('String')));
}
Future<void>
test_functionTypedFormalParameter_named_no_default_required_hint() async {
await analyze('''
void f({/*required*/ void s()}) {}
''');
expect(
variables!.getRequiredHint(
testSource, findNode.functionTypedFormalParameter('s')),
isNotNull);
}
Future<void>
test_functionTypedFormalParameter_named_no_default_required_hint_no_return() async {
await analyze('''
void f({/*required*/ s()}) {}
''');
expect(
variables!.getRequiredHint(
testSource, findNode.functionTypedFormalParameter('s')),
isNotNull);
}
Future<void> test_functionTypedFormalParameter_namedParameter_typed() async {
await analyze('''
void f(void g({int i})) {}
''');
var f = findElement.function('f');
var g = f.parameters[0];
var fType = variables!.decoratedElementType(f);
var gType = variables!.decoratedElementType(g);
expect(fType.positionalParameters![0], same(gType));
expect(gType.node, TypeMatcher<NullabilityNodeMutable>());
expect(gType.namedParameters!['i'], same(decoratedTypeAnnotation('int')));
}
Future<void>
test_functionTypedFormalParameter_namedParameter_untyped() async {
await analyze('''
void f(void g({i})) {}
''');
var f = findElement.function('f');
var g = f.parameters[0];
var fType = variables!.decoratedElementType(f);
var gType = variables!.decoratedElementType(g);
expect(fType.positionalParameters![0], same(gType));
expect(gType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(gType.namedParameters!['i']!.type!, 'dynamic');
expect(gType.namedParameters!['i']!.node!.isImmutable, false);
}
Future<void>
test_functionTypedFormalParameter_positionalParameter_typed() async {
await analyze('''
void f(void g(int i)) {}
''');
var f = findElement.function('f');
var g = f.parameters[0];
var fType = variables!.decoratedElementType(f);
var gType = variables!.decoratedElementType(g);
expect(fType.positionalParameters![0], same(gType));
expect(gType.node, TypeMatcher<NullabilityNodeMutable>());
expect(
gType.positionalParameters![0], same(decoratedTypeAnnotation('int')));
}
Future<void>
test_functionTypedFormalParameter_positionalParameter_untyped() async {
await analyze('''
void f(void g(i)) {}
''');
var f = findElement.function('f');
var g = f.parameters[0];
var fType = variables!.decoratedElementType(f);
var gType = variables!.decoratedElementType(g);
expect(fType.positionalParameters![0], same(gType));
expect(gType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(gType.positionalParameters![0]!.type!, 'dynamic');
expect(gType.positionalParameters![0]!.node!.isImmutable, false);
}
Future<void> test_functionTypedFormalParameter_return_typed() async {
await analyze('''
void f(int g()) {}
''');
var f = findElement.function('f');
var g = f.parameters[0];
var fType = variables!.decoratedElementType(f);
var gType = variables!.decoratedElementType(g);
expect(fType.positionalParameters![0], same(gType));
expect(gType.node, TypeMatcher<NullabilityNodeMutable>());
expect(gType.returnType, same(decoratedTypeAnnotation('int')));
}
Future<void> test_functionTypedFormalParameter_return_untyped() async {
await analyze('''
void f(g()) {}
''');
var f = findElement.function('f');
var g = f.parameters[0];
var fType = variables!.decoratedElementType(f);
var gType = variables!.decoratedElementType(g);
expect(fType.positionalParameters![0], same(gType));
expect(gType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(gType.returnType!.type!, 'dynamic');
expect(gType.returnType!.node!.isImmutable, false);
}
Future<void> test_genericFunctionType_formals() async {
await analyze('''
void f(T Function<T, U>(U) x) {}
''');
var decoratedType = decoratedGenericFunctionTypeAnnotation('T Function');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
_assertType(decoratedType.type!, 'T Function<T, U>(U)');
expect(decoratedType.typeFormals, hasLength(2));
var t = decoratedType.typeFormals![0];
var u = decoratedType.typeFormals![1];
expect(
(decoratedType.returnType!.type as TypeParameterType).element, same(t));
expect(
(decoratedType.positionalParameters![0]!.type as TypeParameterType)
.element,
same(u));
}
Future<void> test_genericFunctionType_namedParameterType() async {
await analyze('''
void f(void Function({int y}) x) {}
''');
var decoratedType =
decoratedGenericFunctionTypeAnnotation('void Function({int y})');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
var decoratedIntType = decoratedTypeAnnotation('int');
expect(decoratedType.namedParameters!['y'], same(decoratedIntType));
expect(decoratedIntType.node, isNotNull);
expect(decoratedIntType.node, isNot(never));
}
Future<void> test_genericFunctionType_returnType() async {
await analyze('''
void f(int Function() x) {}
''');
var decoratedType =
decoratedGenericFunctionTypeAnnotation('int Function()');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
var decoratedIntType = decoratedTypeAnnotation('int');
expect(decoratedType.returnType, same(decoratedIntType));
expect(decoratedIntType.node, isNotNull);
expect(decoratedIntType.node, isNot(never));
expect(decoratedType.returnType!.node!.displayName,
'return type of parameter 0 of f (test.dart:1:8)');
}
Future<void> test_genericFunctionType_syntax_inferred_dynamic_return() async {
await analyze('''
abstract class C {
Function() f();
}
''');
var decoratedFType = decoratedMethodType('f');
var decoratedFReturnType = decoratedFType.returnType!;
var decoratedFReturnReturnType = decoratedFReturnType.returnType!;
_assertType(decoratedFReturnReturnType.type!, 'dynamic');
expect(decoratedFReturnReturnType.node!.isImmutable, false);
}
Future<void> test_genericFunctionType_unnamedParameterType() async {
await analyze('''
void f(void Function(int) x) {}
''');
var decoratedType =
decoratedGenericFunctionTypeAnnotation('void Function(int)');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
var decoratedIntType = decoratedTypeAnnotation('int');
expect(decoratedType.positionalParameters![0], same(decoratedIntType));
expect(decoratedIntType.node, isNotNull);
expect(decoratedIntType.node, isNot(never));
}
Future<void> test_genericTypeAlias_generic_inner() async {
await analyze('''
typedef F = T Function<T, U>(U u);
''');
var element = findElement.typeAlias('F');
var decoratedType =
variables!.decoratedElementType(element.aliasedElement!);
expect(decoratedType,
same(decoratedGenericFunctionTypeAnnotation('T Function')));
expect(decoratedType.typeFormals, hasLength(2));
var t = decoratedType.typeFormals![0];
var u = decoratedType.typeFormals![1];
expect(decoratedType.returnType, same(decoratedTypeAnnotation('T F')));
expect(
(decoratedType.returnType!.type as TypeParameterType).element, same(t));
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
expect(
(decoratedType.positionalParameters![0]!.type as TypeParameterType)
.element,
same(u));
expect(decoratedType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_genericTypeAlias_generic_outer() async {
await analyze('''
typedef F<T, U> = T Function(U u);
''');
var element = findElement.typeAlias('F');
var decoratedType =
variables!.decoratedElementType(element.aliasedElement!);
expect(decoratedType,
same(decoratedGenericFunctionTypeAnnotation('T Function')));
var t = element.typeParameters[0];
var u = element.typeParameters[1];
// typeFormals should be empty because this is not a generic function type,
// it's a generic typedef that defines an ordinary (non-generic) function
// type.
expect(decoratedType.typeFormals, isEmpty);
expect(decoratedType.returnType, same(decoratedTypeAnnotation('T F')));
expect(
(decoratedType.returnType!.type as TypeParameterType).element, same(t));
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
expect(
(decoratedType.positionalParameters![0]!.type as TypeParameterType)
.element,
same(u));
expect(decoratedType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_genericTypeAlias_implicit_return_type() async {
await analyze('''
typedef F = Function();
''');
var decoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
expect(decoratedType,
same(decoratedGenericFunctionTypeAnnotation('Function')));
expect(decoratedType.returnType!.type!.isDynamic, isTrue);
expect(decoratedType.returnType!.node!.isImmutable, false);
expect(decoratedType.typeFormals, isEmpty);
}
Future<void> test_genericTypeAlias_simple() async {
await analyze('''
typedef F = int Function(String s);
''');
var decoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
expect(decoratedType,
same(decoratedGenericFunctionTypeAnnotation('int Function')));
expect(decoratedType.returnType, same(decoratedTypeAnnotation('int')));
expect(decoratedType.typeFormals, isEmpty);
expect(decoratedType.positionalParameters![0],
same(decoratedTypeAnnotation('String')));
expect(decoratedType.returnType!.node!.displayName,
'return type of F (test.dart:1:13)');
}
Future<void> test_implicit_type_nested_no_add_hint_actions() async {
await analyze('''
var x = [1];
''');
final node = variables!
.decoratedElementType(findNode
.topLevelVariableDeclaration('x')
.variables
.variables[0]
.declaredElement!)
.typeArguments[0]!
.node!;
expect(node.hintActions, isEmpty);
}
Future<void> test_implicit_type_no_add_hint_actions() async {
await analyze('''
var x = 1;
''');
final node = variables!
.decoratedElementType(findNode
.topLevelVariableDeclaration('x')
.variables
.variables[0]
.declaredElement!)
.node!;
expect(node.hintActions, isEmpty);
}
Future<void> test_interfaceType_generic_instantiate_to_dynamic() async {
await analyze('''
void f(List x) {}
''');
var decoratedListType = decoratedTypeAnnotation('List');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedListType));
expect(decoratedListType.node, isNotNull);
expect(decoratedListType.node, isNot(never));
var decoratedArgType = decoratedListType.typeArguments[0]!;
expect(decoratedArgType.node!.isImmutable, false);
}
Future<void> test_interfaceType_generic_instantiate_to_function_type() async {
await analyze('''
class C<T extends int Function()> {}
void f(C x) {}
''');
var decoratedCType = decoratedTypeAnnotation('C x');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedCType));
expect(decoratedCType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedCType.typeArguments, hasLength(1));
var decoratedArgType = decoratedCType.typeArguments[0]!;
expect(decoratedArgType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArgType.typeArguments, isEmpty);
var decoratedArgReturnType = decoratedArgType.returnType!;
expect(decoratedArgReturnType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArgReturnType.typeArguments, isEmpty);
}
Future<void>
test_interfaceType_generic_instantiate_to_function_type_void() async {
await analyze('''
class C<T extends void Function()> {}
void f(C x) {}
''');
var decoratedCType = decoratedTypeAnnotation('C x');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedCType));
expect(decoratedCType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedCType.typeArguments, hasLength(1));
var decoratedArgType = decoratedCType.typeArguments[0]!;
expect(decoratedArgType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArgType.typeArguments, isEmpty);
var decoratedArgReturnType = decoratedArgType.returnType!;
expect(decoratedArgReturnType.node!.isImmutable, false);
expect(decoratedArgReturnType.typeArguments, isEmpty);
}
Future<void> test_interfaceType_generic_instantiate_to_generic_type() async {
await analyze('''
class C<T> {}
class D<T extends C<int>> {}
void f(D x) {}
''');
var decoratedDType = decoratedTypeAnnotation('D x');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedDType));
expect(decoratedDType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedDType.typeArguments, hasLength(1));
var decoratedArgType = decoratedDType.typeArguments[0]!;
expect(decoratedArgType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArgType.typeArguments, hasLength(1));
var decoratedArgArgType = decoratedArgType.typeArguments[0]!;
expect(decoratedArgArgType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArgArgType.typeArguments, isEmpty);
}
Future<void>
test_interfaceType_generic_instantiate_to_generic_type_2() async {
await analyze('''
class C<T, U> {}
class D<T extends C<int, String>, U extends C<num, double>> {}
void f(D x) {}
''');
var decoratedDType = decoratedTypeAnnotation('D x');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedDType));
expect(decoratedDType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedDType.typeArguments, hasLength(2));
var decoratedArg0Type = decoratedDType.typeArguments[0]!;
expect(decoratedArg0Type.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArg0Type.typeArguments, hasLength(2));
var decoratedArg0Arg0Type = decoratedArg0Type.typeArguments[0]!;
expect(decoratedArg0Arg0Type.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArg0Arg0Type.typeArguments, isEmpty);
var decoratedArg0Arg1Type = decoratedArg0Type.typeArguments[1]!;
expect(decoratedArg0Arg1Type.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArg0Arg1Type.typeArguments, isEmpty);
var decoratedArg1Type = decoratedDType.typeArguments[1]!;
expect(decoratedArg1Type.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArg1Type.typeArguments, hasLength(2));
var decoratedArg1Arg0Type = decoratedArg1Type.typeArguments[0]!;
expect(decoratedArg1Arg0Type.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArg1Arg0Type.typeArguments, isEmpty);
var decoratedArg1Arg1Type = decoratedArg1Type.typeArguments[1]!;
expect(decoratedArg1Arg1Type.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArg1Arg1Type.typeArguments, isEmpty);
}
Future<void> test_interfaceType_generic_instantiate_to_object() async {
await analyze('''
class C<T extends Object> {}
void f(C x) {}
''');
var decoratedListType = decoratedTypeAnnotation('C x');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedListType));
expect(decoratedListType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedListType.typeArguments, hasLength(1));
var decoratedArgType = decoratedListType.typeArguments[0]!;
expect(decoratedArgType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedArgType.typeArguments, isEmpty);
}
Future<void> test_interfaceType_typeParameter() async {
await analyze('''
void f(List<int> x) {}
''');
var decoratedListType = decoratedTypeAnnotation('List<int>');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedListType));
expect(decoratedListType.node, isNotNull);
expect(decoratedListType.node, isNot(never));
var decoratedIntType = decoratedTypeAnnotation('int');
expect(decoratedListType.typeArguments[0], same(decoratedIntType));
expect(decoratedIntType.node, isNotNull);
expect(decoratedIntType.node, isNot(never));
}
Future<void> test_local_function() async {
await analyze('''
void f() {
int g(int i) => 1;
}
''');
var decoratedType = decoratedFunctionType('g');
expect(decoratedType.returnType, same(decoratedTypeAnnotation('int g')));
expect(decoratedType.positionalParameters![0],
same(decoratedTypeAnnotation('int i')));
expect(decoratedType.node, same(never));
}
Future<void> test_localVariable_type_implicit_dynamic() async {
await analyze('''
main() {
var x;
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_localVariable_type_inferred() async {
await analyze('''
main() {
var x = 1;
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_localVariable_type_inferred_dynamic() async {
await analyze('''
dynamic f() {}
main() {
var x = f();
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_localVariable_type_inferred_function() async {
await analyze('''
main() {
var x = () => 1;
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.returnType!.node!.displayName,
'return type of main.x (test.dart:2:7)');
}
Future<void> test_localVariable_type_inferred_generic() async {
await analyze('''
main() {
var x = {1: 2};
}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.typeArguments[0]!.node!.displayName,
'type argument 0 of main.x (test.dart:2:7)');
expect(decoratedType.typeArguments[1]!.node!.displayName,
'type argument 1 of main.x (test.dart:2:7)');
}
Future<void> test_method_generic_bounded() async {
await analyze('''
class C {
T f<T extends Object>(T t) => t;
}
''');
var bound = decoratedTypeParameterBound('T extends')!;
expect(decoratedTypeAnnotation('Object'), same(bound));
expect(bound.node, isNot(always));
expect(bound.type, typeProvider.objectType);
}
Future<void> test_method_generic_implicit_bound() async {
await analyze('''
class C {
T f<T>(T t) => t;
}
''');
var bound = decoratedTypeParameterBound('T>')!;
assertEdge(always, bound.node, hard: false);
expect(bound.type, same(typeProvider.objectType));
}
Future<void> test_method_metadata() async {
await analyze('''
class A {
final Object x;
const A(this.x);
}
class C {
@A(<int>[])
f() {}
}
''');
var node = decoratedTypeAnnotation('int').node;
expect(node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_method_parameterType_implicit_dynamic() async {
await analyze('''
class C {
void f(x) {}
}
''');
var decoratedType = decoratedMethodType('f').positionalParameters![0]!;
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_method_parameterType_implicit_dynamic_named() async {
await analyze('''
class C {
void f({x}) {}
}
''');
var decoratedType = decoratedMethodType('f').namedParameters!['x']!;
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_method_parameterType_inferred() async {
await analyze('''
class B {
void f(int x) {}
}
class C extends B {
void f/*C*/(x) {}
}
''');
var decoratedType = decoratedMethodType('f/*C*/').positionalParameters![0]!;
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_method_parameterType_inferred_dynamic() async {
await analyze('''
class B {
void f(dynamic x) {}
}
class C extends B {
void f/*C*/(x) {}
}
''');
var decoratedType = decoratedMethodType('f/*C*/').positionalParameters![0]!;
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_method_parameterType_inferred_dynamic_named() async {
await analyze('''
class B {
void f({dynamic x = 0}) {}
}
class C extends B {
void f/*C*/({x = 0}) {}
}
''');
var decoratedType = decoratedMethodType('f/*C*/').namedParameters!['x']!;
expect(decoratedType.node!.isImmutable, false);
}
Future<void>
test_method_parameterType_inferred_generic_function_typed_no_bound() async {
await analyze('''
class B {
void f/*B*/(T Function<T>() x) {}
}
class C extends B {
void f/*C*/(x) {}
}
''');
var decoratedBaseType =
decoratedMethodType('f/*B*/').positionalParameters![0]!;
var decoratedType = decoratedMethodType('f/*C*/').positionalParameters![0]!;
var decoratedTypeFormalBound = decoratedTypeParameterBounds
.get((decoratedType.type as FunctionType).typeFormals[0])!;
_assertType(decoratedTypeFormalBound.type!, 'Object');
var decoratedBaseTypeFormalBound = decoratedTypeParameterBounds
.get((decoratedBaseType.type as FunctionType).typeFormals[0])!;
expect(decoratedTypeFormalBound.node,
isNot(same(decoratedBaseTypeFormalBound.node)));
}
Future<void>
test_method_parameterType_inferred_generic_function_typed_with_bound() async {
await analyze('''
class B {
void f/*B*/(T Function<T extends num>() x) {}
}
class C extends B {
void f/*C*/(x) {}
}
''');
var decoratedBaseType =
decoratedMethodType('f/*B*/').positionalParameters![0]!;
var decoratedType = decoratedMethodType('f/*C*/').positionalParameters![0]!;
var decoratedTypeFormalBound = decoratedTypeParameterBounds
.get((decoratedType.type as FunctionType).typeFormals[0])!;
_assertType(decoratedTypeFormalBound.type!, 'num');
var decoratedBaseTypeFormalBound = decoratedTypeParameterBounds
.get((decoratedBaseType.type as FunctionType).typeFormals[0])!;
expect(decoratedTypeFormalBound.node,
isNot(same(decoratedBaseTypeFormalBound.node)));
}
Future<void> test_method_parameterType_inferred_named() async {
await analyze('''
class B {
void f({int x = 0}) {}
}
class C extends B {
void f/*C*/({x = 0}) {}
}
''');
var decoratedType = decoratedMethodType('f/*C*/').namedParameters!['x']!;
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_method_returnType_implicit_dynamic() async {
await analyze('''
class C {
f() => 1;
}
''');
var decoratedType = decoratedMethodType('f').returnType!;
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_method_returnType_inferred() async {
await analyze('''
class B {
int f() => 1;
}
class C extends B {
f/*C*/() => 1;
}
''');
var decoratedType = decoratedMethodType('f/*C*/').returnType!;
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_method_returnType_inferred_dynamic() async {
await analyze('''
class B {
dynamic f() => 1;
}
class C extends B {
f/*C*/() => 1;
}
''');
var decoratedType = decoratedMethodType('f/*C*/').returnType!;
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_parameters() async {
await analyze('''
void foo({List<int> values}) {
values.where((i) => true);
}
''');
// No assertions; just checking that it doesn't crash.
}
Future<void> test_topLevelFunction_parameterType_implicit_dynamic() async {
await analyze('''
void f(x) {}
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.type!.isDynamic, isTrue);
}
Future<void> test_topLevelFunction_parameterType_named_no_default() async {
await analyze('''
void f({String s}) {}
''');
var decoratedType = decoratedTypeAnnotation('String');
var functionType = decoratedFunctionType('f');
expect(functionType.namedParameters!['s'], same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
expect(decoratedType.node, isNot(always));
expect(functionType.namedParameters!['s']!.node!.isPossiblyOptional, true);
}
Future<void>
test_topLevelFunction_parameterType_named_no_default_required() async {
addMetaPackage();
await analyze('''
import 'package:meta/meta.dart';
void f({@required String s}) {}
''');
var decoratedType = decoratedTypeAnnotation('String');
var functionType = decoratedFunctionType('f');
expect(functionType.namedParameters!['s'], same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
expect(decoratedType.node, isNot(always));
expect(functionType.namedParameters!['s']!.node!.isPossiblyOptional, false);
}
Future<void>
test_topLevelFunction_parameterType_named_no_default_required_hint() async {
addMetaPackage();
await analyze('''
import 'package:meta/meta.dart';
void f({/*required*/ String s}) {}
''');
var decoratedType = decoratedTypeAnnotation('String');
var functionType = decoratedFunctionType('f');
expect(functionType.namedParameters!['s'], same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
expect(decoratedType.node, isNot(always));
expect(functionType.namedParameters!['s']!.node!.isPossiblyOptional, false);
expect(
variables!.getRequiredHint(testSource, findNode.simpleParameter('s')),
isNotNull);
}
Future<void> test_topLevelFunction_parameterType_named_with_default() async {
await analyze('''
void f({String s: 'x'}) {}
''');
var decoratedType = decoratedTypeAnnotation('String');
var functionType = decoratedFunctionType('f');
expect(functionType.namedParameters!['s'], same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
expect(functionType.namedParameters!['s']!.node!.isPossiblyOptional, false);
}
Future<void> test_topLevelFunction_parameterType_positionalOptional() async {
await analyze('''
void f([int i]) {}
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
}
Future<void> test_topLevelFunction_parameterType_simple() async {
await analyze('''
void f(int i) {}
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(decoratedFunctionType('f').positionalParameters![0],
same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
}
Future<void> test_topLevelFunction_returnType_implicit_dynamic() async {
await analyze('''
f() {}
''');
var decoratedType = decoratedFunctionType('f').returnType!;
expect(decoratedType.type!.isDynamic, isTrue);
}
Future<void> test_topLevelFunction_returnType_simple() async {
await analyze('''
int f() => 0;
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(decoratedFunctionType('f').returnType, same(decoratedType));
expect(decoratedType.node, isNotNull);
expect(decoratedType.node, isNot(never));
}
Future<void> test_topLevelVariable_type_implicit_dynamic() async {
await analyze('''
var x;
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_topLevelVariable_type_inferred() async {
await analyze('''
var x = 1;
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_topLevelVariable_type_inferred_dynamic() async {
await analyze('''
dynamic f() {}
var x = f();
''');
var decoratedType =
variables!.decoratedElementType(findNode.simple('x').staticElement!);
expect(decoratedType.node!.isImmutable, false);
}
Future<void> test_type_add_non_null_hint() async {
await analyze('''
void f(int i) {}
''');
final node = decoratedTypeAnnotation('int').node!;
expect(node.hintActions, contains(HintActionKind.addNonNullableHint));
expect(
node.hintActions[HintActionKind.addNonNullableHint]
.applyTo(super.testCode!),
'''
void f(int/*!*/ i) {}
''');
}
Future<void> test_type_add_null_hint() async {
await analyze('''
void f(int i) {}
''');
final node = decoratedTypeAnnotation('int').node!;
expect(node.hintActions, contains(HintActionKind.addNullableHint));
expect(
node.hintActions[HintActionKind.addNullableHint]
.applyTo(super.testCode!),
'''
void f(int/*?*/ i) {}
''');
}
Future<void> test_type_comment_bang() async {
await analyze('''
void f(int/*!*/ i) {}
''');
final node = decoratedTypeAnnotation('int').node!;
assertEdge(node, never, hard: true, checkable: false);
expect(
node.hintActions, isNot(contains(HintActionKind.addNonNullableHint)));
expect(node.hintActions, isNot(contains(HintActionKind.addNullableHint)));
expect(node.hintActions,
isNot(contains(HintActionKind.changeToNonNullableHint)));
expect(
node.hintActions[HintActionKind.removeNonNullableHint]
.applyTo(super.testCode!),
'''
void f(int i) {}
''');
expect(
node.hintActions[HintActionKind.changeToNullableHint]
.applyTo(super.testCode!),
'''
void f(int/*?*/ i) {}
''');
}
Future<void> test_type_comment_question() async {
await analyze('''
void f(int/*?*/ i) {}
''');
final node = decoratedTypeAnnotation('int').node!;
assertUnion(always, node);
expect(
node.hintActions, isNot(contains(HintActionKind.addNonNullableHint)));
expect(node.hintActions, isNot(contains(HintActionKind.addNullableHint)));
expect(
node.hintActions, isNot(contains(HintActionKind.changeToNullableHint)));
expect(
node.hintActions[HintActionKind.removeNullableHint]
.applyTo(super.testCode!),
'''
void f(int i) {}
''');
expect(
node.hintActions[HintActionKind.changeToNonNullableHint]
.applyTo(super.testCode!),
'''
void f(int/*!*/ i) {}
''');
}
Future<void> test_type_nested_add_non_null_hint() async {
await analyze('''
void f(List<int> i) {}
''');
final node = decoratedTypeAnnotation('int').node!;
expect(node.hintActions, contains(HintActionKind.addNonNullableHint));
expect(
node.hintActions[HintActionKind.addNonNullableHint]
.applyTo(super.testCode!),
'''
void f(List<int/*!*/> i) {}
''');
}
Future<void> test_type_nested_add_null_hint() async {
await analyze('''
void f(List<int> i) {}
''');
final node = decoratedTypeAnnotation('int').node!;
expect(node.hintActions, contains(HintActionKind.addNullableHint));
expect(
node.hintActions[HintActionKind.addNullableHint]
.applyTo(super.testCode!),
'''
void f(List<int/*?*/> i) {}
''');
}
Future<void> test_type_parameter_explicit_bound() async {
await analyze('''
class C<T extends Object> {}
''');
var bound = decoratedTypeParameterBound('T')!;
expect(decoratedTypeAnnotation('Object'), same(bound));
expect(bound.node, isNot(always));
expect(bound.type, typeProvider.objectType);
}
Future<void> test_type_parameter_implicit_bound() async {
// The implicit bound of `T` is automatically `Object?`. TODO(paulberry):
// consider making it possible for type inference to infer an explicit bound
// of `Object`.
await analyze('''
class C<T> {}
''');
var bound = decoratedTypeParameterBound('T')!;
assertEdge(always, bound.node, hard: false);
expect(bound.type, same(typeProvider.objectType));
}
Future<void> test_typedef_reference_generic_instantiated() async {
await analyze('''
typedef F<T> = T Function();
F<int> f;
''');
// The instantiation of F should produce fresh nullability nodes, distinct
// from the ones in the typedef (they will be unified by the edge builder).
// This is necessary because there is no guarantee of whether the typedef or
// its usage will be visited first.
var typedefDecoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
var decoratedType = decoratedTypeAnnotation('F<int>');
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.node, isNot(same(typedefDecoratedType.node)));
_assertType(decoratedType.returnType!.type!, 'int');
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.returnType!.node,
isNot(same(typedefDecoratedType.returnType!.node)));
}
Future<void> test_typedef_reference_generic_uninstantiated() async {
await analyze('''
typedef F = T Function<T extends num>();
F f;
''');
// The instantiation of F should produce fresh nullability nodes, distinct
// from the ones in the typedef (they will be unified by the edge builder).
// This is necessary because there is no guarantee of whether the typedef or
// its usage will be visited first.
var typedefDecoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
var decoratedType = decoratedTypeAnnotation('F f');
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.node, isNot(same(typedefDecoratedType.node)));
_assertType(decoratedType.returnType!.type!, 'T');
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.returnType!.node,
isNot(same(typedefDecoratedType.returnType!.node)));
var decoratedTypeFormalBound = decoratedTypeParameterBounds
.get((decoratedType.type as FunctionType).typeFormals[0])!;
_assertType(decoratedTypeFormalBound.type!, 'num');
expect(decoratedTypeFormalBound.node!.displayName,
'bound of type formal T of f (test.dart:2:1)');
var decoratedTypedefTypeFormalBound = decoratedTypeParameterBounds
.get((typedefDecoratedType.type as FunctionType).typeFormals[0])!;
expect(decoratedTypeFormalBound.node,
isNot(same(decoratedTypedefTypeFormalBound.node)));
}
Future<void> test_typedef_reference_simple() async {
await analyze('''
typedef int F(String s);
F f;
''');
// The instantiation of F should produce fresh nullability nodes, distinct
// from the ones in the typedef (they will be unified by the edge builder).
// This is necessary because there is no guarantee of whether the typedef or
// its usage will be visited first.
var typedefDecoratedType = variables!
.decoratedElementType(findElement.typeAlias('F').aliasedElement!);
var decoratedType = decoratedTypeAnnotation('F f');
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.node, isNot(same(typedefDecoratedType.node)));
_assertType(decoratedType.returnType!.type!, 'int');
expect(
decoratedType.returnType!.node, TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.returnType!.node,
isNot(same(typedefDecoratedType.returnType!.node)));
expect(typedefDecoratedType.returnType!.node!.displayName,
'return type of F (test.dart:1:9)');
expect(decoratedType.returnType!.node!.displayName,
'return type of f (test.dart:2:1)');
_assertType(decoratedType.positionalParameters![0]!.type!, 'String');
expect(decoratedType.positionalParameters![0]!.node,
TypeMatcher<NullabilityNodeMutable>());
expect(decoratedType.positionalParameters![0]!.node,
isNot(same(typedefDecoratedType.positionalParameters![0]!.node)));
expect(decoratedType.positionalParameters![0]!.node!.displayName,
'parameter 0 of f (test.dart:2:1)');
}
Future<void> test_typedef_reference_simple_named_parameter() async {
await analyze('''
typedef int F({String s});
F f;
''');
// The instantiation of F should produce fresh nullability nodes, distinct
// from the ones in the typedef (they will be unified by the edge builder).
// This is necessary because there is no guarantee of whether the typedef or
// its usage will be visited first.
var decoratedType = decoratedTypeAnnotation('F f');
expect(decoratedType.namedParameters!['s']!.node!.displayName,
'parameter s of f (test.dart:2:1)');
}
Future<void> test_typedef_reference_simple_two_parameters() async {
await analyze('''
typedef int F(String s, int i);
F f;
''');
// The instantiation of F should produce fresh nullability nodes, distinct
// from the ones in the typedef (they will be unified by the edge builder).
// This is necessary because there is no guarantee of whether the typedef or
// its usage will be visited first.
var decoratedType = decoratedTypeAnnotation('F f');
expect(decoratedType.positionalParameters![0]!.node!.displayName,
'parameter 0 of f (test.dart:2:1)');
expect(decoratedType.positionalParameters![1]!.node!.displayName,
'parameter 1 of f (test.dart:2:1)');
}
Future<void> test_typedef_rhs_nullability() async {
await analyze('''
typedef F = void Function();
''');
var decorated = decoratedGenericFunctionTypeAnnotation('void Function()');
expect(decorated.node, same(never));
}
Future<void> test_variableDeclaration_late_final_hint_simple() async {
await analyze('/*late final*/ int i;');
expect(
variables!
.getLateHint(testSource, findNode.variableDeclarationList('int i')),
isNotNull);
}
Future<void> test_variableDeclaration_late_hint_after_metadata() async {
await analyze('@deprecated /*late*/ int i;');
expect(
variables!
.getLateHint(testSource, findNode.variableDeclarationList('int i')),
isNotNull);
}
Future<void> test_variableDeclaration_late_hint_multiple_comments() async {
await analyze('/*other*/ /*late*/ int i;');
expect(
variables!
.getLateHint(testSource, findNode.variableDeclarationList('int i')),
isNotNull);
}
Future<void> test_variableDeclaration_late_hint_simple() async {
await analyze('/*late*/ int i;');
expect(
variables!
.getLateHint(testSource, findNode.variableDeclarationList('int i')),
isNotNull);
}
Future<void> test_variableDeclaration_late_hint_with_spaces() async {
await analyze('/* late */ int i;');
expect(
variables!
.getLateHint(testSource, findNode.variableDeclarationList('int i')),
isNotNull);
}
Future<void> test_variableDeclaration_type_simple() async {
await analyze('''
main() {
int i;
}
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_variableDeclaration_visit_initializer() async {
await analyze('''
class C<T> {}
void f(C<dynamic> c) {
var x = c as C<int>;
}
''');
var decoratedType = decoratedTypeAnnotation('int');
expect(decoratedType.node, TypeMatcher<NullabilityNodeMutable>());
}
Future<void> test_void_type() async {
await analyze('''
void f() {}
''');
var decoratedType = decoratedTypeAnnotation('void');
expect(decoratedFunctionType('f').returnType, same(decoratedType));
assertNoEdge(always, decoratedType.node);
}
void _assertType(DartType type, String expected) {
var typeStr = type.getDisplayString(withNullability: false);
expect(typeStr, expected);
}
}