anchor.diff:      // Ensure that [element] is an implementation element.
       element = element.implementation;
       // TODO(floitsch): we should be able to inline inside lazy initializers.
  -    if (!currentElement.isFunction()) return false;
  +    if (currentElement.isField()) return false;
       // TODO(floitsch): find a cleaner way to know if the element is a function
       // containing nodes.
       // [PartialFunctionElement]s are [FunctionElement]s that have [Node]s.
  -    if (element is !PartialFunctionElement) return false;
  -    // TODO(ngeoffray): try to inline generative constructors. They
  -    // don't have any body, which make it more difficult.
  +    if (element is !PartialFunctionElement
  +        && !element.isGenerativeConstructorBody()) {
  +      return false;
  +    }
       if (inliningStack.length > MAX_INLINING_DEPTH) return false;
       // Don't inline recursive calls. We use the same elements for the inlined
       // functions and would thus clobber our local variables.
  
positive.code:       if (inliningStack[i].function == element) return false;
      }
  
      PartialFunctionElement function = element;
      bool canBeInlined = backend.canBeInlined[function];
      if (canBeInlined == false) return false;
      assert(selector != null || Elements.isStaticOrTopLevel(element));
      if (selector != null && !selector.applies(function, compiler)) return false;
  
      // Don't inline operator== methods if the parameter can be null.
  
negative.code:     List<HInstruction> compiledArguments;
      bool isInstanceMember = function.isInstanceMember();
  
      if (isInstanceMember && !function.isGenerativeConstructorBody()) {
        assert(providedArguments != null);
        compiledArguments = new List<HInstruction>();
        compiledArguments.add(providedArguments[0]);
  