Add ConstantExpression.evaluate.

tests/compiler/dart2js/constant_expression_evaluate_test.dart

+// 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/constants/expressions.dart';
+import 'package:compiler/src/constants/values.dart';
+import 'package:compiler/src/constant_system_dart.dart';
+import 'package:compiler/src/core_types.dart';
+import 'package:compiler/src/dart2jslib.dart';
+import 'package:compiler/src/elements/elements.dart';
+import 'memory_compiler.dart';
+
+class TestData {
+  /// Declarations needed for the [constants].
+  final String declarations;
+  /// Tested constants.
+  final List constants;
+
+  const TestData(this.declarations, this.constants);
+}
+
+class ConstantData {
+  /// Source code for the constant expression.
+  final String code;
+  /// Map from environment to expected constant value as structured text.
+  final Map<Map<String, String>, String> expectedValues;
+
+  const ConstantData(this.code,
+                     this.expectedValues);
+}
+
+class MemoryEnvironment implements Environment {
+  final Compiler compiler;
+  final Map<String, String> env;
+
+  MemoryEnvironment(this.compiler, [this.env = const <String, String>{}]);
+
+  @override
+  String readFromEnvironment(String name) => env[name];
+}
+
+const List<TestData> DATA = const [
+  const TestData('', const [
+    const ConstantData('null', const { const {} : 'NullConstant' }),
+    const ConstantData('false', const { const {} : 'BoolConstant(false)' }),
+    const ConstantData('true', const { const {} : 'BoolConstant(true)' }),
+    const ConstantData('0', const { const {} : 'IntConstant(0)' }),
+    const ConstantData('0.0', const { const {} : 'DoubleConstant(0.0)' }),
+    const ConstantData('"foo"', const { const {} : 'StringConstant("foo")' }),
+    const ConstantData('1 + 2', const { const {} : 'IntConstant(3)' }),
+    const ConstantData('-(1)', const { const {} : 'IntConstant(-1)' }),
+    const ConstantData('identical(0, 1)',
+                       const { const {} : 'BoolConstant(false)' }),
+    const ConstantData('"a" "b"', const { const {} : 'StringConstant("ab")' }),
+    const ConstantData('identical',
+        const { const {} : 'FunctionConstant(identical)' }),
+    const ConstantData('true ? 0 : 1', const { const {} : 'IntConstant(0)' }),
+    const ConstantData('proxy',
+        const { const {} : 'ConstructedConstant(_Proxy())' }),
+    const ConstantData('Object', const { const {} : 'TypeConstant(Object)' }),
+    const ConstantData('const [0, 1]',
+        const { const {} : 'ListConstant([IntConstant(0),IntConstant(1)])' }),

[karlklose, 2015/05/11 12:48:08]

I would prefer more white-space in the string values (after ',' and ':' below).

[Johnni Winther, 2015/05/11 13:59:46]

Done.

+    const ConstantData('const <int>[0, 1]', const {
+        const {} : 'ListConstant(<int>[IntConstant(0),IntConstant(1)])' }),
+    const ConstantData('const {0: 1, 2: 3}',
+        const { const {} :
+          'MapConstant({IntConstant(0):IntConstant(1),'
+                       'IntConstant(2):IntConstant(3)})' }),
+    const ConstantData('const <int, int>{0: 1, 2: 3}',
+        const { const {} :
+          'MapConstant(<int, int>{IntConstant(0):IntConstant(1),'
+                                 'IntConstant(2):IntConstant(3)})' }),
+    const ConstantData(
+        'const bool.fromEnvironment("foo", defaultValue: false)',
+        const { const {} : 'BoolConstant(false)',
+                const {'foo': 'true'} : 'BoolConstant(true)'}),
+    const ConstantData(
+        'const int.fromEnvironment("foo", defaultValue: 42)',
+        const { const {} : 'IntConstant(42)',
+                const {'foo': '87'} : 'IntConstant(87)'}),
+    const ConstantData(
+        'const String.fromEnvironment("foo", defaultValue: "bar")',
+        const { const {} : 'StringConstant("bar")',
+                const {'foo': 'foo'} : 'StringConstant("foo")'}),
+  ]),
+  const TestData('''
+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);
+}
+''', const [
+    const ConstantData('const Object()',
+        const { const {} : 'ConstructedConstant(Object())' }),
+    const ConstantData('const A()',
+        const { const {} : 'ConstructedConstant(A())' }),
+    const ConstantData('const B(0)',
+        const { const {} : 'ConstructedConstant(B(field1=IntConstant(0)))' }),
+    const ConstantData('const B(const A())',
+        const { const {} :
+          'ConstructedConstant(B(field1=ConstructedConstant(A())))' }),
+    const ConstantData('const C()', const { const {} :
+        'ConstructedConstant(C(field1=IntConstant(42),'
+                              'field2=BoolConstant(false)))' }),
+    const ConstantData('const C(field1: 87)', const { const {} :
+        'ConstructedConstant(C(field1=IntConstant(87),'
+                              'field2=BoolConstant(false)))' }),
+    const ConstantData('const C(field2: true)', const { const {} :
+        'ConstructedConstant(C(field1=IntConstant(42),'
+                              'field2=BoolConstant(true)))' }),
+    const ConstantData('const C.named()', const { const {} :
+        'ConstructedConstant(C(field1=BoolConstant(false),'
+                              'field2=BoolConstant(false)))' }),
+    const ConstantData('const C.named(87)', const { const {} :
+        'ConstructedConstant(C(field1=IntConstant(87),'
+                              'field2=IntConstant(87)))' }),
+    const ConstantData('const C(field1: a, field2: b)', const {
+        const {} :
+          'ConstructedConstant(C(field1=BoolConstant(true),'
+                                'field2=IntConstant(42)))',
+        const {'foo': 'false', 'bar': '87'} :
+          'ConstructedConstant(C(field1=BoolConstant(false),'
+                                'field2=IntConstant(87)))', }),
+  ]),
+  const TestData('''
+class A<T> implements B {
+  final field1;
+  const A({this.field1:42});
+}
+class B<S> implements C {
+  const factory B({field1}) = A<B<S>>;
+  // TODO(johnniwinther): Enable this when the constructor evaluator doesn't
+  // crash:
+  /*const factory B.named() = A<S>;*/
+}
+class C<U> {
+  const factory C({field1}) = A<B<double>>;
+}
+''', const [
+    const ConstantData('const A()',
+        const { const {} :
+          'ConstructedConstant(A<dynamic>(field1=IntConstant(42)))' }),
+    const ConstantData('const A<int>(field1: 87)',
+        const { const {} :
+          'ConstructedConstant(A<int>(field1=IntConstant(87)))' }),
+    const ConstantData('const B()',
+        const { const {} :
+          'ConstructedConstant(A<B<dynamic>>(field1=IntConstant(42)))' }),
+    const ConstantData('const B<int>()',
+        const { const {} :
+          'ConstructedConstant(A<B<int>>(field1=IntConstant(42)))' }),
+    const ConstantData('const B<int>(field1: 87)',
+        const { const {} :
+          'ConstructedConstant(A<B<int>>(field1=IntConstant(87)))' }),
+    const ConstantData('const C<int>(field1: 87)',
+        const { const {} :
+          'ConstructedConstant(A<B<double>>(field1=IntConstant(87)))' }),
+    // TODO(johnniwinther): Enable this when the constructor evaluator doesn't
+    // crash:
+    /*const ConstantData('const B<int>.named()',
+        const { const {} :
+          'ConstructedConstant(A<int>(field1=IntConstant(42)))' }),*/
+  ]),
+  const TestData('''
+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 {
+        const {} :
+          'ConstructedConstant(A(field=IntConstant(15)))',
+        const {'foo': '7', 'bar': '11'} :
+          'ConstructedConstant(A(field=IntConstant(18)))', }),
+    const ConstantData('const B(d)', const {
+        const {} :
+          'ConstructedConstant(B(field=IntConstant(30)))',
+        const {'bar': '42'} :
+          'ConstructedConstant(B(field=IntConstant(126)))', }),
+  ]),
+];
+
+main() {
+  asyncTest(() => Future.forEach(DATA, testData));
+}
+
+Future testData(TestData data) {
+  StringBuffer sb = new StringBuffer();
+  sb.write('${data.declarations}\n');
+  Map constants = {};
+  data.constants.forEach((ConstantData constantData) {
+    String name = 'c${constants.length}';
+    sb.write('const $name = ${constantData.code};\n');
+    constants[name] = constantData;
+  });
+  sb.write('main() {}\n');
+  String source = sb.toString();
+  Compiler compiler = compilerFor(
+      {'main.dart': source}, options: ['--analyze-all']);
+  return compiler.runCompiler(Uri.parse('memory:main.dart')).then((_) {
+    var library = compiler.mainApp;
+    constants.forEach((String name, ConstantData data) {
+      FieldElement field = library.localLookup(name);
+      ConstantExpression constant = field.constant;
+      data.expectedValues.forEach(
+          (Map<String, String> env, String expectedText) {
+        Environment environment = new MemoryEnvironment(compiler, env);
+        ConstantValue value =
+            constant.evaluate(environment, DART_CONSTANT_SYSTEM);
+        String valueText = value.toStructuredString();
+        Expect.equals(expectedText, valueText,
+            "Unexpected value '${valueText}' for contant "
+            "`${constant.getText()}`, expected '${expectedText}'.");
+      });
+    });
+  });
+}