Support @NoInlining in the ssa-builder.

pkg/compiler/lib/src/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 const bool USE_CPS_IR = const bool.fromEnvironment("USE_CPS_IR");
 
@@ skipping 2287 matching lines @@
               new CodegenRegistry(compiler,
                   dependency.annotatedElement.analyzableElement.treeElements));
         }
         metadataConstants.clear();
       }
     }
     return true;
   }
 
   void onElementResolved(Element element, TreeElements elements) {
+    if (element.isFunction && annotations.noInline(element)) {
+      inlineCache.markAsNonInlinable(element);
+    }
+
     LibraryElement library = element.library;
     if (!library.isPlatformLibrary && !library.canUseNative) return;
     bool hasNoInline = false;
     bool hasNoThrows = false;
     bool hasNoSideEffects = false;
     for (MetadataAnnotation metadata in element.metadata) {
       metadata.ensureResolved(compiler);
       if (!metadata.constant.value.isConstructedObject) continue;
       ObjectConstantValue value = metadata.constant.value;
       ClassElement cls = value.type.element;
@@ skipping 105 matching lines @@
       enqueue(enqueuer, getStreamIteratorConstructor(), registry);
     }
   }
 }
 
 /// Handling of special annotations for tests.
 class Annotations {
   static final Uri PACKAGE_EXPECT =
       new Uri(scheme: 'package', path: 'expect/expect.dart');
 
-  ClassElement expectNoInliningClass;
+  ClassElement expectNoInlineClass;
   ClassElement expectTrustTypeAnnotationsClass;
   ClassElement expectAssumeDynamicClass;
 
   void onLibraryScanned(LibraryElement library) {
     if (library.canonicalUri == PACKAGE_EXPECT) {
-      expectNoInliningClass = library.find('NoInlining');
+      expectNoInlineClass = library.find('NoInline');
       expectTrustTypeAnnotationsClass = library.find('TrustTypeAnnotations');
       expectAssumeDynamicClass = library.find('AssumeDynamic');
-      if (expectNoInliningClass == null ||
+      if (expectNoInlineClass == null ||
           expectTrustTypeAnnotationsClass == null ||
           expectAssumeDynamicClass == null) {
         // This is not the package you're looking for.
-        expectNoInliningClass = null;
+        expectNoInlineClass = null;
         expectTrustTypeAnnotationsClass = null;
         expectAssumeDynamicClass = null;
       }
     }
   }
 
   /// Returns `true` if inlining is disabled for [element].
-  bool noInlining(Element element) {
-    return _hasAnnotation(element, expectNoInliningClass);
+  bool noInline(Element element) {
+    // TODO(floitsch): restrict to test directory.
+    return _hasAnnotation(element, expectNoInlineClass);
   }
 
   /// Returns `true` if parameter and returns types should be trusted for
   /// [element].
   bool trustTypeAnnotations(Element element) {
     return _hasAnnotation(element, expectTrustTypeAnnotationsClass);
   }
 
   /// Returns `true` if inference of parameter types is disabled for [element].
   bool assumeDynamic(Element element) {
@@ skipping 215 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }