pkg/front_end/test/type_labeler_test.dart - sdk.git - Git at Google

 // 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';

 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 {
         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
   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, [
     foo,
     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),
       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),
       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),
       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),
       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);
   fooClass.fields.add(booField);
   Field valueField = new Field.immutable(new Name("value"),
       type: intType, fileUri: foo2Class.fileUri);
   foo2Class.fields.add(valueField);
   Field nextField = new Field.immutable(new Name("next"),
       type: foo2, fileUri: foo2Class.fileUri);
   foo2Class.fields.add(nextField);
   Field xField = new Field.immutable(new Name("x"),
       type:
           new TypeParameterType(bazClass.typeParameters[0], Nullability.legacy),
       fileUri: bazClass.fileUri);
   bazClass.fields.add(xField);
   Field yField = new Field.immutable(new Name("y"),
       type:
           new TypeParameterType(bazClass.typeParameters[1], Nullability.legacy),
       fileUri: bazClass.fileUri);
   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, 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.fieldReference: trueConst});
   check({fooConst: "Foo {boo: true}"}, 1);

   Constant foo2Const = new InstanceConstant(foo2Class.reference, [], {
     nextField.fieldReference: nullConst,
     valueField.fieldReference: intConst
   });
   check({foo2Const: "Foo {value: 2, next: null}"}, 1);

   Constant foo2nConst = new InstanceConstant(foo2Class.reference, [], {
     valueField.fieldReference: intConst,
     nextField.fieldReference: new InstanceConstant(foo2Class.reference, [], {
       valueField.fieldReference: intConst,
       nextField.fieldReference: nullConst
     }),
   });
   check({foo2nConst: "Foo {value: 2, next: Foo {value: 2, next: null}}"}, 1);

   Constant bazFooFoo2Const = new InstanceConstant(
       bazClass.reference,
       [foo, foo2],
       {xField.fieldReference: fooConst, yField.fieldReference: 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 StaticTearOffConstant(gooMethod);
   check({tearOffConst: "Foo.goo"}, 1);

   Constant partialInstantiationConst =
       new InstantiationConstant(tearOffConst, [intType]);
   check({partialInstantiationConst: "Foo.goo<int>"}, 1);

   Constant typeLiteralConst = new TypeLiteralConstant(foo);
   check({typeLiteralConst: "Foo"}, 1);
 }
	// 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';

	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 {
	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
	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, [
	foo,
	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),
	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),
	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),
	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),
	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);
	fooClass.fields.add(booField);
	Field valueField = new Field.immutable(new Name("value"),
	type: intType, fileUri: foo2Class.fileUri);
	foo2Class.fields.add(valueField);
	Field nextField = new Field.immutable(new Name("next"),
	type: foo2, fileUri: foo2Class.fileUri);
	foo2Class.fields.add(nextField);
	Field xField = new Field.immutable(new Name("x"),
	type:
	new TypeParameterType(bazClass.typeParameters[0], Nullability.legacy),
	fileUri: bazClass.fileUri);
	bazClass.fields.add(xField);
	Field yField = new Field.immutable(new Name("y"),
	type:
	new TypeParameterType(bazClass.typeParameters[1], Nullability.legacy),
	fileUri: bazClass.fileUri);
	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, 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.fieldReference: trueConst});
	check({fooConst: "Foo {boo: true}"}, 1);

	Constant foo2Const = new InstanceConstant(foo2Class.reference, [], {
	nextField.fieldReference: nullConst,
	valueField.fieldReference: intConst
	});
	check({foo2Const: "Foo {value: 2, next: null}"}, 1);

	Constant foo2nConst = new InstanceConstant(foo2Class.reference, [], {
	valueField.fieldReference: intConst,
	nextField.fieldReference: new InstanceConstant(foo2Class.reference, [], {
	valueField.fieldReference: intConst,
	nextField.fieldReference: nullConst
	}),
	});
	check({foo2nConst: "Foo {value: 2, next: Foo {value: 2, next: null}}"}, 1);

	Constant bazFooFoo2Const = new InstanceConstant(
	bazClass.reference,
	[foo, foo2],
	{xField.fieldReference: fooConst, yField.fieldReference: 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 StaticTearOffConstant(gooMethod);
	check({tearOffConst: "Foo.goo"}, 1);

	Constant partialInstantiationConst =
	new InstantiationConstant(tearOffConst, [intType]);
	check({partialInstantiationConst: "Foo.goo<int>"}, 1);

	Constant typeLiteralConst = new TypeLiteralConstant(foo);
	check({typeLiteralConst: "Foo"}, 1);
	}