if (seq.containsMethod(callee)) {
if (seq.containsMethod(singleImpl)) {
  protected OPT_InlineDecision shouldInlineInterfaceInternal(VM_Method caller,                                                             VM_Method callee,                                                             OPT_CompilationState state) {    OPT_Options opts = state.getOptions();    if (!opts.GUARDED_INLINE_INTERFACE)      return OPT_InlineDecision.NO("invokeinterface");          if (isForbiddenSpeculation(state.getRootMethod(), callee)) {      return OPT_InlineDecision.NO("Forbidden speculation");    }    VM_Method singleImpl =       OPT_InterfaceHierarchy.getUniqueImplementation(callee);    if (singleImpl != null) {      // Don't allow the static inline oracle to inline recursive calls.      // It isn't smart enough to do this effectively.      OPT_InlineSequence seq = state.getSequence();      if (seq.containsMethod(callee)) {        return OPT_InlineDecision.NO("recursive call");      }      // got a unique target in the current hierarchy. Attempt to inline it.      if (!hasBody(singleImpl))        return OPT_InlineDecision.NO("Illegal interface inline");            int inlinedSizeEstimate = inlinedSizeEstimate((VM_NormalMethod)singleImpl, state);      int cost = inliningActionCost(inlinedSizeEstimate, true, false, opts);      OPT_InlineDecision sizeCheck = sizeHeuristics(caller, singleImpl, state, cost);      if (sizeCheck != null) return sizeCheck;      // passed size heuristics. Do it.      OPT_InlineDecision d =         OPT_InlineDecision.guardedYES(singleImpl,                                      chooseGuard(caller, singleImpl, callee, state, false),                                       "static GUARDED interface inline passsed size checks");      return d;    } else {      return OPT_InlineDecision.NO(callee, "non-final interface method");    }  }