JS templates

tests/compiler/dart2js/js_parser_statements_test.dart

Index: tests/compiler/dart2js/js_parser_statements_test.dart
diff --git a/tests/compiler/dart2js/js_parser_statements_test.dart b/tests/compiler/dart2js/js_parser_statements_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..5394749f122af103ba07e3429492a1a47e5f1b9f
--- /dev/null
+++ b/tests/compiler/dart2js/js_parser_statements_test.dart
@@ -0,0 +1,143 @@
+// Copyright (c) 2014, 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 'mock_compiler.dart';
+import '../../../sdk/lib/_internal/compiler/implementation/js/js.dart' as jsAst;
+import '../../../sdk/lib/_internal/compiler/implementation/js/js.dart' show js;
+
+
+void testStatement(String statement, List arguments, String expect) {
+  jsAst.Node node = js.statement(statement, arguments);
+  MockCompiler compiler = new MockCompiler();
+  String jsText =
+      jsAst.prettyPrint(node, compiler, allowVariableMinification: false)
+      .getText();
+
+  Expect.stringEquals(expect.trim(), jsText.trim());

[floitsch, 2014/04/22 16:11:18]

for simplicity I would just remove all whitespace for both sides.
"for (var x in foo)" -> "for(varxinfoo)"

But I have to admit that the error-messages are not as nice then.

[sra1, 2014/04/23 02:33:50]

I will leave it alone for now, but replacing multiple whitespaces with space
characters on both would be reasonably pleasant.

+}
+
+void testError(String statement, List arguments, [String expect = ""]) {
+  bool doCheck(exception) {
+    String message = '$exception';
+    Expect.isTrue(message.contains(expect), '"$message" contains "$expect"');
+    return true;
+  }
+  void action() {
+    jsAst.Node node = js.statement(statement, arguments);
+  }
+  Expect.throws(action, doCheck);
+}
+
+// Function declaration and named function.
+const NAMED_FUNCTION_1 = r'''
+function foo/*function declaration*/() {
+  return function harry/*named function*/() { return #; }
+}''';
+
+const NAMED_FUNCTION_1_ONE = r'''
+function foo() {
+  return function harry() {
+    return 1;
+  };
+}''';
+
+const MISC_1 = r'''
+function foo() {
+  /a/;
+  #;
+}''';
+
+const MISC_1_1 = r'''
+function foo() {
+  /a/;
+  1;
+  2;
+}''';
+
+
+
+void main() {
+
+  var eOne = js('1');
+  var eTrue = js('true');
+  var eVar = js('x');
+  var block12 = js.statement('{ 1; 2; }');
+
+  Expect.isTrue(eOne is jsAst.LiteralNumber);
+  Expect.isTrue(eTrue is jsAst.LiteralBool);
+  Expect.isTrue(block12 is jsAst.Block);
+
+  // Interpolated Expressions are upgraded to ExpressionStatements.
+  testStatement('{ #; #; }', [eOne, eOne], '{\n  1;\n  1;\n}');
+
+  // Interpolated sub-blocks are spliced.
+  testStatement('{ #; #; }', [block12, block12],
+      '{\n  1;\n  2;\n  1;\n  2;\n}\n');
+
+  // If-condition.  Dart booleans are evaluated, JS Expression booleans are
+  // substituted.
+  testStatement('if (#) #', [eOne, block12], 'if (1) {\n  1;\n  2;\n}');
+  testStatement('if (#) #;', [eTrue, block12], 'if (true) {\n  1;\n  2;\n}');
+  testStatement('if (#) #;', [true, block12], '{\n  1;\n  2;\n}');
+  testStatement('if (#) #;', [false, block12], ';');
+  testStatement('if (#) 3; else #;', [true, block12], '3;');
+  testStatement('if (#) 3; else #;', [false, block12], '{\n  1;\n  2;\n}');
+
+
+  testStatement(NAMED_FUNCTION_1, [eOne], NAMED_FUNCTION_1_ONE);
+
+  testStatement(MISC_1, [block12], MISC_1_1);
+
+  // Argument list splicing.
+  testStatement('foo(#)', [[]], 'foo();');
+  testStatement('foo(#)', [[eOne]], 'foo(1);');
+  testStatement('foo(#)', [eOne], 'foo(1);');
+  testStatement('foo(#)', [[eTrue,eOne]], 'foo(true, 1);');
+
+  testStatement('foo(2,#)', [[]], 'foo(2);');
+  testStatement('foo(2,#)', [[eOne]], 'foo(2, 1);');
+  testStatement('foo(2,#)', [eOne], 'foo(2, 1);');
+  testStatement('foo(2,#)', [[eTrue,eOne]], 'foo(2, true, 1);');
+
+  testStatement('foo(#,3)', [[]], 'foo(3);');
+  testStatement('foo(#,3)', [[eOne]], 'foo(1, 3);');
+  testStatement('foo(#,3)', [eOne], 'foo(1, 3);');
+  testStatement('foo(#,3)', [[eTrue,eOne]], 'foo(true, 1, 3);');
+
+  testStatement('foo(2,#,3)', [[]], 'foo(2, 3);');
+  testStatement('foo(2,#,3)', [[eOne]], 'foo(2, 1, 3);');
+  testStatement('foo(2,#,3)', [eOne], 'foo(2, 1, 3);');
+  testStatement('foo(2,#,3)', [[eTrue,eOne]], 'foo(2, true, 1, 3);');
+
+  // Interpolated Literals
+  testStatement('a = {#: 1}', [eOne], 'a = {1: 1};');
+  // Maybe we should make this work?

[floitsch, 2014/04/22 16:11:18]

I don't think it will be necessary. but we will see.

[sra1, 2014/04/23 02:33:50]

I agree. It was not necessary.

+  testError('a = {#: 1}', [1], 'is not a Literal: 1');
+
+  // Interpolated parameter splicing.
+  testStatement('function foo(#){}', [new jsAst.Parameter('x')],
+      'function foo(x) {\n}');
+  testStatement('function foo(#){}', ['x'], 'function foo(x) {\n}');
+  testStatement('function foo(#){}', [[]], 'function foo() {\n}');
+  testStatement('function foo(#){}', [['x']], 'function foo(x) {\n}');
+  testStatement('function foo(#){}', [['x', 'y']], 'function foo(x, y) {\n}');
+
+
+  testStatement('a = #.#', [eVar,eOne], 'a = x[1];');
+  testStatement('a = #.#', [eVar,'foo'], 'a = x.foo;');
+
+  testStatement('function f(#) { return #.#; }', ['x', eVar,'foo'],
+      'function f(x) {\n  return x.foo;\n}');
+
+  testStatement('#.prototype.# = function(#) { return #.# };',
+      ['className', 'getterName', ['r', 'y'], 'r', 'fieldName'],
+      'className.prototype.getterName = function(r, y) {\n'
+      '  return r.fieldName;\n'
+      '};');
+
+  testStatement('function foo(r, #) { return #[r](#) }',
+      [['a', 'b'], 'g', ['b', 'a']],
+      'function foo(r, a, b) {\n  return g[r](b, a);\n}');
+}