// Copyright (c) 2015, 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.

library dart2js.constants.expressions.evaluate_test;

import 'dart:async';
import 'package:async_helper/async_helper.dart';
import 'package:expect/expect.dart';
import 'package:compiler/src/common.dart';
import 'package:compiler/src/common_elements.dart';
import 'package:compiler/src/compiler.dart';
import 'package:compiler/src/constants/constructors.dart';
import 'package:compiler/src/constants/evaluation.dart';
import 'package:compiler/src/constants/expressions.dart';
import 'package:compiler/src/constants/values.dart';
import 'package:compiler/src/constant_system_dart.dart';
import 'package:compiler/src/diagnostics/messages.dart';
import 'package:compiler/src/elements/entities.dart';
import 'package:compiler/src/elements/types.dart';
import 'package:compiler/src/kernel/kernel_strategy.dart';
import 'package:compiler/src/kernel/element_map_impl.dart';
import '../helpers/memory_compiler.dart';

class TestData {
  final String name;

  /// Declarations needed for the [constants].
  final String declarations;

  /// Tested constants.
  final List<ConstantData> constants;

  const TestData(this.name, this.declarations, this.constants);
}

class ConstantData {
  /// Source code for the constant expression.
  final String code;

  /// Constant value as structured text for the empty environment or a map from
  /// environment to either the expected constant value as structured text or
  /// a [ConstantResult].
  final expectedResults;

  /// A [MessageKind] or a list of [MessageKind]s containing the error messages
  /// expected as the result of evaluating the constant under the empty
  /// environment.
  final expectedErrors;

  const ConstantData(this.code, this.expectedResults, {this.expectedErrors});
}

class EvaluationError {
  final MessageKind kind;
  final Map arguments;

  EvaluationError(this.kind, this.arguments);
}

class MemoryEnvironment implements EvaluationEnvironment {
  final EvaluationEnvironment _environment;
  final Map<String, String> env;
  final List<EvaluationError> errors = <EvaluationError>[];

  MemoryEnvironment(this._environment, [this.env = const <String, String>{}]);

  @override
  String readFromEnvironment(String name) => env[name];

  @override
  InterfaceType substByContext(InterfaceType base, InterfaceType target) {
    return _environment.substByContext(base, target);
  }

  @override
  DartType getTypeInContext(DartType type) =>
      _environment.getTypeInContext(type);

  @override
  ConstantConstructor getConstructorConstant(ConstructorEntity constructor) {
    return _environment.getConstructorConstant(constructor);
  }

  @override
  ConstantExpression getFieldConstant(FieldEntity field) {
    return _environment.getFieldConstant(field);
  }

  @override
  ConstantExpression getLocalConstant(Local local) {
    return _environment.getLocalConstant(local);
  }

  @override
  CommonElements get commonElements => _environment.commonElements;

  @override
  DartTypes get types => _environment.types;

  @override
  InterfaceType get enclosingConstructedType =>
      _environment.enclosingConstructedType;

  @override
  void reportWarning(
      ConstantExpression expression, MessageKind kind, Map arguments) {
    errors.add(new EvaluationError(kind, arguments));
    _environment.reportWarning(expression, kind, arguments);
  }

  @override
  void reportError(
      ConstantExpression expression, MessageKind kind, Map arguments) {
    errors.add(new EvaluationError(kind, arguments));
    _environment.reportError(expression, kind, arguments);
  }

  @override
  ConstantValue evaluateConstructor(ConstructorEntity constructor,
      InterfaceType type, ConstantValue evaluate()) {
    return _environment.evaluateConstructor(constructor, type, evaluate);
  }

  @override
  ConstantValue evaluateField(FieldEntity field, ConstantValue evaluate()) {
    return _environment.evaluateField(field, evaluate);
  }

  @override
  bool get enableAssertions => true;
}

const List<TestData> DATA = const [
  const TestData('simple', '', const [
    const ConstantData('null', 'NullConstant'),
    const ConstantData('false', 'BoolConstant(false)'),
    const ConstantData('true', 'BoolConstant(true)'),
    const ConstantData('0', 'IntConstant(0)'),
    const ConstantData('0.0', 'DoubleConstant(0.0)'),
    const ConstantData('"foo"', 'StringConstant("foo")'),
    const ConstantData('1 + 2', 'IntConstant(3)'),
    const ConstantData('-(1)', 'IntConstant(-1)'),
    const ConstantData('1 == 2', 'BoolConstant(false)'),
    const ConstantData('1 != 2', 'BoolConstant(true)'),
    const ConstantData('1 / 0', 'DoubleConstant(Infinity)'),
    const ConstantData('0 / 0', 'DoubleConstant(NaN)'),
    const ConstantData('1 << 0', 'IntConstant(1)'),
    const ConstantData('1 >> 0', 'IntConstant(1)'),
    const ConstantData('"foo".length', 'IntConstant(3)'),
    const ConstantData('identical(0, 1)', 'BoolConstant(false)'),
    const ConstantData('"a" "b"', 'StringConstant("ab")'),
    const ConstantData(r'"${null}"', 'StringConstant("null")'),
    const ConstantData('identical', 'FunctionConstant(identical)'),
    const ConstantData('true ? 0 : 1', 'IntConstant(0)'),
    const ConstantData('proxy', 'ConstructedConstant(_Proxy())'),
    const ConstantData('const [] == null', 'BoolConstant(false)'),
    const ConstantData('proxy == null', 'BoolConstant(false)'),
    const ConstantData('Object', 'TypeConstant(Object)'),
    const ConstantData('null ?? 0', 'IntConstant(0)'),
    const ConstantData(
        'const [0, 1]', 'ListConstant(<int>[IntConstant(0), IntConstant(1)])'),
    const ConstantData('const <int>[0, 1]',
        'ListConstant(<int>[IntConstant(0), IntConstant(1)])'),
    const ConstantData(
        'const {0: 1, 2: 3}',
        'MapConstant(<int, int>{IntConstant(0): IntConstant(1), '
        'IntConstant(2): IntConstant(3)})'),
    const ConstantData(
        'const <int, int>{0: 1, 2: 3}',
        'MapConstant(<int, int>{IntConstant(0): IntConstant(1), '
        'IntConstant(2): IntConstant(3)})'),
    const ConstantData('const <int, int>{0: 1, 0: 2}',
        'MapConstant(<int, int>{IntConstant(0): IntConstant(2)})',
        expectedErrors: MessageKind.EQUAL_MAP_ENTRY_KEY),
    const ConstantData(
        'const bool.fromEnvironment("foo", defaultValue: false)',
        const <Map<String, String>, String>{
          const {}: 'BoolConstant(false)',
          const {'foo': 'true'}: 'BoolConstant(true)'
        }),
    const ConstantData(
        'const int.fromEnvironment("foo", defaultValue: 42)',
        const <Map<String, String>, String>{
          const {}: 'IntConstant(42)',
          const {'foo': '87'}: 'IntConstant(87)'
        }),
    const ConstantData(
        'const String.fromEnvironment("foo", defaultValue: "bar")',
        const <Map<String, String>, String>{
          const {}: 'StringConstant("bar")',
          const {'foo': 'foo'}: 'StringConstant("foo")'
        }),
  ]),
  const TestData('env', '''
const a = const bool.fromEnvironment("foo", defaultValue: true);
const b = const int.fromEnvironment("bar", defaultValue: 42);

class A {
  const A();
}
class B {
  final field1;
  const B(this.field1);
}
class C extends B {
  final field2;
  const C({field1: 42, this.field2: false}) : super(field1);
  const C.named([field = false]) : this(field1: field, field2: field);
}
class D extends C {
  final field3 = 99;
  const D(a, b) : super(field2: a, field1: b);
}
''', const [
    const ConstantData('const Object()', 'ConstructedConstant(Object())'),
    const ConstantData('const A()', 'ConstructedConstant(A())'),
    const ConstantData(
        'const B(0)', 'ConstructedConstant(B(field1=IntConstant(0)))'),
    const ConstantData('const B(const A())',
        'ConstructedConstant(B(field1=ConstructedConstant(A())))'),
    const ConstantData(
        'const C()',
        'ConstructedConstant(C(field1=IntConstant(42),'
        'field2=BoolConstant(false)))'),
    const ConstantData(
        'const C(field1: 87)',
        'ConstructedConstant(C(field1=IntConstant(87),'
        'field2=BoolConstant(false)))'),
    const ConstantData(
        'const C(field2: true)',
        'ConstructedConstant(C(field1=IntConstant(42),'
        'field2=BoolConstant(true)))'),
    const ConstantData(
        'const C.named()',
        'ConstructedConstant(C(field1=BoolConstant(false),'
        'field2=BoolConstant(false)))'),
    const ConstantData(
        'const C.named(87)',
        'ConstructedConstant(C(field1=IntConstant(87),'
        'field2=IntConstant(87)))'),
    const ConstantData(
        'const C(field1: a, field2: b)', const <Map<String, String>, String>{
      const {}: 'ConstructedConstant(C(field1=BoolConstant(true),'
          'field2=IntConstant(42)))',
      const {'foo': 'false', 'bar': '87'}:
          'ConstructedConstant(C(field1=BoolConstant(false),'
          'field2=IntConstant(87)))',
    }),
    const ConstantData(
        'const D(42, 87)',
        'ConstructedConstant(D(field1=IntConstant(87),'
        'field2=IntConstant(42),'
        'field3=IntConstant(99)))'),
  ]),
  const TestData('redirect', '''
class A<T> implements B<Null> {
  final field1;
  const A({this.field1:42});
}
class B<S> implements C<Null> {
  const factory B({field1}) = A<B<S>>;
  const factory B.named() = A<S>;
}
class C<U> {
  const factory C({field1}) = A<B<double>>;
}
''', const [
    const ConstantData(
        'const A()', 'ConstructedConstant(A<dynamic>(field1=IntConstant(42)))'),
    const ConstantData('const A<int>(field1: 87)',
        'ConstructedConstant(A<int>(field1=IntConstant(87)))'),
    const ConstantData('const B()',
        'ConstructedConstant(A<B<dynamic>>(field1=IntConstant(42)))'),
    const ConstantData('const B<int>()',
        'ConstructedConstant(A<B<int>>(field1=IntConstant(42)))'),
    const ConstantData('const B<int>(field1: 87)',
        'ConstructedConstant(A<B<int>>(field1=IntConstant(87)))'),
    const ConstantData('const C<int>(field1: 87)',
        'ConstructedConstant(A<B<double>>(field1=IntConstant(87)))'),
    const ConstantData('const B<int>.named()',
        'ConstructedConstant(A<int>(field1=IntConstant(42)))'),
  ]),
  const TestData('env2', '''
const c = const int.fromEnvironment("foo", defaultValue: 5);
const d = const int.fromEnvironment("bar", defaultValue: 10);

class A {
  final field;
  const A(a, b) : field = a + b;
}

class B extends A {
  const B(a) : super(a, a * 2);
}
''', const [
    const ConstantData('const A(c, d)', const <Map<String, String>, String>{
      const {}: 'ConstructedConstant(A(field=IntConstant(15)))',
      const {'foo': '7', 'bar': '11'}:
          'ConstructedConstant(A(field=IntConstant(18)))',
    }),
    const ConstantData('const B(d)', const <Map<String, String>, String>{
      const {}: 'ConstructedConstant(B(field=IntConstant(30)))',
      const {'bar': '42'}: 'ConstructedConstant(B(field=IntConstant(126)))',
    }),
  ]),
  const TestData('construct', '''
 class A {
   final x;
   final y;
   final z;
   final t;
   final u = 42;
   const A(this.z, tt) : y = 499, t = tt, x = 3;
   const A.named(z, this.t) : y = 400 + z, this.z = z, x = 3;
   const A.named2(t, z, y, x) : x = t, y = z, z = y, t = x;
 }
 ''', const [
    const ConstantData(
        'const A.named(99, 100)',
        'ConstructedConstant(A('
        't=IntConstant(100),'
        'u=IntConstant(42),'
        'x=IntConstant(3),'
        'y=IntConstant(499),'
        'z=IntConstant(99)))'),
    const ConstantData(
        'const A(99, 100)',
        'ConstructedConstant(A('
        't=IntConstant(100),'
        'u=IntConstant(42),'
        'x=IntConstant(3),'
        'y=IntConstant(499),'
        'z=IntConstant(99)))'),
  ]),
  const TestData('errors', r'''
 const integer = const int.fromEnvironment("foo", defaultValue: 5);
 const string = const String.fromEnvironment("bar", defaultValue: "baz");
 const boolean = const bool.fromEnvironment("baz", defaultValue: false);
 const not_string =
    const bool.fromEnvironment("not_string", defaultValue: false) ? '' : 0;
 get getter => 0;
 class Class1 {
    final field;
    const Class1() : field = not_string.length;
 }
 class Class2 implements Class3 {
    const Class2() : assert(false);
    const Class2.redirect() : this();
 }
 class Class3 {
    const Class3() : assert(false, "Message");
    const factory Class3.fact() = Class2;
 }
 class Class4 extends Class2 {
    const Class4();
 }
 class Class5 {
    const Class5(a) : assert(a > 0, "$a <= 0");
 }
 class Class6 extends Class5 {
    const Class6(a) : super(a - 1);
 }
 class Class7 {
    const Class7();
 }
 ''', const [
    const ConstantData(
        r'"$integer $string $boolean"', 'StringConstant("5 baz false")'),
    const ConstantData('0 ? true : false', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_CONDITIONAL_TYPE),
    const ConstantData('integer ? true : false', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_CONDITIONAL_TYPE),
    const ConstantData(r'"${const []}"', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE),
    const ConstantData(r'"${proxy}"', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE),
    const ConstantData(r'"${proxy}${const []}"', 'NonConstant',
        expectedErrors: const [
          MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE,
          MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE
        ]),
    const ConstantData(r'"${"${proxy}"}${const []}"', 'NonConstant',
        expectedErrors: const [
          MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE,
          MessageKind.INVALID_CONSTANT_INTERPOLATION_TYPE
        ]),
    const ConstantData('0 + ""', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_NUM_ADD_TYPE),
    const ConstantData('0 + string', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_NUM_ADD_TYPE),
    const ConstantData('"" + 0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_STRING_ADD_TYPE),
    const ConstantData('string + 0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_STRING_ADD_TYPE),
    const ConstantData('true + ""', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_STRING_ADD_TYPE),
    const ConstantData('boolean + string', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_STRING_ADD_TYPE),
    const ConstantData('true + false', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_ADD_TYPES),
    const ConstantData('boolean + false', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_ADD_TYPES),
    const ConstantData('0 * ""', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_BINARY_NUM_TYPE),
    const ConstantData('0 * string', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_BINARY_NUM_TYPE),
    const ConstantData('0 % ""', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_BINARY_NUM_TYPE),
    const ConstantData('0 % string', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_BINARY_NUM_TYPE),
    const ConstantData('0 << ""', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_BINARY_INT_TYPE),
    const ConstantData('0 << string', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_BINARY_INT_TYPE),
    const ConstantData('1 ~/ 0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_DIV),
    const ConstantData('1 ~/ 0.0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_DIV),
    const ConstantData('1 % 0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_DIV),
    const ConstantData('1 % 0.0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_DIV),
    const ConstantData('1 << -1', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_SHIFT),
    const ConstantData('1 >> -1', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_SHIFT),
    const ConstantData('null[0]', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_INDEX),
    const ConstantData('const bool.fromEnvironment(0)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_FROM_ENVIRONMENT_NAME_TYPE),
    const ConstantData('const bool.fromEnvironment(integer)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_FROM_ENVIRONMENT_NAME_TYPE),
    const ConstantData(
        'const bool.fromEnvironment("baz", defaultValue: 0)', 'NonConstant',
        expectedErrors:
            MessageKind.INVALID_BOOL_FROM_ENVIRONMENT_DEFAULT_VALUE_TYPE),
    const ConstantData(
        'const bool.fromEnvironment("baz", defaultValue: integer)',
        'NonConstant',
        expectedErrors:
            MessageKind.INVALID_BOOL_FROM_ENVIRONMENT_DEFAULT_VALUE_TYPE),
    const ConstantData('const int.fromEnvironment(0)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_FROM_ENVIRONMENT_NAME_TYPE),
    const ConstantData('const int.fromEnvironment(integer)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_FROM_ENVIRONMENT_NAME_TYPE),
    const ConstantData(
        'const int.fromEnvironment("baz", defaultValue: "")', 'NonConstant',
        expectedErrors:
            MessageKind.INVALID_INT_FROM_ENVIRONMENT_DEFAULT_VALUE_TYPE),
    const ConstantData(
        'const int.fromEnvironment("baz", defaultValue: string)', 'NonConstant',
        expectedErrors:
            MessageKind.INVALID_INT_FROM_ENVIRONMENT_DEFAULT_VALUE_TYPE),
    const ConstantData('const String.fromEnvironment(0)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_FROM_ENVIRONMENT_NAME_TYPE),
    const ConstantData('const String.fromEnvironment(integer)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_FROM_ENVIRONMENT_NAME_TYPE),
    const ConstantData(
        'const String.fromEnvironment("baz", defaultValue: 0)', 'NonConstant',
        expectedErrors:
            MessageKind.INVALID_STRING_FROM_ENVIRONMENT_DEFAULT_VALUE_TYPE),
    const ConstantData(
        'const String.fromEnvironment("baz", defaultValue: integer)',
        'NonConstant',
        expectedErrors:
            MessageKind.INVALID_STRING_FROM_ENVIRONMENT_DEFAULT_VALUE_TYPE),
    const ConstantData('true || 0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_OR_OPERAND_TYPE),
    const ConstantData('0 || true', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_OR_OPERAND_TYPE),
    const ConstantData('true || integer', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_OR_OPERAND_TYPE),
    const ConstantData('integer || true', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_OR_OPERAND_TYPE),
    const ConstantData('true && 0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_AND_OPERAND_TYPE),
    const ConstantData('0 && true', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_AND_OPERAND_TYPE),
    const ConstantData('integer && true', 'NonConstant',
        expectedErrors: MessageKind.INVALID_LOGICAL_AND_OPERAND_TYPE),
    const ConstantData('!0', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_NOT_TYPE),
    const ConstantData('!string', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_NOT_TYPE),
    const ConstantData('-("")', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_NEGATE_TYPE),
    const ConstantData('-(string)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_NEGATE_TYPE),
    const ConstantData('not_string.length', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_STRING_LENGTH_TYPE),
    const ConstantData('const Class1()', 'NonConstant',
        expectedErrors: MessageKind.INVALID_CONSTANT_STRING_LENGTH_TYPE),
    const ConstantData('getter', 'NonConstant'),
    const ConstantData('const Class2()', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE),
    const ConstantData('const Class2.redirect()', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE),
    const ConstantData('const Class3()', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE_MESSAGE),
    const ConstantData('const Class3.fact()', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE),
    const ConstantData('const Class4()', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE),
    const ConstantData('const Class5(0)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE_MESSAGE),
    const ConstantData('const Class5(1)', 'ConstructedConstant(Class5())'),
    const ConstantData('const Class6(1)', 'NonConstant',
        expectedErrors: MessageKind.INVALID_ASSERT_VALUE_MESSAGE),
    const ConstantData('const Class6(2)', 'ConstructedConstant(Class6())'),
    const ConstantData('const Class7()', 'ConstructedConstant(Class7())'),
    const ConstantData('const Class7() == const Class7()', 'NonConstant',
        expectedErrors: const [
          MessageKind.INVALID_CONSTANT_BINARY_PRIMITIVE_TYPE,
          MessageKind.INVALID_CONSTANT_BINARY_PRIMITIVE_TYPE
        ]),
  ]),
  const TestData('assert', '''
    class A {
      const A() : assert(true);
    }
    class B {
      const B() : assert(true, "Message");
    }
    class C {
      final a;
      const C(this.a);
    }
    class D extends C {
      final b;
      const D(c) : b = c + 2, super(c + 1);
    }
  ''', const [
    const ConstantData(r'const A()', 'ConstructedConstant(A())'),
    const ConstantData(r'const B()', 'ConstructedConstant(B())'),
    const ConstantData(r'const D(0)',
        'ConstructedConstant(D(a=IntConstant(1),b=IntConstant(2)))'),
  ]),
  const TestData('instantiations', '''
T identity<T>(T t) => t;
class C<T> {
  final T defaultValue;
  final T Function(T t) identityFunction;

  const C(this.defaultValue, this.identityFunction);
}
  ''', const <ConstantData>[
    const ConstantData('identity', 'FunctionConstant(identity)'),
    const ConstantData(
        'const C<int>(0, identity)',
        'ConstructedConstant(C<int>(defaultValue=IntConstant(0),'
        'identityFunction=InstantiationConstant([int],'
        'FunctionConstant(identity))))'),
    const ConstantData(
        'const C<double>(0.5, identity)',
        'ConstructedConstant(C<double>(defaultValue=DoubleConstant(0.5),'
        'identityFunction=InstantiationConstant([double],'
        'FunctionConstant(identity))))'),
  ]),
  const TestData('generic class', '''
class C<T> {
  const C.generative();
  const C.redirect() : this.generative();
}
  ''', const <ConstantData>[
    const ConstantData(
        'const C<int>.generative()', 'ConstructedConstant(C<int>())'),
    const ConstantData(
        'const C<int>.redirect()', 'ConstructedConstant(C<int>())'),
  ])
];

main(List<String> args) {
  asyncTest(() async {
    for (TestData data in DATA) {
      if (args.isNotEmpty && !args.contains(data.name)) continue;
      await testData(data);
    }
  });
}

Future testData(TestData data) async {
  StringBuffer sb = new StringBuffer();
  sb.writeln('${data.declarations}');
  Map<String, ConstantData> constants = {};
  List<String> names = <String>[];
  data.constants.forEach((ConstantData constantData) {
    String name = 'c${constants.length}';
    names.add(name);
    sb.writeln('const $name = ${constantData.code};');
    constants[name] = constantData;
  });
  sb.writeln('main() {');
  for (String name in names) {
    sb.writeln('  print($name);');
  }
  sb.writeln('}');
  String source = sb.toString();
  print("--source '${data.name}'---------------------------------------------");
  print(source);

  Future runTest(
      EvaluationEnvironment getEnvironment(
          Compiler compiler, FieldEntity field)) async {
    CompilationResult result =
        await runCompiler(memorySourceFiles: {'main.dart': source});
    Compiler compiler = result.compiler;
    KElementEnvironment elementEnvironment =
        compiler.frontendStrategy.elementEnvironment;
    LibraryEntity library = elementEnvironment.mainLibrary;
    constants.forEach((String name, ConstantData data) {
      FieldEntity field = elementEnvironment.lookupLibraryMember(library, name);
      compiler.reporter.withCurrentElement(field, () {
        ConstantExpression constant =
            elementEnvironment.getFieldConstantForTesting(field);

        var expectedResults = data.expectedResults;
        if (expectedResults is String) {
          expectedResults = <Map<String, String>, String>{
            const <String, String>{}: expectedResults
          };
        }
        expectedResults.forEach((Map<String, String> env, String expectedText) {
          MemoryEnvironment environment =
              new MemoryEnvironment(getEnvironment(compiler, field), env);
          ConstantValue value =
              constant.evaluate(environment, DART_CONSTANT_SYSTEM);

          Expect.isNotNull(
              value,
              "Expected non-null value from evaluation of "
              "`${constant.toStructuredText()}`.");

          String valueText = value.toStructuredText();
          Expect.equals(
              expectedText,
              valueText,
              "Unexpected value '${valueText}' for field $field = "
              "`${constant.toDartText()}`, expected '${expectedText}'.");

          List<MessageKind> errors =
              environment.errors.map((m) => m.kind).toList();
          var expectedErrors = data.expectedErrors;
          if (expectedErrors != null) {
            if (expectedErrors is! List) {
              expectedErrors = [expectedErrors];
            }
            Expect.listEquals(
                expectedErrors,
                errors,
                "Error mismatch for `$field = ${constant.toDartText()}`:\n"
                "Expected: ${data.expectedErrors},\n"
                "Found: ${errors}.");
          } else {
            Expect.isTrue(
                errors.isEmpty,
                "Unexpected errors for `$field = ${constant.toDartText()}`:\n"
                "Found: ${errors}.");
          }
        });
      });
    });
  }

  const skipStrongList = const [
    // TODO(johnniwinther): Investigate why different errors are reported in
    // strong mode.
    'errors',
  ];

  if (!skipStrongList.contains(data.name)) {
    await runTest((Compiler compiler, FieldEntity field) {
      KernelFrontEndStrategy frontendStrategy = compiler.frontendStrategy;
      KernelToElementMapImpl elementMap = frontendStrategy.elementMap;
      return new KernelEvaluationEnvironment(elementMap, null, field,
          constantRequired: field.isConst);
    });
  }
}