blob: 8681a9fe33f74bab5b845f96997621a66e87c793 [file] [log] [blame]
// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// @dart = 2.9
import 'package:kernel/ast.dart';
import 'package:front_end/src/fasta/kernel/type_labeler.dart';
import 'package:expect/expect.dart';
void main() {
void check(Map<Node, String> expectations, int bulletCount) {
TypeLabeler labeler = new TypeLabeler(false);
Map<Node, List<Object>> conversions = {};
expectations.forEach((Node node, String expected) {
if (node is DartType) {
conversions[node] = labeler.labelType(node);
} else if (node is Constant) {
conversions[node] = labeler.labelConstant(node);
} else {"Neither type nor constant");
expectations.forEach((Node node, String expected) {
Expect.stringEquals(expected, conversions[node].join());
int newlines = "\n".allMatches(labeler.originMessages).length;
Expect.equals(bulletCount, newlines);
// Library mocks
Uri dartCoreUri = new Uri(scheme: 'dart', path: 'core');
Library dartCoreLib = new Library(dartCoreUri, fileUri: dartCoreUri);
Uri myUri = Uri.parse("org-dartlang-testcase:///mylib.dart");
Library myLib = new Library(myUri, fileUri: myUri);
// Set up some classes
Class objectClass = new Class(name: "Object", fileUri: dartCoreUri)
..parent = dartCoreLib;
Supertype objectSuper = new Supertype(objectClass, []);
Class boolClass =
new Class(name: "bool", supertype: objectSuper, fileUri: dartCoreUri)
..parent = dartCoreLib;
Class numClass =
new Class(name: "num", supertype: objectSuper, fileUri: dartCoreUri)
..parent = dartCoreLib;
Supertype numSuper = new Supertype(numClass, []);
Class intClass =
new Class(name: "int", supertype: numSuper, fileUri: dartCoreUri)
..parent = dartCoreLib;
Class fooClass =
new Class(name: "Foo", supertype: objectSuper, fileUri: myUri)
..parent = myLib;
Class foo2Class =
new Class(name: "Foo", supertype: objectSuper, fileUri: myUri)
..parent = myLib;
Class barClass = new Class(
name: "Bar",
supertype: objectSuper,
typeParameters: [new TypeParameter("X")],
fileUri: myUri)
..parent = myLib;
Class bazClass = new Class(
name: "Baz",
supertype: objectSuper,
typeParameters: [new TypeParameter("X"), new TypeParameter("Y")],
fileUri: myUri)
..parent = myLib;
// Test types
DartType voidType = const VoidType();
check({voidType: "void"}, 0);
DartType dynamicType = const DynamicType();
check({dynamicType: "dynamic"}, 0);
DartType boolType = new InterfaceType(boolClass, Nullability.legacy);
check({boolType: "bool"}, 0);
DartType numType = new InterfaceType(numClass, Nullability.legacy);
check({numType: "num"}, 0);
DartType intType = new InterfaceType(intClass, Nullability.legacy);
check({intType: "int"}, 0);
DartType object = new InterfaceType(objectClass, Nullability.legacy);
check({object: "Object"}, 1);
DartType foo = new InterfaceType(fooClass, Nullability.legacy);
check({foo: "Foo"}, 1);
DartType foo2 = new InterfaceType(foo2Class, Nullability.legacy);
check({foo2: "Foo"}, 1);
check({foo: "Foo/*1*/", foo2: "Foo/*2*/"}, 2);
DartType barVoid =
new InterfaceType(barClass, Nullability.legacy, [voidType]);
check({barVoid: "Bar<void>"}, 1);
DartType barObject =
new InterfaceType(barClass, Nullability.legacy, [object]);
check({barObject: "Bar<Object>"}, 2);
DartType barBarDynamic = new InterfaceType(barClass, Nullability.legacy, [
new InterfaceType(barClass, Nullability.legacy, [dynamicType])
check({barBarDynamic: "Bar<Bar<dynamic>>"}, 1);
DartType parameterY =
new TypeParameterType(new TypeParameter("Y"), Nullability.legacy);
DartType barY = new InterfaceType(barClass, Nullability.legacy, [parameterY]);
check({parameterY: "Y", barY: "Bar<Y>"}, 1);
DartType bazFooBarBazDynamicVoid =
new InterfaceType(bazClass, Nullability.legacy, [
new InterfaceType(barClass, Nullability.legacy, [
new InterfaceType(bazClass, Nullability.legacy, [dynamicType, voidType])
check({bazFooBarBazDynamicVoid: "Baz<Foo, Bar<Baz<dynamic, void>>>"}, 3);
DartType bazFooFoo2 =
new InterfaceType(bazClass, Nullability.legacy, [foo, foo2]);
check({bazFooFoo2: "Baz<Foo/*1*/, Foo/*2*/>"}, 3);
DartType funVoid = new FunctionType([], voidType, Nullability.legacy);
check({funVoid: "void Function()"}, 0);
DartType funFooBarVoid = new FunctionType([foo], barVoid, Nullability.legacy);
check({funFooBarVoid: "Bar<void> Function(Foo)"}, 2);
DartType funFooFoo2 = new FunctionType([foo], foo2, Nullability.legacy);
check({funFooFoo2: "Foo/*1*/ Function(Foo/*2*/)"}, 2);
DartType funOptFooVoid = new FunctionType([foo], voidType, Nullability.legacy,
requiredParameterCount: 0);
check({funOptFooVoid: "void Function([Foo])"}, 1);
DartType funFooOptIntVoid = new FunctionType(
[foo, intType], voidType, Nullability.legacy,
requiredParameterCount: 1);
check({funFooOptIntVoid: "void Function(Foo, [int])"}, 1);
DartType funOptFooOptIntVoid = new FunctionType(
[foo, intType], voidType, Nullability.legacy,
requiredParameterCount: 0);
check({funOptFooOptIntVoid: "void Function([Foo, int])"}, 1);
DartType funNamedObjectVoid = new FunctionType(
[], voidType, Nullability.legacy,
namedParameters: [new NamedType("obj", object)]);
check({funNamedObjectVoid: "void Function({Object obj})"}, 1);
DartType funFooNamedObjectVoid = new FunctionType(
[foo], voidType, Nullability.legacy,
namedParameters: [new NamedType("obj", object)]);
check({funFooNamedObjectVoid: "void Function(Foo, {Object obj})"}, 2);
TypeParameter t = new TypeParameter("T", object, dynamicType);
DartType funGeneric = new FunctionType(
[new TypeParameterType(t, Nullability.legacy)],
new TypeParameterType(t, Nullability.legacy),
typeParameters: [t]);
check({funGeneric: "T Function<T>(T)"}, 0);
TypeParameter tObject = new TypeParameter("T", object, object);
DartType funGenericObject = new FunctionType(
[new TypeParameterType(tObject, Nullability.legacy)],
new TypeParameterType(tObject, Nullability.legacy),
typeParameters: [tObject]);
check({funGenericObject: "T Function<T extends Object>(T)"}, 1);
TypeParameter tFoo = new TypeParameter("T", foo, dynamicType);
DartType funGenericFoo = new FunctionType(
[new TypeParameterType(tFoo, Nullability.legacy)],
new TypeParameterType(tFoo, Nullability.legacy),
typeParameters: [tFoo]);
check({funGenericFoo: "T Function<T extends Foo>(T)"}, 1);
TypeParameter tBar = new TypeParameter("T", dynamicType, dynamicType);
tBar.bound = new InterfaceType(barClass, Nullability.legacy,
[new TypeParameterType(tBar, Nullability.legacy)]);
DartType funGenericBar = new FunctionType(
[new TypeParameterType(tBar, Nullability.legacy)],
new TypeParameterType(tBar, Nullability.legacy),
typeParameters: [tBar]);
check({funGenericBar: "T Function<T extends Bar<T>>(T)"}, 1);
// Add some members for testing instance constants
Field booField = new Field.immutable(new Name("boo"),
type: boolType, fileUri: fooClass.fileUri);
Field valueField = new Field.immutable(new Name("value"),
type: intType, fileUri: foo2Class.fileUri);
Field nextField = new Field.immutable(new Name("next"),
type: foo2, fileUri: foo2Class.fileUri);
Field xField = new Field.immutable(new Name("x"),
new TypeParameterType(bazClass.typeParameters[0], Nullability.legacy),
fileUri: bazClass.fileUri);
Field yField = new Field.immutable(new Name("y"),
new TypeParameterType(bazClass.typeParameters[1], Nullability.legacy),
fileUri: bazClass.fileUri);
FunctionNode gooFunction = new FunctionNode(new EmptyStatement(),
typeParameters: [new TypeParameter("V")]);
Procedure gooMethod = new Procedure(
new Name("goo"), ProcedureKind.Method, gooFunction,
isStatic: true, fileUri: fooClass.fileUri)
..parent = fooClass;
// Test constants
Constant nullConst = new NullConstant();
check({nullConst: "null"}, 0);
Constant trueConst = new BoolConstant(true);
Constant falseConst = new BoolConstant(false);
check({trueConst: "true", falseConst: "false"}, 0);
Constant intConst = new IntConstant(2);
Constant doubleConst = new DoubleConstant(2.5);
check({intConst: "2", doubleConst: "2.5"}, 0);
Constant stringConst = new StringConstant("Don't \"quote\" me on that!");
check({stringConst: "\"Don't \\\"quote\\\" me on that!\""}, 0);
Constant symConst = new SymbolConstant("foo", null);
Constant symLibConst = new SymbolConstant("bar", dartCoreLib.reference);
check({symConst: "#foo", symLibConst: "#dart:core::bar"}, 0);
Constant fooConst = new InstanceConstant(
fooClass.reference, [], {booField.getterReference: trueConst});
check({fooConst: "Foo {boo: true}"}, 1);
Constant foo2Const = new InstanceConstant(foo2Class.reference, [], {
nextField.getterReference: nullConst,
valueField.getterReference: intConst
check({foo2Const: "Foo {value: 2, next: null}"}, 1);
Constant foo2nConst = new InstanceConstant(foo2Class.reference, [], {
valueField.getterReference: intConst,
nextField.getterReference: new InstanceConstant(foo2Class.reference, [], {
valueField.getterReference: intConst,
nextField.getterReference: nullConst
check({foo2nConst: "Foo {value: 2, next: Foo {value: 2, next: null}}"}, 1);
Constant bazFooFoo2Const = new InstanceConstant(
[foo, foo2],
{xField.getterReference: fooConst, yField.getterReference: foo2Const});
bazFooFoo2Const: "Baz<Foo/*1*/, Foo/*2*/> "
"{x: Foo/*1*/ {boo: true}, y: Foo/*2*/ {value: 2, next: null}}"
}, 3);
Constant listConst = new ListConstant(dynamicType, [intConst, doubleConst]);
check({listConst: "<dynamic>[2, 2.5]"}, 0);
Constant listBoolConst = new ListConstant(boolType, [falseConst, trueConst]);
check({listBoolConst: "<bool>[false, true]"}, 0);
Constant setConst = new SetConstant(dynamicType, [intConst, doubleConst]);
check({setConst: "<dynamic>{2, 2.5}"}, 0);
Constant setBoolConst = new SetConstant(boolType, [falseConst, trueConst]);
check({setBoolConst: "<bool>{false, true}"}, 0);
Constant mapConst = new MapConstant(boolType, numType, [
new ConstantMapEntry(trueConst, intConst),
new ConstantMapEntry(falseConst, doubleConst)
check({mapConst: "<bool, num>{true: 2, false: 2.5}"}, 0);
Constant tearOffConst = new StaticTearOffConstant(gooMethod);
check({tearOffConst: ""}, 1);
Constant partialInstantiationConst =
new InstantiationConstant(tearOffConst, [intType]);
check({partialInstantiationConst: "<int>"}, 1);
Constant typeLiteralConst = new TypeLiteralConstant(foo);
check({typeLiteralConst: "Foo"}, 1);