| // 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. |
| |
| import 'package:kernel/ast.dart'; |
| |
| import 'package:front_end/src/fasta/kernel/type_labeler.dart'; |
| |
| import 'package:expect/expect.dart'; |
| |
| main() { |
| void check(Map<Node, String> expectations, int bulletCount) { |
| TypeLabeler labeler = new TypeLabeler(); |
| 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 { |
| Expect.fail("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 |
| Library dartCoreLib = new Library(new Uri(scheme: 'dart', path: 'core')); |
| Library myLib = new Library(Uri.parse("org-dartlang-testcase:///mylib.dart")); |
| |
| // Set up some classes |
| Class objectClass = new Class(name: "Object")..parent = dartCoreLib; |
| Supertype objectSuper = new Supertype(objectClass, []); |
| Class boolClass = new Class(name: "bool", supertype: objectSuper) |
| ..parent = dartCoreLib; |
| Class numClass = new Class(name: "num", supertype: objectSuper) |
| ..parent = dartCoreLib; |
| Supertype numSuper = new Supertype(numClass, []); |
| Class intClass = new Class(name: "int", supertype: numSuper) |
| ..parent = dartCoreLib; |
| Class fooClass = new Class(name: "Foo", supertype: objectSuper) |
| ..parent = myLib; |
| Class foo2Class = new Class(name: "Foo", supertype: objectSuper) |
| ..parent = myLib; |
| Class barClass = new Class( |
| name: "Bar", |
| supertype: objectSuper, |
| typeParameters: [new TypeParameter("X")]) |
| ..parent = myLib; |
| Class bazClass = new Class( |
| name: "Baz", |
| supertype: objectSuper, |
| typeParameters: [new TypeParameter("X"), new TypeParameter("Y")]) |
| ..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); |
| check({boolType: "bool"}, 0); |
| |
| DartType numType = new InterfaceType(numClass); |
| check({numType: "num"}, 0); |
| |
| DartType intType = new InterfaceType(intClass); |
| check({intType: "int"}, 0); |
| |
| DartType object = new InterfaceType(objectClass); |
| check({object: "Object"}, 1); |
| |
| DartType foo = new InterfaceType(fooClass); |
| check({foo: "Foo"}, 1); |
| |
| DartType foo2 = new InterfaceType(foo2Class); |
| check({foo2: "Foo"}, 1); |
| check({foo: "Foo/*1*/", foo2: "Foo/*2*/"}, 2); |
| |
| DartType barVoid = new InterfaceType(barClass, [voidType]); |
| check({barVoid: "Bar<void>"}, 1); |
| |
| DartType barObject = new InterfaceType(barClass, [object]); |
| check({barObject: "Bar<Object>"}, 2); |
| |
| DartType barBarDynamic = new InterfaceType(barClass, [ |
| new InterfaceType(barClass, [dynamicType]) |
| ]); |
| check({barBarDynamic: "Bar<Bar<dynamic>>"}, 1); |
| |
| DartType parameterY = new TypeParameterType(new TypeParameter("Y")); |
| DartType barY = new InterfaceType(barClass, [parameterY]); |
| check({parameterY: "Y", barY: "Bar<Y>"}, 1); |
| |
| DartType bazFooBarBazDynamicVoid = new InterfaceType(bazClass, [ |
| foo, |
| new InterfaceType(barClass, [ |
| new InterfaceType(bazClass, [dynamicType, voidType]) |
| ]) |
| ]); |
| check({bazFooBarBazDynamicVoid: "Baz<Foo, Bar<Baz<dynamic, void>>>"}, 3); |
| |
| DartType bazFooFoo2 = new InterfaceType(bazClass, [foo, foo2]); |
| check({bazFooFoo2: "Baz<Foo/*1*/, Foo/*2*/>"}, 3); |
| |
| DartType funVoid = new FunctionType([], voidType); |
| check({funVoid: "void Function()"}, 0); |
| |
| DartType funFooBarVoid = new FunctionType([foo], barVoid); |
| check({funFooBarVoid: "Bar<void> Function(Foo)"}, 2); |
| |
| DartType funFooFoo2 = new FunctionType([foo], foo2); |
| check({funFooFoo2: "Foo/*1*/ Function(Foo/*2*/)"}, 2); |
| |
| DartType funOptFooVoid = |
| new FunctionType([foo], voidType, requiredParameterCount: 0); |
| check({funOptFooVoid: "void Function([Foo])"}, 1); |
| |
| DartType funFooOptIntVoid = |
| new FunctionType([foo, intType], voidType, requiredParameterCount: 1); |
| check({funFooOptIntVoid: "void Function(Foo, [int])"}, 1); |
| |
| DartType funOptFooOptIntVoid = |
| new FunctionType([foo, intType], voidType, requiredParameterCount: 0); |
| check({funOptFooOptIntVoid: "void Function([Foo, int])"}, 1); |
| |
| DartType funNamedObjectVoid = new FunctionType([], voidType, |
| namedParameters: [new NamedType("obj", object)]); |
| check({funNamedObjectVoid: "void Function({Object obj})"}, 1); |
| |
| DartType funFooNamedObjectVoid = new FunctionType([foo], voidType, |
| 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)], new TypeParameterType(t), |
| typeParameters: [t]); |
| check({funGeneric: "T Function<T>(T)"}, 0); |
| |
| TypeParameter tObject = new TypeParameter("T", object, object); |
| DartType funGenericObject = new FunctionType( |
| [new TypeParameterType(tObject)], new TypeParameterType(tObject), |
| 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)], new TypeParameterType(tFoo), |
| typeParameters: [tFoo]); |
| check({funGenericFoo: "T Function<T extends Foo>(T)"}, 1); |
| |
| TypeParameter tBar = new TypeParameter("T", dynamicType, dynamicType); |
| tBar.bound = new InterfaceType(barClass, [new TypeParameterType(tBar)]); |
| DartType funGenericBar = new FunctionType( |
| [new TypeParameterType(tBar)], new TypeParameterType(tBar), |
| typeParameters: [tBar]); |
| check({funGenericBar: "T Function<T extends Bar<T>>(T)"}, 1); |
| |
| // Add some members for testing instance constants |
| Field booField = new Field(new Name("boo"), type: boolType); |
| fooClass.fields.add(booField); |
| Field valueField = new Field(new Name("value"), type: intType); |
| foo2Class.fields.add(valueField); |
| Field nextField = new Field(new Name("next"), type: foo2); |
| foo2Class.fields.add(nextField); |
| Field xField = new Field(new Name("x"), |
| type: new TypeParameterType(bazClass.typeParameters[0])); |
| bazClass.fields.add(xField); |
| Field yField = new Field(new Name("y"), |
| type: new TypeParameterType(bazClass.typeParameters[1])); |
| bazClass.fields.add(yField); |
| FunctionNode gooFunction = new FunctionNode(new EmptyStatement(), |
| typeParameters: [new TypeParameter("V")]); |
| Procedure gooMethod = new Procedure( |
| new Name("goo"), ProcedureKind.Method, gooFunction, |
| isStatic: true) |
| ..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.reference: trueConst}); |
| check({fooConst: "Foo {boo: true}"}, 1); |
| |
| Constant foo2Const = new InstanceConstant(foo2Class.reference, [], |
| {nextField.reference: nullConst, valueField.reference: intConst}); |
| check({foo2Const: "Foo {value: 2, next: null}"}, 1); |
| |
| Constant foo2nConst = new InstanceConstant(foo2Class.reference, [], { |
| valueField.reference: intConst, |
| nextField.reference: new InstanceConstant(foo2Class.reference, [], |
| {valueField.reference: intConst, nextField.reference: nullConst}), |
| }); |
| check({foo2nConst: "Foo {value: 2, next: Foo {value: 2, next: null}}"}, 1); |
| |
| Constant bazFooFoo2Const = new InstanceConstant(bazClass.reference, |
| [foo, foo2], {xField.reference: fooConst, yField.reference: foo2Const}); |
| check({ |
| 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 TearOffConstant(gooMethod); |
| check({tearOffConst: "Foo.goo"}, 1); |
| |
| Constant partialInstantiationConst = |
| new PartialInstantiationConstant(tearOffConst, [intType]); |
| check({partialInstantiationConst: "Foo.goo<int>"}, 1); |
| |
| Constant typeLiteralConst = new TypeLiteralConstant(foo); |
| check({typeLiteralConst: "Foo"}, 1); |
| } |