Begin to compute constant expressions in resolution.

tests/compiler/dart2js/resolver_test.dart

 // Copyright (c) 2012, 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:expect/expect.dart";
 import 'dart:async';
-import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
-import "package:compiler/src/resolution/resolution.dart";
-import "compiler_helper.dart";
-import "parser_helper.dart";
-
+import 'package:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/dart_types.dart';
 import 'package:compiler/src/elements/modelx.dart';
+import 'package:compiler/src/resolution/resolution.dart';
+
+import 'compiler_helper.dart';
 import 'link_helper.dart';
+import 'parser_helper.dart';
 
 Node buildIdentifier(String name) => new Identifier(scan(name));
 
 Node buildInitialization(String name) =>
   parseBodyCode('$name = 1',
       (parser, tokens) => parser.parseOptionallyInitializedIdentifier(tokens));
 
 createLocals(List variables) {
   var locals = <Node>[];
   for (final variable in variables) {
     String name = variable[0];
     bool init = variable[1];
     if (init) {
       locals.add(buildInitialization(name));
     } else {
       locals.add(buildIdentifier(name));
     }
   }
   var definitions = new NodeList(null, LinkFromList(locals), null, null);
   return new VariableDefinitions(null, Modifiers.EMPTY, definitions);
 }
 
 Future testLocals(List variables) {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     ResolutionResult result = visitor.visit(createLocals(variables));
-    Element element = result != null ? result.element : null;
     // A VariableDefinitions does not have an element.
-    Expect.equals(null, element);
+    Expect.equals(const NoneResult(), result);
     Expect.equals(variables.length, map(visitor).length);
 
     for (final variable in variables) {
       final name = variable[0];
       Identifier id = buildIdentifier(name);
       ResolutionResult result = visitor.visit(id);
-      final VariableElement variableElement =
-          result != null ? result.element : null;
+      final VariableElement variableElement = result.element;
       MethodScope scope = visitor.scope;
       Expect.equals(variableElement, scope.elements[name]);
     }
     return compiler;
   });
 }
 
 main() {
   asyncTest(() => Future.forEach([
     testLocalsOne,
@@ skipping 20 matching lines @@
     testTypeVariables,
     testToString,
     testIndexedOperator,
     testIncrementsAndDecrements,
     testOverrideHashCodeCheck,
     testSupertypeOrder,
     testConstConstructorAndNonFinalFields,
     testCantAssignMethods,
     testCantAssignFinalAndConsts,
     testAwaitHint,
+    testConstantExpressions,
   ], (f) => f()));
 }
 
 Future testSupertypeOrder() {
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""
 class I1 {}
 class I2 {}
 class J1 extends K1 {}
@@ skipping 207 matching lines @@
           new Message(MessageKind.DUPLICATE_DEFINITION, {'name': 'foo'}, false),
           compiler.errors[0].message);
     })], (f) => f());
 }
 
 
 Future testLocalsTwo() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Node tree = parseStatement("if (true) { var a = 1; var b = 2; }");
-    ResolutionResult element = visitor.visit(tree);
-    Expect.equals(null, element);
+    ResolutionResult result = visitor.visit(tree);
+    Expect.equals(const NoneResult(), result);
     MethodScope scope = visitor.scope;
     Expect.equals(0, scope.elements.length);
     Expect.equals(2, map(visitor).length);
 
     List<Element> elements = new List<Element>.from(map(visitor).values);
     Expect.notEquals(elements[0], elements[1]);
   });
 }
 
 Future testLocalsThree() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Node tree = parseStatement("{ var a = 1; if (true) { a; } }");
-    ResolutionResult element = visitor.visit(tree);
-    Expect.equals(null, element);
+    ResolutionResult result = visitor.visit(tree);
+    Expect.equals(const NoneResult(), result);
     MethodScope scope = visitor.scope;
     Expect.equals(0, scope.elements.length);
     Expect.equals(3, map(visitor).length);
     List<Element> elements = map(visitor).values.toList();
     Expect.equals(elements[0], elements[1]);
   });
 }
 
 Future testLocalsFour() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Node tree = parseStatement("{ var a = 1; if (true) { var a = 1; } }");
-    ResolutionResult element = visitor.visit(tree);
-    Expect.equals(null, element);
+    ResolutionResult result = visitor.visit(tree);
+    Expect.equals(const NoneResult(), result);
     MethodScope scope = visitor.scope;
     Expect.equals(0, scope.elements.length);
     Expect.equals(2, map(visitor).length);
     List<Element> elements = map(visitor).values.toList();
     Expect.notEquals(elements[0], elements[1]);
   });
 }
 
 Future testLocalsFive() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     If tree =
         parseStatement("if (true) { var a = 1; a; } else { var a = 2; a;}");
-    ResolutionResult element = visitor.visit(tree);
-    Expect.equals(null, element);
+    ResolutionResult result = visitor.visit(tree);
+    Expect.equals(const NoneResult(), result);
     MethodScope scope = visitor.scope;
     Expect.equals(0, scope.elements.length);
     Expect.equals(6, map(visitor).length);
 
     Block thenPart = tree.thenPart;
     List statements1 = thenPart.statements.nodes.toList();
     Node def1 = statements1[0].definitions.nodes.head;
     Node id1 = statements1[1].expression;
     Expect.equals(visitor.registry.mapping[def1],
                   visitor.registry.mapping[id1]);
@@ skipping 615 matching lines @@
           const { 'Object': 'class Object { Object() : super(); }' };
       return resolveConstructor(script,
           "Object o = new Object();", "Object", "", 1,
           expectedWarnings: [],
           expectedErrors: [MessageKind.SUPER_INITIALIZER_IN_OBJECT],
           corelib: INVALID_OBJECT);
     },
   ], (f) => f());
 }
 
+Future testConstantExpressions() {
+  const Map<String, List<String>> testedConstants = const {
+    'null': const ['null'],
+    'true': const ['true'],
+    '0': const ['0'],
+    '0.0': const ['0.0'],
+    '"foo"': const ['"foo"'],
+    '#a': const ['#a'],
+    '0 + 1': const ['0', '1', '0 + 1'],
+    '0 * 1': const ['0', '1', '0 * 1'],
+    '0 * 1 + 2': const ['0', '1', '0 * 1', '2', '0 * 1 + 2'],
+    '0 + 1 * 2': const ['0', '1', '2', '1 * 2', '0 + 1 * 2'],
+    '-(1)': const ['1', '-1'],
+    '-(1 * 4)': const ['1', '4', '1 * 4', '-(1 * 4)'],
+    'true ? 0 : 1': const ['true', '0', '1', 'true ? 0 : 1'],
+    '"a" "b"': const ['"a"', '"b"', '"ab"'],
+    '"a" "b" "c"': const ['"a"', '"b"', '"c"', '"bc"', r'"a${"bc"}"'],
+    r'"a${0}b"': const ['"a"', '0', '"b"', r'"a${0}b"'],
+    r'"a${0}b${1}"': const ['"a"', '0', '"b"', '1', '""', r'"a${0}b${1}"'],
+    'true || false': const ['true', 'false', 'true || false'],
+    'true && false': const ['true', 'false', 'true && false'],
+    '!true': const ['true', '!true'],
+    'const []': const ['const []'],
+    'const <int>[]': const ['const <int>[]'],
+    'const [0, 1, 2]': const ['0', '1', '2', 'const [0, 1, 2]'],
+    'const <int>[0, 1, 2]': const ['0', '1', '2', 'const <int>[0, 1, 2]'],
+    'const {}': const ['const {}'],
+    'const <String, int>{}': const ['const <String, int>{}'],
+    'const {"a": 0, "b": 1, "c": 2}':
+        const ['"a"', '0', '"b"', '1', '"c"', '2',
+               'const {"a": 0, "b": 1, "c": 2}'],
+    'const <String, int>{"a": 0, "b": 1, "c": 2}':
+        const ['"a"', '0', '"b"', '1', '"c"', '2',
+               'const <String, int>{"a": 0, "b": 1, "c": 2}'],
+  };
+  return Future.forEach(testedConstants.keys, (String constant) {
+    return MockCompiler.create((MockCompiler compiler) {
+      CollectingTreeElements elements =
+          compiler.resolveStatement("main() => $constant;");
+      List<String> expectedConstants = testedConstants[constant];
+      Expect.equals(0, compiler.warnings.length);
+      Expect.equals(0, compiler.errors.length);
+      List<ConstantExpression> constants = elements.constants;
+      String constantsText =
+          '[${constants.map((c) => c.getText()).join(', ')}]';
+      Expect.equals(expectedConstants.length, constants.length,
+          "Expected ${expectedConstants.length} constants for `${constant}` "
+          "found $constantsText.");
+      for (int index = 0; index < expectedConstants.length; index++) {
+        Expect.equals(expectedConstants[index], constants[index].getText(),
+            "Expected ${expectedConstants} for `$constant`, "
+            "found $constantsText.");
+      }
+    });
+  });
+}
+
 map(ResolverVisitor visitor) {
   CollectingTreeElements elements = visitor.registry.mapping;
   return elements.map;
 }
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);
 
 List<String> asSortedStrings(Link link) {
   List<String> result = <String>[];
   for (; !link.isEmpty; link = link.tail) result.add(link.head.toString());
@@ skipping 320 matching lines @@
     }
     main() => A.m();
   ''', functionName: 'm');
   check('''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''', className: 'A');
 }