blob: fdc03f174133eb71eaa564322d201ac1823db339 [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/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/dart/element/type_provider.dart';
import 'package:analyzer/source/line_info.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
import 'package:analyzer/src/generated/testing/element_factory.dart';
import 'package:analyzer/src/generated/testing/test_type_provider.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/src/already_migrated_code_decorator.dart';
import 'package:nnbd_migration/src/decorated_type.dart';
import 'package:nnbd_migration/src/nullability_node.dart';
import 'package:nnbd_migration/src/nullability_node_target.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import 'migration_visitor_test_base.dart';
main() {
defineReflectiveSuite(() {
defineReflectiveTests(_AlreadyMigratedCodeDecoratorTestNormal);
defineReflectiveTests(_AlreadyMigratedCodeDecoratorTestProvisional);
});
}
class _AlreadyMigratedCodeDecoratorTestBase extends Object with EdgeTester {
final TypeProvider typeProvider;
final AlreadyMigratedCodeDecorator decorator;
final NullabilityGraphForTesting graph;
final NullabilitySuffix suffix;
Element element = _MockElement();
final decoratedTypeParameterBounds = DecoratedTypeParameterBounds();
_AlreadyMigratedCodeDecoratorTestBase(NullabilitySuffix nullabilitySuffix)
: this._(
nullabilitySuffix,
NullabilityGraphForTesting(),
TestTypeProvider(),
);
_AlreadyMigratedCodeDecoratorTestBase._(
this.suffix, this.graph, this.typeProvider)
: decorator =
AlreadyMigratedCodeDecorator(graph, typeProvider, _getLineInfo);
NullabilityNode get always => graph.always;
NullabilityNode get never => graph.never;
void checkAlwaysNullable(NullabilityNode node, String displayName) {
var edge = assertEdge(always, node, hard: true, checkable: false);
var origin = graph.getEdgeOrigin(edge);
expect(origin.kind, EdgeOriginKind.alwaysNullableType);
expect(origin.element, same(element));
expect(node.displayName, displayName);
}
void checkDynamic(DecoratedType decoratedType, String displayName) {
expect(decoratedType.type, same(typeProvider.dynamicType));
checkAlwaysNullable(decoratedType.node, displayName);
}
void checkExplicitlyNonNullable(NullabilityNode node, String displayName) {
var edge = assertEdge(node, never, hard: true, checkable: false);
var origin = graph.getEdgeOrigin(edge);
expect(origin.kind, EdgeOriginKind.alreadyMigratedType);
expect(origin.element, same(element));
expect(node.displayName, displayName);
}
void checkExplicitlyNullable(NullabilityNode node, String displayName) {
var edge = assertEdge(always, node, hard: true, checkable: false);
var origin = graph.getEdgeOrigin(edge);
expect(origin.kind, EdgeOriginKind.alreadyMigratedType);
expect(origin.element, same(element));
expect(node.displayName, displayName);
}
void checkFutureOr(
DecoratedType decoratedType,
void Function(NullabilityNode, String) checkNullability,
void Function(DecoratedType, String) checkArgument,
String displayName) {
expect(decoratedType.type.element, typeProvider.futureOrElement);
checkNullability(decoratedType.node, displayName);
checkArgument(
decoratedType.typeArguments[0], 'type argument 0 of $displayName');
}
void checkInt(
DecoratedType decoratedType,
void Function(NullabilityNode, String) checkNullability,
String displayName) {
expect(decoratedType.type.element, typeProvider.intType.element);
checkNullability(decoratedType.node, displayName);
}
void checkIterable(
DecoratedType decoratedType,
void Function(NullabilityNode, String) checkNullability,
void Function(DecoratedType, String) checkArgument,
String displayName) {
expect(
decoratedType.type.element, typeProvider.iterableDynamicType.element);
checkNullability(decoratedType.node, displayName);
checkArgument(
decoratedType.typeArguments[0], 'type argument 0 of $displayName');
}
void checkNever(DecoratedType decoratedType, String displayName) {
expect(decoratedType.type, same(typeProvider.neverType));
checkExplicitlyNonNullable(decoratedType.node, displayName);
}
void checkNum(
DecoratedType decoratedType,
void Function(NullabilityNode, String) checkNullability,
String displayName) {
expect(decoratedType.type.element, typeProvider.numType.element);
checkNullability(decoratedType.node, displayName);
}
void checkObject(
DecoratedType decoratedType,
void Function(NullabilityNode, String) checkNullability,
String displayName) {
expect(decoratedType.type.element, typeProvider.objectType.element);
checkNullability(decoratedType.node, displayName);
}
void checkTypeParameter(
DecoratedType decoratedType,
void Function(NullabilityNode, String) checkNullability,
TypeParameterElement expectedElement,
String displayName) {
var type = decoratedType.type as TypeParameterTypeImpl;
expect(type.element, same(expectedElement));
checkNullability(decoratedType.node, displayName);
}
void checkVoid(DecoratedType decoratedType, String displayName) {
expect(decoratedType.type, same(typeProvider.voidType));
checkAlwaysNullable(decoratedType.node, displayName);
}
DecoratedType decorate(DartType type) {
var decoratedType = decorator.decorate(
type, element, NullabilityNodeTarget.text('test type'));
expect(decoratedType.type, same(type));
return decoratedType;
}
DecoratedType getDecoratedBound(TypeParameterElement element) =>
decoratedTypeParameterBounds.get(element);
void setUp() {
DecoratedTypeParameterBounds.current = decoratedTypeParameterBounds;
}
void tearDown() {
DecoratedTypeParameterBounds.current = null;
}
void test_decorate_dynamic() {
checkDynamic(decorate(typeProvider.dynamicType), 'test type');
}
void test_decorate_functionType_generic_bounded() {
var typeFormal = element = TypeParameterElementImpl.synthetic('T')
..bound = typeProvider.numType;
var decoratedType = decorate(
FunctionTypeImpl(
typeFormals: [typeFormal],
parameters: const [],
returnType: TypeParameterTypeImpl(
element: typeFormal,
nullabilitySuffix: NullabilitySuffix.star,
),
nullabilitySuffix: suffix,
),
);
checkNum(getDecoratedBound(typeFormal), checkExplicitlyNonNullable,
'bound of type formal T of test type');
checkTypeParameter(decoratedType.returnType, checkExplicitlyNonNullable,
typeFormal, 'return type of test type');
}
void test_decorate_functionType_generic_no_explicit_bound() {
var typeFormal = element = TypeParameterElementImpl.synthetic('T');
var decoratedType = decorate(
FunctionTypeImpl(
typeFormals: [typeFormal],
parameters: const [],
returnType: TypeParameterTypeImpl(
element: typeFormal,
nullabilitySuffix: NullabilitySuffix.star,
),
nullabilitySuffix: suffix,
),
);
checkObject(getDecoratedBound(typeFormal), checkExplicitlyNullable,
'bound of type formal T of test type');
checkTypeParameter(decoratedType.returnType, checkExplicitlyNonNullable,
typeFormal, 'return type of test type');
}
void test_decorate_functionType_named_parameter() {
checkDynamic(
decorate(
FunctionTypeImpl(
typeFormals: const [],
parameters: [
ParameterElementImpl.synthetic(
'x',
typeProvider.dynamicType,
ParameterKind.NAMED,
)
],
returnType: typeProvider.voidType,
nullabilitySuffix: suffix,
),
).namedParameters['x'],
'parameter x of test type');
}
void test_decorate_functionType_ordinary_parameters() {
var decoratedType = decorate(
FunctionTypeImpl(
typeFormals: const [],
parameters: [
ParameterElementImpl.synthetic(
'x',
typeProvider.dynamicType,
ParameterKind.REQUIRED,
),
ParameterElementImpl.synthetic(
'y',
typeProvider.dynamicType,
ParameterKind.REQUIRED,
)
],
returnType: typeProvider.voidType,
nullabilitySuffix: suffix,
),
);
checkDynamic(
decoratedType.positionalParameters[0], 'parameter 0 of test type');
checkDynamic(
decoratedType.positionalParameters[1], 'parameter 1 of test type');
}
void test_decorate_functionType_positional_parameter() {
checkDynamic(
decorate(
FunctionTypeImpl(
typeFormals: const [],
parameters: [
ParameterElementImpl.synthetic(
'x',
typeProvider.dynamicType,
ParameterKind.POSITIONAL,
)
],
returnType: typeProvider.voidType,
nullabilitySuffix: suffix,
),
).positionalParameters[0],
'parameter 0 of test type');
}
void test_decorate_functionType_question() {
checkExplicitlyNullable(
decorate(
FunctionTypeImpl(
typeFormals: const [],
parameters: const [],
returnType: typeProvider.voidType,
nullabilitySuffix: NullabilitySuffix.question,
),
).node,
'test type');
}
void test_decorate_functionType_returnType() {
checkDynamic(
decorate(
FunctionTypeImpl(
typeFormals: const [],
parameters: const [],
returnType: typeProvider.dynamicType,
nullabilitySuffix: suffix,
),
).returnType,
'return type of test type');
}
void test_decorate_functionType_star() {
checkExplicitlyNonNullable(
decorate(
FunctionTypeImpl(
typeFormals: const [],
parameters: const [],
returnType: typeProvider.voidType,
nullabilitySuffix: suffix,
),
).node,
'test type');
}
void test_decorate_interfaceType_parameters() {
var decoratedType = decorate(InterfaceTypeImpl(
element: typeProvider.mapElement,
typeArguments: [typeProvider.intType, typeProvider.numType],
nullabilitySuffix: suffix));
checkInt(decoratedType.typeArguments[0], checkExplicitlyNonNullable,
'type argument 0 of test type');
checkNum(decoratedType.typeArguments[1], checkExplicitlyNonNullable,
'type argument 1 of test type');
}
void test_decorate_interfaceType_simple_question() {
checkInt(
decorate(
InterfaceTypeImpl(
element: typeProvider.intElement,
typeArguments: const [],
nullabilitySuffix: NullabilitySuffix.question,
),
),
checkExplicitlyNullable,
'test type');
}
void test_decorate_interfaceType_simple_star() {
checkInt(
decorate(
InterfaceTypeImpl(
element: typeProvider.intElement,
typeArguments: const [],
nullabilitySuffix: suffix,
),
),
checkExplicitlyNonNullable,
'test type');
}
void test_decorate_iterable_dynamic() {
var decorated = decorate(typeProvider.iterableDynamicType);
checkIterable(
decorated, checkExplicitlyNonNullable, checkDynamic, 'test type');
}
void test_decorate_never() {
checkNever(decorate(typeProvider.neverType), 'test type');
}
void test_decorate_typeParameterType_question() {
var element = TypeParameterElementImpl.synthetic('T');
checkTypeParameter(
decorate(TypeParameterTypeImpl(
element: element, nullabilitySuffix: NullabilitySuffix.question)),
checkExplicitlyNullable,
element,
'test type');
}
void test_decorate_typeParameterType_star() {
var element = TypeParameterElementImpl.synthetic('T');
checkTypeParameter(
decorate(
TypeParameterTypeImpl(element: element, nullabilitySuffix: suffix)),
checkExplicitlyNonNullable,
element,
'test type');
}
void test_decorate_void() {
checkVoid(decorate(typeProvider.voidType), 'test type');
}
void test_getImmediateSupertypes_future() {
var class_ = element = typeProvider.futureElement;
var decoratedSupertypes = decorator.getImmediateSupertypes(class_).toList();
var typeParam = class_.typeParameters[0];
expect(decoratedSupertypes, hasLength(2));
// Note: the bogus location `async:1:1` is because we're using a
// TestTypeProvider.
checkObject(decoratedSupertypes[0], checkExplicitlyNonNullable,
'Future (async:1:1)');
// Since Future<T> is a subtype of FutureOr<T>, we consider FutureOr<T> to
// be an immediate supertype, even though the class declaration for Future
// doesn't mention FutureOr.
// Note: the bogus location `async:1:1` is because we're using a
// TestTypeProvider.
checkFutureOr(
decoratedSupertypes[1],
checkExplicitlyNonNullable,
(t, displayName) => checkTypeParameter(
t, checkExplicitlyNonNullable, typeParam, displayName),
'Future (async:1:1)');
}
void test_getImmediateSupertypes_generic() {
var t = ElementFactory.typeParameterElement('T');
var class_ = element = ElementFactory.classElement3(
name: 'C',
typeParameters: [t],
supertype: typeProvider.iterableType2(
t.instantiate(nullabilitySuffix: suffix),
),
);
class_.enclosingElement = ElementFactory.compilationUnit('test.dart');
var decoratedSupertypes = decorator.getImmediateSupertypes(class_).toList();
expect(decoratedSupertypes, hasLength(1));
checkIterable(
decoratedSupertypes[0],
checkExplicitlyNonNullable,
(type, displayName) => checkTypeParameter(
type, checkExplicitlyNonNullable, t, displayName),
'C (test.dart:1:1)');
}
void test_getImmediateSupertypes_interface() {
var class_ =
element = ElementFactory.classElement('C', typeProvider.objectType);
class_.interfaces = [typeProvider.numType];
class_.enclosingElement = ElementFactory.compilationUnit('test.dart');
var decoratedSupertypes = decorator.getImmediateSupertypes(class_).toList();
expect(decoratedSupertypes, hasLength(2));
checkObject(decoratedSupertypes[0], checkExplicitlyNonNullable,
'C (test.dart:1:1)');
checkNum(decoratedSupertypes[1], checkExplicitlyNonNullable,
'C (test.dart:1:1)');
}
void test_getImmediateSupertypes_mixin() {
var class_ =
element = ElementFactory.classElement('C', typeProvider.objectType);
class_.mixins = [typeProvider.numType];
class_.enclosingElement = ElementFactory.compilationUnit('test.dart');
var decoratedSupertypes = decorator.getImmediateSupertypes(class_).toList();
expect(decoratedSupertypes, hasLength(2));
checkObject(decoratedSupertypes[0], checkExplicitlyNonNullable,
'C (test.dart:1:1)');
checkNum(decoratedSupertypes[1], checkExplicitlyNonNullable,
'C (test.dart:1:1)');
}
void test_getImmediateSupertypes_superclassConstraint() {
var class_ = element = ElementFactory.mixinElement(
name: 'C', constraints: [typeProvider.numType]);
class_.enclosingElement = ElementFactory.compilationUnit('test.dart');
var decoratedSupertypes = decorator.getImmediateSupertypes(class_).toList();
expect(decoratedSupertypes, hasLength(1));
checkNum(decoratedSupertypes[0], checkExplicitlyNonNullable,
'C (test.dart:1:1)');
}
void test_getImmediateSupertypes_supertype() {
var class_ =
element = ElementFactory.classElement('C', typeProvider.objectType);
class_.enclosingElement = ElementFactory.compilationUnit('test.dart');
var decoratedSupertypes = decorator.getImmediateSupertypes(class_).toList();
expect(decoratedSupertypes, hasLength(1));
// TODO(paulberry): displayName should be 'Object supertype of C'
checkObject(decoratedSupertypes[0], checkExplicitlyNonNullable,
'C (test.dart:1:1)');
}
static LineInfo _getLineInfo(String path) => LineInfo([0]);
}
/// Specialization of [_AlreadyMigratedCodeDecoratorTestBase] for testing the
/// situation where the already migrated code does not contain star types. In
/// the final product, by definition all already-migrated code will be free of
/// star types. However, since we do not yet migrate using a fully NNBD-aware
/// SDK, we need to handle both star and non-star variants on a short term
/// basis.
@reflectiveTest
class _AlreadyMigratedCodeDecoratorTestNormal
extends _AlreadyMigratedCodeDecoratorTestBase {
_AlreadyMigratedCodeDecoratorTestNormal() : super(NullabilitySuffix.none);
}
/// Specialization of [_AlreadyMigratedCodeDecoratorTestBase] for testing the
/// situation where the already migrated code contains star types. In the final
/// product, this will never happen. However, since we do not yet migrate using
/// a fully NNBD-aware SDK, we need to handle both star and non-star variants on
/// a short term basis.
@reflectiveTest
class _AlreadyMigratedCodeDecoratorTestProvisional
extends _AlreadyMigratedCodeDecoratorTestBase {
_AlreadyMigratedCodeDecoratorTestProvisional()
: super(NullabilitySuffix.star);
}
class _MockElement implements Element {
noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}