Add "force inline" to internal annotations.

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");
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
   final Set<HInstruction> allocatedFixedLists = new Set<HInstruction>();
 }
 
 abstract class FunctionCompiler {
   /// Generates JavaScript code for `work.element`.
   jsAst.Fun compile(CodegenWorkItem work);
 
   Iterable get tasks;
 }
 
 /*
  * Invariants:
  *   canInline(function) implies canInline(function, insideLoop:true)
  *   !canInline(function, insideLoop: true) implies !canInline(function)
  */
 class FunctionInlineCache {
-  final Map<FunctionElement, bool> canBeInlined =
-      new Map<FunctionElement, bool>();
+  static const int _unknown = -1;
+  static const int _mustNotInline = 0;
+  // May-inline-in-loop means that the function may not be inlined outside loops
+  // but may be inlined in a loop.
+  static const int _mayInlineInLoopMustNotOutside = 1;
+  // The function can be inlined in a loop, but not outside.
+  static const int _canInlineInLoopMustNotOutside = 2;
+  // May-inline means that we know that it can be inlined inside a loop, but
+  // don't know about the general case yet.
+  static const int _canInlineInLoopMayInlineOutside = 3;
+  static const int _canInline = 4;
+  static const int _mustInline = 5;
 
-  final Map<FunctionElement, bool> canBeInlinedInsideLoop =
-      new Map<FunctionElement, bool>();
+  final Map<FunctionElement, int> _cachedDecisions =
+      new Map<FunctionElement, int>();
 
-  // Returns [:true:]/[:false:] if we have a cached decision.
-  // Returns [:null:] otherwise.
+  // Returns `true`/`false` if we have a cached decision.
+  // Returns `null` otherwise.
   bool canInline(FunctionElement element, {bool insideLoop}) {
-    return insideLoop ? canBeInlinedInsideLoop[element] : canBeInlined[element];
+    int decision = _cachedDecisions[element];
+
+    if (decision == null) {
+      decision = _unknown;
+    }
+
+    if (insideLoop) {
+      switch (decision) {
+        case _mustNotInline:
+          return false;
+
+        case _unknown:
+        case _mayInlineInLoopMustNotOutside:
+          // We know we can't inline outside a loop, but don't know for the
+          // loop case. Return `null` to indicate that we don't know yet.
+          return null;
+
+        case _canInlineInLoopMustNotOutside:
+        case _canInlineInLoopMayInlineOutside:
+        case _canInline:
+        case _mustInline:
+          return true;
+      }
+    } else {
+      switch (decision) {
+        case _mustNotInline:
+        case _mayInlineInLoopMustNotOutside:
+        case _canInlineInLoopMustNotOutside:
+          return false;
+
+        case _unknown:
+        case _canInlineInLoopMayInlineOutside:
+          // We know we can inline inside a loop, but don't know for the
+          // non-loop case. Return `null` to indicate that we don't know yet.
+          return null;
+
+        case _canInline:
+        case _mustInline:
+          return true;
+      }
+    }
+
+    // Quiet static checker.
+    return null;
   }
 
   void markAsInlinable(FunctionElement element, {bool insideLoop}) {
+    int oldDecision = _cachedDecisions[element];
+
+    if (oldDecision == null) {
+      oldDecision = _unknown;
+    }
+
     if (insideLoop) {
-      canBeInlinedInsideLoop[element] = true;
+      switch (oldDecision) {
+        case _mustNotInline:
+          throw new SpannableAssertionFailure(element,
+              "Can't mark a function as non-inlinable and inlinable at the "
+              "same time.");
+          break;

[Johnni Winther, 2015/03/04 09:19:16]

`break;` shouldn't be necessary for warning-freeness.

[floitsch, 2015/03/04 13:24:58]

Done.

+
+        case _unknown:
+          // We know that it can be inlined in a loop, but don't know about the
+          // non-loop case yet.
+          _cachedDecisions[element] = _canInlineInLoopMayInlineOutside;
+          break;
+
+        case _mayInlineInLoopMustNotOutside:

[Johnni Winther, 2015/03/04 09:19:16]

Shouldn't _mayInlineInLoopMustNotOutside but replaced by
_canInlineInLoopMustNotOutside? 

[floitsch, 2015/03/04 13:24:58]

good catch. thanks.
done.

+        case _canInlineInLoopMustNotOutside:
+        case _canInlineInLoopMayInlineOutside:
+        case _canInline:
+        case _mustInline:
+          // Do nothing.
+          break;
+      }
     } else {
-      // If we can inline a function outside a loop then we should do it inside
-      // a loop as well.
-      canBeInlined[element] = true;
-      canBeInlinedInsideLoop[element] = true;
+      switch (oldDecision) {
+        case _mustNotInline:
+        case _mayInlineInLoopMustNotOutside:
+        case _canInlineInLoopMustNotOutside:
+          throw new SpannableAssertionFailure(element,
+              "Can't mark a function as non-inlinable and inlinable at the "
+              "same time.");
+          break;

[Johnni Winther, 2015/03/04 09:19:16]

`break;` shouldn't be necessary for warning-freeness.

[floitsch, 2015/03/04 13:24:59]

Done.

+
+
+        case _unknown:
+        case _canInlineInLoopMayInlineOutside:
+          _cachedDecisions[element] = _canInline;
+          break;
+
+        case _canInline:
+        case _mustInline:
+          // Do nothing.
+          break;
+
+      }
     }
   }
 
-  void markAsNonInlinable(FunctionElement element, {bool insideLoop}) {
-    if (insideLoop == null || insideLoop) {
-      // If we can't inline a function inside a loop, then we should not inline
-      // it outside a loop either.
-      canBeInlined[element] = false;
-      canBeInlinedInsideLoop[element] = false;
+  void markAsNonInlinable(FunctionElement element, {bool insideLoop: true}) {
+    int oldDecision = _cachedDecisions[element];
+
+    if (oldDecision == null) {
+      oldDecision = _unknown;
+    }
+
+    if (insideLoop) {
+      switch (oldDecision) {
+        case _canInlineInLoopMustNotOutside:
+        case _canInlineInLoopMayInlineOutside:
+        case _canInline:
+        case _mustInline:
+          throw new SpannableAssertionFailure(element,
+              "Can't mark a function as non-inlinable and inlinable at the "
+              "same time.");
+          break;
+
+        case _mayInlineInLoopMustNotOutside:
+        case _unknown:
+          _cachedDecisions[element] = _mustNotInline;
+          break;
+
+        case _mustNotInline:
+          // Do nothing.
+          break;
+      }
     } else {
-      canBeInlined[element] = false;
+      switch (oldDecision) {
+        case _canInline:
+        case _mustInline:
+          throw new SpannableAssertionFailure(element,
+              "Can't mark a function as non-inlinable and inlinable at the "
+              "same time.");
+          break;

[Johnni Winther, 2015/03/04 09:19:16]

`break;` shouldn't be necessary for warning-freeness.

[floitsch, 2015/03/04 13:24:58]

Done.

+
+        case _unknown:
+          // We can't inline outside a loop, but we might still be allowed to do
+          // it outside.
+          _cachedDecisions[element] = _mayInlineInLoopMustNotOutside;
+          break;
+
+        case _canInlineInLoopMayInlineOutside:
+          // We already knew that the function could be inlined inside a loop,
+          // but didn't have information about the non-loop case. Now we know
+          // that it can't be inlined outside a loop.
+          _cachedDecisions[element] = _canInlineInLoopMustNotOutside;
+          break;
+
+        case _mayInlineInLoopMustNotOutside:
+        case _canInlineInLoopMustNotOutside:
+        case _mustNotInline:
+          // Do nothing.
+          break;
+      }
     }
   }
+
+  void markAsMustInline(FunctionElement element) {
+    _cachedDecisions[element] = _mustInline;
+  }
 }
 
 class JavaScriptBackend extends Backend {
   static final Uri DART_JS_HELPER = new Uri(scheme: 'dart', path: '_js_helper');
   static final Uri DART_INTERCEPTORS =
       new Uri(scheme: 'dart', path: '_interceptors');
   static final Uri DART_INTERNAL =
       new Uri(scheme: 'dart', path: '_internal');
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
       new Uri(scheme: 'dart', path: '_js_mirrors');
   static final Uri DART_JS_NAMES =
       new Uri(scheme: 'dart', path: '_js_names');
   static final Uri DART_EMBEDDED_NAMES =
       new Uri(scheme: 'dart', path: '_js_embedded_names');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
   static final Uri DART_HTML =
       new Uri(scheme: 'dart', path: 'html');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
 
-  /// The list of functions for classes in the [internalLibrary] that we want
-  /// to inline always.  Any function in this list must be inlinable with
-  /// respect to the conditions used in [InlineWeeder.canInline], except for
-  /// size/complexity heuristics.
-  static const Map<String, List<String>> ALWAYS_INLINE =
-      const <String, List<String>> {
-  };
-
   String get patchVersion => USE_NEW_EMITTER ? 'new' : 'old';
 
   final Annotations annotations = new Annotations();
 
-  /// List of [FunctionElement]s that we want to inline always.  This list is
-  /// filled when resolution is complete by looking up in [internalLibrary].
-  List<FunctionElement> functionsToAlwaysInline;
-
   /// Reference to the internal library to lookup functions to always inline.
   LibraryElement internalLibrary;
 
 
   /// Set of classes that need to be considered for reflection although not
   /// otherwise visible during resolution.
   Iterable<ClassElement> get classesRequiredForReflection {
     // TODO(herhut): Clean this up when classes needed for rti are tracked.
     return [closureClass, jsIndexableClass];
   }
@@ skipping 54 matching lines @@
   ClassElement typeLiteralClass;
   ClassElement mapLiteralClass;
   ClassElement constMapLiteralClass;
   ClassElement typeVariableClass;
   ConstructorElement mapLiteralConstructor;
   ConstructorElement mapLiteralConstructorEmpty;
 
   ClassElement noSideEffectsClass;
   ClassElement noThrowsClass;
   ClassElement noInlineClass;
+  ClassElement forceInlineClass;
   ClassElement irRepresentationClass;
 
   Element getInterceptorMethod;
 
   ClassElement jsInvocationMirrorClass;
 
   /// If [true], the compiler will emit code that writes the name of the current
   /// method together with its class and library to the console the first time
   /// the method is called.
   static const bool TRACE_CALLS = false;
@@ skipping 767 matching lines @@
       assert(traceHelper != null);
       enqueueInResolution(traceHelper, registry);
     }
     registerCheckedModeHelpers(registry);
   }
 
   onResolutionComplete() {
     super.onResolutionComplete();
     computeMembersNeededForReflection();
     rti.computeClassesNeedingRti();
-    computeFunctionsToAlwaysInline();
-  }
-
-  void computeFunctionsToAlwaysInline() {
-    functionsToAlwaysInline = <FunctionElement>[];
-    if (internalLibrary == null) return;
-
-    // Try to find all functions intended to always inline.  If their enclosing
-    // class is not resolved we skip the methods, but it is an error to mention
-    // a function or class that cannot be found.
-    for (String className in ALWAYS_INLINE.keys) {
-      ClassElement cls = find(internalLibrary, className);
-      if (cls.resolutionState != STATE_DONE) continue;
-      for (String functionName in ALWAYS_INLINE[className]) {
-        Element function = cls.lookupMember(functionName);
-        assert(invariant(cls, function is FunctionElement,
-            message: 'unable to find function $functionName in $className'));
-        functionsToAlwaysInline.add(function);
-      }
-    }
   }
 
   void registerGetRuntimeTypeArgument(Registry registry) {
     enqueueInResolution(getGetRuntimeTypeArgument(), registry);
     enqueueInResolution(getGetTypeArgumentByIndex(), registry);
     enqueueInResolution(getCopyTypeArguments(), registry);
   }
 
   void registerCallMethodWithFreeTypeVariables(
       Element callMethod,
@@ skipping 868 matching lines @@
 
         typeLiteralClass = findClass('TypeImpl');
         constMapLiteralClass = findClass('ConstantMap');
         typeVariableClass = findClass('TypeVariable');
 
         jsIndexingBehaviorInterface = findClass('JavaScriptIndexingBehavior');
 
         noSideEffectsClass = findClass('NoSideEffects');
         noThrowsClass = findClass('NoThrows');
         noInlineClass = findClass('NoInline');
+        forceInlineClass = findClass('ForceInline');
         irRepresentationClass = findClass('IrRepresentation');
 
         getIsolateAffinityTagMarker = findMethod('getIsolateAffinityTag');
 
         requiresPreambleMarker = findMethod('requiresPreamble');
       } else if (uri == DART_JS_MIRRORS) {
         disableTreeShakingMarker = find(library, 'disableTreeShaking');
         preserveMetadataMarker = find(library, 'preserveMetadata');
         preserveUrisMarker = find(library, 'preserveUris');
         preserveLibraryNamesMarker = find(library, 'preserveLibraryNames');
@@ skipping 436 matching lines @@
   }
 
   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 hasForceInline = 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;
-      if (cls == noInlineClass) {
+      if (cls == forceInlineClass) {
+        hasForceInline = true;
+        if (VERBOSE_OPTIMIZER_HINTS) {
+          compiler.reportHint(element,
+              MessageKind.GENERIC,
+              {'text': "Must inline"});
+        }
+        inlineCache.markAsMustInline(element);
+      } else if (cls == noInlineClass) {
         hasNoInline = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           compiler.reportHint(element,
               MessageKind.GENERIC,
               {'text': "Cannot inline"});
         }
         inlineCache.markAsNonInlinable(element);
       } else if (cls == noThrowsClass) {
         hasNoThrows = true;
         if (!Elements.isStaticOrTopLevelFunction(element)) {
@@ skipping 10 matching lines @@
       } else if (cls == noSideEffectsClass) {
         hasNoSideEffects = true;
         if (VERBOSE_OPTIMIZER_HINTS) {
           compiler.reportHint(element,
               MessageKind.GENERIC,
               {'text': "Has no side effects"});
         }
         compiler.world.registerSideEffectsFree(element);
       }
     }
+    if (hasForceInline && hasNoInline) {
+      compiler.internalError(element,
+          "@ForceInline() must not be used with @NoInline.");
+    }
     if (hasNoThrows && !hasNoInline) {
       compiler.internalError(element,
           "@NoThrows() should always be combined with @NoInline.");
     }
     if (hasNoSideEffects && !hasNoInline) {
       compiler.internalError(element,
           "@NoSideEffects() should always be combined with @NoInline.");
     }
     if (element == invokeOnMethod) {
       compiler.enabledInvokeOn = true;
@@ skipping 330 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);
 }