// 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.

// @dart = 2.7

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/commandline_options.dart';
import 'package:compiler/src/common_elements.dart';
import 'package:compiler/src/compiler.dart';
import 'package:compiler/src/constants/values.dart';
import 'package:compiler/src/elements/entities.dart';
import 'package:compiler/src/elements/indexed.dart';
import 'package:compiler/src/elements/types.dart';
import 'package:compiler/src/ir/constants.dart';
import 'package:compiler/src/ir/visitors.dart';
import 'package:compiler/src/kernel/kernel_strategy.dart';
import 'package:compiler/src/kernel/element_map_impl.dart';
import 'package:front_end/src/api_prototype/constant_evaluator.dart' as ir;
import 'package:front_end/src/api_unstable/dart2js.dart' as ir;
import 'package:kernel/ast.dart' as ir;
import 'package:kernel/type_environment.dart' as ir;
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 [String] or a list of [String]s containing the code names for 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});
}

const List<TestData> DATA = [
  TestData('simple', '', [
    ConstantData('null', 'NullConstant'),
    ConstantData('false', 'BoolConstant(false)'),
    ConstantData('true', 'BoolConstant(true)'),
    ConstantData('0', 'IntConstant(0)'),
    ConstantData('0.0', 'IntConstant(0)'),
    ConstantData('"foo"', 'StringConstant("foo")'),
    ConstantData('1 + 2', 'IntConstant(3)'),
    ConstantData('-(1)', 'IntConstant(-1)'),
    ConstantData('1 == 2', 'BoolConstant(false)'),
    ConstantData('1 != 2', 'BoolConstant(true)'),
    ConstantData('1 / 0', 'DoubleConstant(Infinity)'),
    ConstantData('0 / 0', 'DoubleConstant(NaN)'),
    ConstantData('1 << 0', 'IntConstant(1)'),
    ConstantData('1 >> 0', 'IntConstant(1)'),
    ConstantData('"foo".length', 'IntConstant(3)'),
    ConstantData('identical(0, 1)', 'BoolConstant(false)'),
    ConstantData('"a" "b"', 'StringConstant("ab")'),
    ConstantData(r'"${null}"', 'StringConstant("null")'),
    ConstantData('identical', 'FunctionConstant(identical)'),
    ConstantData('true ? 0 : 1', 'IntConstant(0)'),
    ConstantData('proxy', 'ConstructedConstant(_Proxy())'),
    ConstantData('const [] == null', 'BoolConstant(false)'),
    ConstantData('proxy == null', 'BoolConstant(false)'),
    ConstantData('proxy != null', 'BoolConstant(true)'),
    ConstantData('null == proxy', 'BoolConstant(false)'),
    ConstantData('null != proxy', 'BoolConstant(true)'),
    ConstantData('true == proxy', 'BoolConstant(false)'),
    ConstantData('true != proxy', 'BoolConstant(true)'),
    ConstantData('0 == proxy', 'BoolConstant(false)'),
    ConstantData('0 != proxy', 'BoolConstant(true)'),
    ConstantData('0.5 == proxy', 'BoolConstant(false)'),
    ConstantData('0.5 != proxy', 'BoolConstant(true)'),
    ConstantData('"" == proxy', 'BoolConstant(false)'),
    ConstantData('"" != proxy', 'BoolConstant(true)'),
    ConstantData('Object', 'TypeConstant(Object)'),
    ConstantData('null ?? 0', 'IntConstant(0)'),
    ConstantData('const <int, int>{0: 1, 0: 2}', 'NonConstant',
        expectedErrors: 'ConstEvalDuplicateKey'),
    ConstantData(
        'const bool.fromEnvironment("foo", defaultValue: false)',
        <Map<String, String>, String>{
          {}: 'BoolConstant(false)',
          {'foo': 'true'}: 'BoolConstant(true)'
        }),
    ConstantData(
        'const int.fromEnvironment("foo", defaultValue: 42)',
        <Map<String, String>, String>{
          {}: 'IntConstant(42)',
          {'foo': '87'}: 'IntConstant(87)'
        }),
    ConstantData(
        'const String.fromEnvironment("foo", defaultValue: "bar")',
        <Map<String, String>, String>{
          {}: 'StringConstant("bar")',
          {'foo': 'foo'}: 'StringConstant("foo")'
        }),
    ConstantData(
        'const [0, 1]', 'ListConstant(<int*>[IntConstant(0), IntConstant(1)])'),
    ConstantData('const <int>[0, 1]',
        'ListConstant(<int*>[IntConstant(0), IntConstant(1)])'),
    ConstantData(
        'const {0, 1}', 'SetConstant(<int*>{IntConstant(0), IntConstant(1)})'),
    ConstantData('const <int>{0, 1}',
        'SetConstant(<int*>{IntConstant(0), IntConstant(1)})'),
    ConstantData(
        'const {0: 1, 2: 3}',
        'MapConstant(<int*, int*>{IntConstant(0): IntConstant(1), '
            'IntConstant(2): IntConstant(3)})'),
    ConstantData(
        'const <int, int>{0: 1, 2: 3}',
        'MapConstant(<int*, int*>{IntConstant(0): IntConstant(1), '
            'IntConstant(2): IntConstant(3)})'),
  ]),
  TestData('env', '''
const a = bool.fromEnvironment("foo", defaultValue: true);
const b = 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);
}
''', [
    ConstantData('const Object()', 'ConstructedConstant(Object())'),
    ConstantData('const A()', 'ConstructedConstant(A())'),
    ConstantData('const B(0)', 'ConstructedConstant(B(field1=IntConstant(0)))'),
    ConstantData('const B(A())',
        'ConstructedConstant(B(field1=ConstructedConstant(A())))'),
    ConstantData(
        'const C()',
        'ConstructedConstant(C(field1=IntConstant(42),'
            'field2=BoolConstant(false)))'),
    ConstantData(
        'const C(field1: 87)',
        'ConstructedConstant(C(field1=IntConstant(87),'
            'field2=BoolConstant(false)))'),
    ConstantData(
        'const C(field2: true)',
        'ConstructedConstant(C(field1=IntConstant(42),'
            'field2=BoolConstant(true)))'),
    ConstantData(
        'const C.named()',
        'ConstructedConstant(C(field1=BoolConstant(false),'
            'field2=BoolConstant(false)))'),
    ConstantData(
        'const C.named(87)',
        'ConstructedConstant(C(field1=IntConstant(87),'
            'field2=IntConstant(87)))'),
    ConstantData('const C(field1: a, field2: b)', <Map<String, String>, String>{
      {}: 'ConstructedConstant(C(field1=BoolConstant(true),'
          'field2=IntConstant(42)))',
      {'foo': 'false', 'bar': '87'}:
          'ConstructedConstant(C(field1=BoolConstant(false),'
              'field2=IntConstant(87)))',
    }),
    ConstantData(
        'const D(42, 87)',
        'ConstructedConstant(D(field1=IntConstant(87),'
            'field2=IntConstant(42),'
            'field3=IntConstant(99)))'),
  ]),
  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>>;
}
''', [
    ConstantData(
        'const A()', 'ConstructedConstant(A<dynamic>(field1=IntConstant(42)))'),
    ConstantData('const A<int>(field1: 87)',
        'ConstructedConstant(A<int*>(field1=IntConstant(87)))'),
    ConstantData('const B()',
        'ConstructedConstant(A<B<dynamic>*>(field1=IntConstant(42)))'),
    ConstantData('const B<int>()',
        'ConstructedConstant(A<B<int*>*>(field1=IntConstant(42)))'),
    ConstantData('const B<int>(field1: 87)',
        'ConstructedConstant(A<B<int*>*>(field1=IntConstant(87)))'),
    ConstantData('const C<int>(field1: 87)',
        'ConstructedConstant(A<B<double*>*>(field1=IntConstant(87)))'),
    ConstantData('const B<int>.named()',
        'ConstructedConstant(A<int*>(field1=IntConstant(42)))'),
  ]),
  TestData('env2', '''
const c = int.fromEnvironment("foo", defaultValue: 5);
const d = 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);
}
''', [
    ConstantData('const A(c, d)', <Map<String, String>, String>{
      {}: 'ConstructedConstant(A(field=IntConstant(15)))',
      {'foo': '7', 'bar': '11'}:
          'ConstructedConstant(A(field=IntConstant(18)))',
    }),
    ConstantData('const B(d)', <Map<String, String>, String>{
      {}: 'ConstructedConstant(B(field=IntConstant(30)))',
      {'bar': '42'}: 'ConstructedConstant(B(field=IntConstant(126)))',
    }),
  ]),
  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;
 }
 ''', [
    ConstantData(
        'const A.named(99, 100)',
        'ConstructedConstant(A('
            't=IntConstant(100),'
            'u=IntConstant(42),'
            'x=IntConstant(3),'
            'y=IntConstant(499),'
            'z=IntConstant(99)))'),
    ConstantData(
        'const A(99, 100)',
        'ConstructedConstant(A('
            't=IntConstant(100),'
            'u=IntConstant(42),'
            'x=IntConstant(3),'
            'y=IntConstant(499),'
            'z=IntConstant(99)))'),
  ]),
  TestData('errors', r'''
 const dynamic null_ = bool.fromEnvironment('x') ? null : null;
 const dynamic zero = bool.fromEnvironment('x') ? null : 0;
 const dynamic minus_one = bool.fromEnvironment('x') ? null : -1;
 const dynamic false_ = bool.fromEnvironment('x') ? null : false;
 const dynamic integer = int.fromEnvironment("foo", defaultValue: 5);
 const dynamic string = String.fromEnvironment("bar", defaultValue: "baz");
 const dynamic boolean = bool.fromEnvironment("baz", defaultValue: false);
 const dynamic not_string =
    bool.fromEnvironment("not_string", defaultValue: false) ? '' : 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();
 }
 class Class8 {
    final field;
    const Class8(this.field);
 }
 class Class9 {
    final field = null_;
    const Class9();
 }
 class Class10 {
    final int field = string;
    const Class10();
 }
 ''', [
    ConstantData(
        r'"$integer $string $boolean"', 'StringConstant("5 baz false")'),
    ConstantData('integer ? true : false', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData(r'"${proxy}"', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidStringInterpolationOperand'),
    ConstantData('0 + string', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('string + 0', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidBinaryOperandType'),
    ConstantData('boolean + string', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidMethodInvocation'),
    ConstantData('boolean + false', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidMethodInvocation'),
    ConstantData('0 * string', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('0 % string', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('0 << string', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('1 ~/ zero', 'NonConstant',
        expectedErrors: 'ConstEvalZeroDivisor'),
    ConstantData('1 % zero', 'NonConstant',
        expectedErrors: 'ConstEvalZeroDivisor'),
    ConstantData('1 << minus_one', 'NonConstant',
        expectedErrors: 'ConstEvalNegativeShift'),
    ConstantData('1 >> minus_one', 'NonConstant',
        expectedErrors: 'ConstEvalNegativeShift'),
    ConstantData('const bool.fromEnvironment(integer)', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('const bool.fromEnvironment("baz", defaultValue: integer)',
        'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('const int.fromEnvironment(integer)', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData(
        'const int.fromEnvironment("baz", defaultValue: string)', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('const String.fromEnvironment(integer)', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('const String.fromEnvironment("baz", defaultValue: integer)',
        'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('false || integer', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('integer || true', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('integer && true', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('!integer', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('!string', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('-(string)', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidMethodInvocation'),
    ConstantData('not_string.length', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidPropertyGet'),
    ConstantData('const Class1()', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidPropertyGet'),
    ConstantData('const Class2()', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertion'),
    ConstantData('const Class2.redirect()', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertion'),
    ConstantData('const Class3()', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertionWithMessage'),
    ConstantData('const Class3.fact()', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertion'),
    ConstantData('const Class4()', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertion'),
    ConstantData('const Class5(0)', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertionWithMessage'),
    ConstantData('const Class5(1)', 'ConstructedConstant(Class5())'),
    ConstantData('const Class6(1)', 'NonConstant',
        expectedErrors: 'ConstEvalFailedAssertionWithMessage'),
    ConstantData('const Class6(2)', 'ConstructedConstant(Class6())'),
    ConstantData('const Class7()', 'ConstructedConstant(Class7())'),
    ConstantData('const Class7() == const Class7()', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidEqualsOperandType'),
    ConstantData('const Class7() != const Class7()', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidEqualsOperandType'),
    ConstantData('const Class8(not_string.length)', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidPropertyGet'),
    ConstantData(
        'const Class9()', 'ConstructedConstant(Class9(field=NullConstant))'),
    ConstantData('const Class10()', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
  ]),
  TestData('assert', '''
    const true_ = bool.fromEnvironment('x') ? null : true;
    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);
    }
    class E {
      const E() : assert(true_);
    }
  ''', [
    ConstantData(r'const A()', 'ConstructedConstant(A())'),
    ConstantData(r'const B()', 'ConstructedConstant(B())'),
    ConstantData(r'const D(0)',
        'ConstructedConstant(D(a=IntConstant(1),b=IntConstant(2)))'),
    ConstantData(r'const E()', 'ConstructedConstant(E())'),
  ]),
  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);
}
  ''', [
    ConstantData('identity', 'FunctionConstant(identity)'),
    ConstantData(
        'const C<int>(0, identity)',
        'ConstructedConstant(C<int*>(defaultValue=IntConstant(0),'
            'identityFunction=InstantiationConstant([int*],'
            'FunctionConstant(identity))))'),
    ConstantData(
        'const C<double>(0.5, identity)',
        'ConstructedConstant(C<double*>(defaultValue=DoubleConstant(0.5),'
            'identityFunction=InstantiationConstant([double*],'
            'FunctionConstant(identity))))'),
  ]),
  TestData('generic class', '''
class C<T> {
  const C.generative();
  const C.redirect() : this.generative();
}
  ''', <ConstantData>[
    ConstantData('const C<int>.generative()', 'ConstructedConstant(C<int*>())'),
    ConstantData('const C<int>.redirect()', 'ConstructedConstant(C<int*>())'),
  ]),
  TestData('instance', '''
const dynamic zero_ = bool.fromEnvironment("x") ? null : 0;
class Class9 {
  final field = zero_;
  const Class9();
}
''', <ConstantData>[
    ConstantData(
        'const Class9()', 'ConstructedConstant(Class9(field=IntConstant(0)))'),
  ]),
  TestData('type-variables', '''
class A {
  const A();
}

class C1<T> {
  final T a;
  const C1(dynamic t) : a = t; // adds implicit cast `as T`
}

T id<T>(T t) => t;

class C2<T> {
  final T Function(T) a;
  const C2(dynamic t) : a = id; // implicit partial instantiation
}
''', <ConstantData>[
    ConstantData('const C1<A>(A())',
        'ConstructedConstant(C1<A*>(a=ConstructedConstant(A())))'),
    ConstantData(
        'const C2<A>(id)',
        'ConstructedConstant(C2<A*>(a='
            'InstantiationConstant([A*],FunctionConstant(id))))'),
  ]),
  TestData('unused-arguments', '''
class A {
  const A();

  A operator -() => this;
}
class B implements A {
  const B();

  B operator -() => this;
}
class C implements A {
  const C();

  C operator -() => this;
}
class Class<T extends A> {
  const Class(T t);
  const Class.redirect(dynamic t) : this(t);
  const Class.method(T t) : this(-t);
}
class Subclass<T extends A> extends Class<T> {
  const Subclass(dynamic t) : super(t);
}
''', [
    ConstantData('const Class<B>.redirect(C())', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('const Class<A>.method(A())', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidMethodInvocation'),
    ConstantData('const Subclass<B>(C())', 'NonConstant',
        expectedErrors: 'ConstEvalInvalidType'),
    ConstantData('const Class<A>(A())', 'ConstructedConstant(Class<A*>())'),
    ConstantData(
        'const Class<B>.redirect(B())', 'ConstructedConstant(Class<B*>())'),
    ConstantData(
        'const Subclass<A>(A())', 'ConstructedConstant(Subclass<A*>())'),
    ConstantData(
        'const Subclass<B>(B())', 'ConstructedConstant(Subclass<B*>())'),
  ]),
];

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);
    // Encode the constants as part of a from-environment conditional to force
    // CFE to create unevaluated constants.
    sb.writeln('const $name = bool.fromEnvironment("x") ? '
        'null : ${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() async {
    CompilationResult result = await runCompiler(
        memorySourceFiles: {'main.dart': source},
        options: [Flags.enableAsserts]);
    Compiler compiler = result.compiler;
    KernelFrontendStrategy frontEndStrategy = compiler.frontendStrategy;
    KernelToElementMapImpl elementMap = frontEndStrategy.elementMap;
    DartTypes dartTypes = elementMap.types;
    ir.TypeEnvironment typeEnvironment = elementMap.typeEnvironment;
    KElementEnvironment elementEnvironment =
        compiler.frontendStrategy.elementEnvironment;
    ConstantValuefier constantValuefier = new ConstantValuefier(elementMap);
    LibraryEntity library = elementEnvironment.mainLibrary;
    constants.forEach((String name, ConstantData data) {
      IndexedField field =
          elementEnvironment.lookupLibraryMember(library, name);
      compiler.reporter.withCurrentElement(field, () {
        var expectedResults = data.expectedResults;
        if (expectedResults is String) {
          expectedResults = <Map<String, String>, String>{
            const <String, String>{}: expectedResults
          };
        }
        ir.Field node = elementMap.getMemberNode(field);
        ir.ConstantExpression initializer = node.initializer;
        print('-- testing $field = ${data.code} --');
        expectedResults
            .forEach((Map<String, String> environment, String expectedText) {
          List<String> errors = [];
          Dart2jsConstantEvaluator evaluator =
              new Dart2jsConstantEvaluator(elementMap.typeEnvironment,
                  (ir.LocatedMessage message, List<ir.LocatedMessage> context) {
            // TODO(johnniwinther): Assert that `message.uri != null`. Currently
            // all unevaluated constants have no uri.
            // The actual message is a "constant errors starts here" message,
            // the "real error message" is the first in the context.
            errors.add(context.first.code.name);
            reportLocatedMessage(elementMap.reporter, message, context);
          },
                  environment: environment,
                  supportReevaluationForTesting: true,
                  evaluationMode: compiler.options.useLegacySubtyping
                      ? ir.EvaluationMode.weak
                      : ir.EvaluationMode.strong);
          ir.Constant evaluatedConstant = evaluator.evaluate(
              new ir.StaticTypeContext(node, typeEnvironment), initializer);

          ConstantValue value = evaluatedConstant is! ir.UnevaluatedConstant
              ? constantValuefier.visitConstant(evaluatedConstant)
              : new NonConstantValue();

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

          String valueText = value.toStructuredText(dartTypes);
          Expect.equals(
              expectedText,
              valueText,
              "Unexpected value '${valueText}' for field $field = "
              "`${data.code}` in env $environment, "
              "expected '${expectedText}'.");

          var expectedErrors = data.expectedErrors;
          if (expectedErrors != null) {
            if (expectedErrors is! List) {
              expectedErrors = [expectedErrors];
            }
            Expect.listEquals(
                expectedErrors,
                errors,
                "Error mismatch for `$field = ${data.code}`:\n"
                "Expected: ${data.expectedErrors},\n"
                "Found: ${errors}.");
          } else {
            Expect.isTrue(
                errors.isEmpty,
                "Unexpected errors for `$field = ${data.code}`:\n"
                "Found: ${errors}.");
          }
        });
      });
    });
  }

  await runTest();
}