Report any diagnostic that might have been deferred by previous calls of report().
769892
public void reportDeferredDiagnostic() {
        if (deferredDiagnosticKind != null) {
            if (deferredDiagnosticArg == null)
                logMandatoryNote(deferredDiagnosticSource, deferredDiagnosticKind.getKey(prefix));
            else
                logMandatoryNote(deferredDiagnosticSource, deferredDiagnosticKind.getKey(prefix), deferredDiagnosticArg);

            if (!verbose)
                logMandatoryNote(deferredDiagnosticSource, prefix + ".recompile");
        }
    }
1350330
private void report(Diagnostic.Kind k, String msg) {
        initReporter();
        reporter.print(k, msg);
    }
239596
protected function _resolve()
    {
        if (!$this->_deferred) {
            return;
        }
        $data = $this->_deferred;

        $instance = $data['instance'];
        $this->_not = $data['not'];
        $boolean = $instance->resolve();
        $data['description'] = $instance->description();
        $data['backtrace'] = $instance->backtrace();
        $this->_log($boolean, $data);

        $this->_deferred = null;
    }
813377
Type checkSpeculative(DiagnosticPosition pos, Type t, ResultInfo resultInfo) {
        if (t.hasTag(DEFERRED)) {
            return ((DeferredType)t).check(resultInfo);
        } else {
            return resultInfo.check(pos, t);
        }
    }
1344336
public void showReportProblem() {
    if (!isEnabled) {
      return;
    }
    final Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
      @Override
      public void run() {
        show(getContext().getString(R.string.report_problem),
          NavigationConstants.ALERT_VIEW_PROBLEM_DURATION, true);
      }
    }, THREE_SECOND_DELAY_IN_MILLIS);
  }
867482
public void afterCompletion(int status) {
        for (DeferredEventNotification<?> notification : notifications) {
            if (!notification.isBefore() && notification.getStatus().matches(status)) {
                notification.run();
            }
        }
    }
1304859
function report (ex) {
            var args = _slice.call(arguments, 1);
            if (lastExceptionStack) {
                if (lastException === ex) {
                    return; // already caught by an inner catch block, ignore
                } else {
                    var s = lastExceptionStack;
                    lastExceptionStack = null;
                    lastException = null;
                    notifyHandlers.apply(null, [s, null].concat(args));
                }
            }

            var stack = TraceKit.computeStackTrace(ex);
            lastExceptionStack = stack;
            lastException = ex;

            // If the stack trace is incomplete, wait for 2 seconds for
            // slow slow IE to see if onerror occurs or not before reporting
            // this exception; otherwise, we will end up with an incomplete
            // stack trace
            window.setTimeout(function() {
                if (lastException === ex) {
                    lastExceptionStack = null;
                    lastException = null;
                    notifyHandlers.apply(null, [stack, null].concat(args));
                }
            }, (stack.incomplete ? 2000 : 0));

            throw ex; // re-throw to propagate to the top level (and cause window.onerror)
        }
786611
public void reportError(Throwable t) {
		// set the exception, if it is the first (and the exception is non null)
		if (t != null && exception.compareAndSet(null, t) && toInterrupt != null) {
			toInterrupt.interrupt();
		}
	}
106578
private void reportException(int s) {
        Throwable ex = ((s == CANCELLED) ?  new CancellationException() :
                        (s == EXCEPTIONAL) ? getThrowableException() :
                        null);
        if (ex != null)
            U.throwException(ex);
    }
428613
void reportError(Throwable throwable) {
    if (logger != null)
      logger.error("Timer reported error", throwable);
    status = "Thread blocked on error: " + throwable;
    error_skips = error_factor;
  }
397834
private void reportBugs() {
        Iterator<Map.Entry<Integer, Map<JavaClass, List<MethodInfo>>>> it = parameterDefiners.entrySet().iterator();
        while (it.hasNext()) {
            try {
                Map.Entry<Integer, Map<JavaClass, List<MethodInfo>>> entry = it.next();

                Integer reg = entry.getKey();
                if (!usedParameters.get(reg.intValue())) {
                    it.remove();
                    continue;
                }
                Map<JavaClass, List<MethodInfo>> definers = entry.getValue();
                definers.remove(objectClass);
                if (definers.size() > 1) {
                    removeInheritedInterfaces(definers);
                }

                if ((definers.size() == 1) && !hasOverloadedMethod()) {

                    String name = "";
                    LocalVariableTable lvt = getMethod().getLocalVariableTable();
                    if (lvt != null) {
                        LocalVariable lv = lvt.getLocalVariable(reg.intValue(), 0);
                        if (lv != null) {
                            name = lv.getName();
                        }
                    }
                    int parm = reg.intValue();
                    if (!methodIsStatic) {
                        parm--;
                    }

                    parm++; // users expect 1 based parameters

                    String infName = definers.keySet().iterator().next().getClassName();
                    bugReporter.reportBug(
                            new BugInstance(this, BugType.OCP_OVERLY_CONCRETE_PARAMETER.name(), NORMAL_PRIORITY)
                                    .addClass(this).addMethod(this).addSourceLine(this, 0)
                                    .addString(getCardinality(parm) + " parameter '" + name + "' could be declared as "
                                            + infName + " instead"));
                }
            } catch (ClassNotFoundException e) {
                bugReporter.reportMissingClass(e);
            }
        }
    }
93280
@Override
    public void report() {
        for (Map.Entry<FQMethod, MethodInfo> entry : Statistics.getStatistics()) {
            MethodInfo mi = entry.getValue();

            int declaredAccess = mi.getDeclaredAccess();
            if ((declaredAccess & Const.ACC_PRIVATE) != 0) {
                continue;
            }

            if (mi.wasCalledPublicly() || !mi.wasCalled()) {
                continue;
            }

            FQMethod key = entry.getKey();

            String methodName = key.getMethodName();
            if (isGetterSetter(methodName, key.getSignature())) {
                continue;
            }

            if (isOverlyPermissive(declaredAccess) && !isConstrainedByInterface(key)) {
                try {
                    String clsName = key.getClassName();
                    if (!isDerived(Repository.lookupClass(clsName), key)) {

                        BugInstance bi = new BugInstance(this, BugType.OPM_OVERLY_PERMISSIVE_METHOD.name(), LOW_PRIORITY).addClass(clsName).addMethod(clsName,
                                key.getMethodName(), key.getSignature(), (declaredAccess & Const.ACC_STATIC) != 0);

                        String descr = String.format("- Method declared %s but could be declared %s", getDeclaredAccessValue(declaredAccess),
                                getRequiredAccessValue(mi));
                        bi.addString(descr);

                        bugReporter.reportBug(bi);
                    }
                } catch (ClassNotFoundException cnfe) {
                    bugReporter.reportMissingClass(cnfe);
                }
            }
        }
    }
9873
def report_and_raise(probe_name, probe_result, failure_msg):
    """"""
    log.info('%s? %s' % (probe_name, probe_result))
    if not probe_result:
        raise exceptions.ProbeException(failure_msg)
    else:
        return True
216669
public void requestCompleted (T result)
    {
        if (_chain != null) {
            _chain.requestCompleted(result);

        } else if (_invChain instanceof InvocationService.ResultListener) {
            ((InvocationService.ResultListener)_invChain).requestProcessed(result);

        } else if (_invChain instanceof InvocationService.ConfirmListener) {
            ((InvocationService.ConfirmListener)_invChain).requestProcessed();
        }
    }
899202
public void handleSuccess ()
    {
        if (_listener instanceof InvocationService.ConfirmListener) {
            reportRequestProcessed();
        } else if (_listener instanceof InvocationService.ResultListener && _resultSet) {
            reportRequestProcessed(_result);
        }
    }
533930
function done(failures, fn, reportersWithDone, waitFor = identity) {
  const count = reportersWithDone.length;
  const waitReporter = waitOn((r, f) => r.done(failures, f));
  const progress = v => debug('Awaiting on %j reporters to invoke done callback.', count - v);
  promiseProgress(reportersWithDone.map(waitReporter), progress)
    .then(() => {
      debug('All reporters invoked done callback.');
    })
    .then(waitFor)
    .then(() => fn && fn(failures));
}
85727
def notify
      if reports.any?
        @notifiers.each do |notifier, options|
          # .dup is NOT reliable
          options_copy = Marshal.load(Marshal.dump(options))
          notifier.new(options_copy).notify(self)
        end
      end
    end