Support @NoInlining in the ssa-builder.

tests/compiler/dart2js/expect_annotations2_test.dart

Index: tests/compiler/dart2js/expect_annotations2_test.dart
diff --git a/tests/compiler/dart2js/expect_annotations2_test.dart b/tests/compiler/dart2js/expect_annotations2_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..4357c1de0238b5f239501c8b0c9338ad028f9ef4
--- /dev/null
+++ b/tests/compiler/dart2js/expect_annotations2_test.dart
@@ -0,0 +1,45 @@
+// 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 "package:async_helper/async_helper.dart";
+import 'memory_compiler.dart';
+
+const MEMORY_SOURCE_FILES = const {
+    'main.dart': '''
+        import 'package:expect/expect.dart';
+
+        @NoInline()
+        foo(y) => 49912344 + y;
+
+        class A {
+          @NoInline()
+          static bar(x) => x + 123455;
+
+          @NoInline()
+          gee(x, y) => x + y + 81234512;
+        }
+
+        main() {
+          print(foo(23412));
+          print(A.bar(87654));
+          print(new A().gee(1337, 919182));
+        }'''};
+
+void main() {
+  OutputCollector collector = new OutputCollector();
+  var compiler = compilerFor(MEMORY_SOURCE_FILES, outputProvider: collector);
+  asyncTest(() => compiler.run(Uri.parse('memory:main.dart')).then((_) {
+    // Simply check that the constants of the small functions are still in the
+    // output, and that we don't see the result of constant folding.
+    String jsOutput = collector.getOutput('', 'js');
+
+    Expect.isTrue(jsOutput.contains('49912344'));

[karlklose, 2015/02/20 09:48:15]

I don't think this way of testing is robust enough, since the type inferrer
could actually know that 'y' in 'foo' has that specific value.  Maybe you should
test that the code contains a call to 'foo' with the original argument?  Also,
when we think about specialization of methods, what does @NoInline mean? Are we
allowed to make a specific version?

[floitsch, 2015/02/20 10:52:56]

We will need to discuss the semantics of @NoInline for specialization when we
get there.
Yes: specialization could break the test, but then we should just fix it. Until
then this is a simple fast way to check that 'foo' hasn't been inlined.

+    Expect.isTrue(jsOutput.contains('123455'));
+    Expect.isTrue(jsOutput.contains('81234512'));
+    Expect.isFalse(jsOutput.contains('49935756'));
+    Expect.isFalse(jsOutput.contains('211109'));
+    Expect.isFalse(jsOutput.contains('82155031'));
+  }));
+}