JSAutoRealm ar(cx, obj);
if (!JS_DefineDebuggerObject(cx, obj)) {
  return NS_ERROR_FAILURE;
} // after: clang-format

MOZ_NO_DANGLING_ON_TEMPORARIES int* get() &&
{
    return nullptr;
}                                                       // mozilla-dangling-on-temporary
MOZ_NO_DANGLING_ON_TEMPORARIES int test() { return 0; } // mozilla-dangling-on-temporary

HandleObject obj,
HandleId id,

}
return ReportValueErrorFlags(
  cx, flags, code_, JSDVG_IGNORE_STACK, val, nullptr, propName.ptr(), nullptr);

for (float x = 0.1f; x <= 1.0f; x += 0.1f) {} // clang-analyzer-security.FloatLoopCounter
^

int y = 0;
if (x < y)
    ; // misc-suspicious-semicolon

{
    x++;

x = 1; // clang-analyzer-deadcode.DeadStores
^

std::map<int, std::vector<std::string>> my_map;
for (const std::pair<int, std::vector<std::string>>& p : my_map) {
} // performance-implicit-conversion-in-loop

return fun->isBoundFunction() ? fun->getBoundFunctionTarget() : nullptr;

: cx_(cx)
, oldRealm_(cx->realm())

                                       JSObject* targetOrNull
                                         MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
: cx_(cx)
, oldRealm_(cx->realm())

// Currently, we only collect nursery during idle time.
return rt->gc.nursery().needIdleTimeCollection();

GCRuntime& gc = rt->gc;
if (gc.nursery().needIdleTimeCollection()) {
    gc.minorGC(JS::gcreason::IDLE_TIME_COLLECTION);
}

if (!args.get(0).isString()) {
    JS_ReportErrorNumberASCII(cx,
                              GetErrorMessage,
                              nullptr,
                              JSMSG_NOT_EXPECTED_TYPE,

"\"string\", \"number\", or \"default\"",
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
R"("string", "number", or "default")"

HandleObject obj,
HandleObject parent_proto,
const JSClass* clasp,
JSNative constructor,
unsigned nargs,
const JSPropertySpec* ps,
const JSFunctionSpec* fs,
const JSPropertySpec* static_ps,
const JSFunctionSpec* static_fs)

assertSameCompartment(cx, obj, parent_proto);
return InitClass(
  cx, obj, parent_proto, Valueify(clasp), constructor, nargs, ps, fs, static_ps, static_fs);

HandleObject obj,
HandleId id,
Handle<PropertyDescriptor> desc,
ObjectOpResult& result)

HandleObject obj,
const char* name,
HandleValue value,

HandleObject obj,
const char16_t* name,
size_t namelen,

HandleObject obj,
const char16_t* name,
size_t namelen,
HandleValue value,
unsigned attrs)

HandleObject obj,
const char16_t* name,
size_t namelen,
HandleObject valueArg,
unsigned attrs)

HandleObject obj,
const char16_t* name,
size_t namelen,
HandleString valueArg,
unsigned attrs)

HandleObject obj,
uint32_t index,
HandleObject getter,
HandleObject setter,
unsigned attrs)

HandleObject obj,
uint32_t index,
HandleObject valueArg,

HandleValue fval,
HandleObject newTarget,
const JS::HandleValueArray& args,

HandleValue fval,
const JS::HandleValueArray& args,

HandleObject obj,
HandleId id,
const char* getterName,
const char* setterName,

if (ps->isSelfHosted()) {
    if (!DefineSelfHostedProperty(cx,
                                  obj,
                                  id,

RootedValue funVal(cx);
if (!GlobalObject::getSelfHostedFunction(
      cx, cx->global(), shName, name, fs->nargs, &funVal)) {

if (CanReuseScriptForClone(cx->realm(), fun, env)) {
// If the script is to be reused, either the script can already handle
// non-syntactic scopes, or there is only the standard global lexical
// scope.

HandleObject funobj,
AutoObjectVector& envChain)

  : fp_(nullptr)
{
}

return mallocSizeOf(filename_) + mallocSizeOf(sourceMapURL_) +

: ReadOnlyCompileOptions()
, elementRoot(cx)
, elementAttributeNameRoot(cx)
, introductionScriptRoot(cx)

return ::Compile(
  cx, options, reinterpret_cast<const char*>(buffer.begin()), buffer.length(), script);

const ReadOnlyCompileOptions& options,
const char* bytes,
size_t length,
JS::MutableHandleScript script)

const ReadOnlyCompileOptions& options,
FILE* file,
JS::MutableHandleScript script)

const ReadOnlyCompileOptions& options,
const char* filename,
JS::MutableHandleScript script)

const ReadOnlyCompileOptions& optionsArg,
SourceBufferHolder& srcBuf,
JS::MutableHandleScript script)

const ReadOnlyCompileOptions& optionsArg,
const char* bytes,
size_t length,
JS::MutableHandleScript script)

const ReadOnlyCompileOptions& optionsArg,
FILE* file,
JS::MutableHandleScript script)

Compile,
Decode,
DecodeBinAST

TranscodeSources& sources,
OffThreadCompileCallback callback,
void* callbackData)

RootedScriptSourceObject sourceObject(
  cx, frontend::CreateScriptSourceObject(cx, options, mozilla::Nothing()));

fun.set(NewScriptedFunction(cx,
                            0,
                            JSFunction::INTERPRETED_NORMAL,

/* proto = */ nullptr,
gc::AllocKind::FUNCTION,
TenuredObject,

const ReadOnlyCompileOptions& options,
const char* name,
unsigned nargs,
const char* const* argnames,
SourceBufferHolder& srcBuf,
MutableHandleFunction fun)

const ReadOnlyCompileOptions& options,
const char* name,
unsigned nargs,
const char* const* argnames,
const char16_t* chars,
size_t length,
MutableHandleFunction fun)

const ReadOnlyCompileOptions& optionsArg,
SourceBufferHolder& srcBuf,
MutableHandleValue rval)

const ReadOnlyCompileOptions& optionsArg,
const char16_t* chars,
size_t length,
MutableHandleValue rval)

SourceBufferHolder srcBuf(chars, length, SourceBufferHolder::NoOwnership);
RootedObject globalLexical(cx, &cx->global()->lexicalEnvironment());
return ::Evaluate(cx, ScopeKind::Global, globalLexical, optionsArg, srcBuf, rval);

const ReadOnlyCompileOptions& options,
const char* bytes,
size_t length,
MutableHandleValue rval)

JS::HandleValue value,
uint32_t* lineNumber,
uint32_t* columnNumber)

UniqueChars stackStr(
  reinterpret_cast<char*>(BuildUTF8StackString(cx, principals, stack).get()));

RootedObject resultPromise(cx);
if (!CallOriginalPromiseThenImpl(cx,
                                 promiseObj,
                                 onResolvedObj,
                                 onRejectedObj,
                                 &resultPromise,
                                 CreateDependentPromise::Always)) {

void* underlyingSource,

JS::HandleObject streamObj,

if (stream->mode() != JS::ReadableStreamMode::Default) {
    JS_ReportErrorNumberASCII(cx,
                              GetErrorMessage,
                              nullptr,

if (stream->mode() != JS::ReadableStreamMode::Byte) {
    JS_ReportErrorNumberASCII(cx,
                              GetErrorMessage,
                              nullptr,

} else {
    JS_ReportErrorNumberASCII(cx,
                              GetErrorMessage,
                              nullptr,

cx->asyncCauseForNewActivations = oldAsyncCause;
cx->asyncStackForNewActivations() = oldAsyncStack ? &oldAsyncStack->as<SavedFrame>() : nullptr;

const JS::AutoRequireNoGC& nogc,
JSString* str,

const JS::AutoRequireNoGC& nogc,
JSString* str,

JS_GetLatin1FlatStringChars(const JS::AutoRequireNoGC& nogc, JSFlatString* str)

MutableHandleValue vp,
HandleObject replacer,
HandleValue space,
JSONWriteCallback callback,
void* data)

CHECK_REQUEST(cx);
return ParseJSONWithReviver(
  cx, mozilla::Range<const char16_t>(chars, len), NullHandleValue, vp);

return stableChars.isLatin1()
         ? ParseJSONWithReviver(cx, stableChars.latin1Range(), reviver, vp)
         : ParseJSONWithReviver(cx, stableChars.twoByteRange(), reviver, vp);

JSErrorCallback errorCallback,
void* userRef,
const unsigned errorNumber,

va_start(ap, errorNumber);
ok =
  ReportErrorNumberVA(cx, flags, errorCallback, userRef, errorNumber, ArgumentsAreLatin1, ap);

unsigned flags,
JSErrorCallback errorCallback,
void* userRef,
const unsigned errorNumber,
...)

unsigned flags,
JSErrorCallback errorCallback,
void* userRef,
const unsigned errorNumber,
...)

return RegExpObject::create(
  cx, chars.get(), length, RegExpFlag(flags), cx->tempLifoAlloc(), GenericObject);

return ExecuteRegExpLegacy(cx, nullptr, obj.as<RegExpObject>(), input, indexp, test, rval);

size_t linebufLengthArg,

: notes_()

const unsigned errorNumber,
ErrorArgumentsType argumentsType,
va_list ap)

if (!ExpandErrorArgumentsVA(
      cx, errorCallback, userRef, errorNumber, nullptr, argumentsType, note.get(), ap)) {

const char* filename,
unsigned lineno,
unsigned column,
JSErrorCallback errorCallback,
void* userRef,
const unsigned errorNumber,
...)

case JSJITCOMPILER_FULL_DEBUG_CHECKS:
    jit::JitOptions.fullDebugChecks = !!value;
    break;

switch (opt) {
    case JSJITCOMPILER_BASELINE_WARMUP_TRIGGER:
        *valueOut = jit::JitOptions.baselineWarmUpThreshold;
        break;
    case JSJITCOMPILER_ION_WARMUP_TRIGGER:
        *valueOut = jit::JitOptions.forcedDefaultIonWarmUpThreshold.valueOr(
          jit::OptimizationInfo::CompilerWarmupThreshold);
        break;
    case JSJITCOMPILER_ION_FORCE_IC:
        *valueOut = jit::JitOptions.forceInlineCaches;
        break;
    case JSJITCOMPILER_ION_CHECK_RANGE_ANALYSIS:
        *valueOut = jit::JitOptions.checkRangeAnalysis;
        break;
    case JSJITCOMPILER_ION_ENABLE:
        *valueOut = JS::ContextOptionsRef(cx).ion();
        break;
    case JSJITCOMPILER_BASELINE_ENABLE:
        *valueOut = JS::ContextOptionsRef(cx).baseline();
        break;
    case JSJITCOMPILER_OFFTHREAD_COMPILATION_ENABLE:
        *valueOut = rt->canUseOffthreadIonCompilation();
        break;
    case JSJITCOMPILER_ASMJS_ATOMICS_ENABLE:
        *valueOut = jit::JitOptions.asmJSAtomicsEnable ? 1 : 0;
        break;
    case JSJITCOMPILER_WASM_FOLD_OFFSETS:
        *valueOut = jit::JitOptions.wasmFoldOffsets ? 1 : 0;
        break;

case JSJITCOMPILER_FULL_DEBUG_CHECKS:
    *valueOut = jit::JitOptions.fullDebugChecks ? 1 : 0;
    break;

default:
    return false;

/************************************************************************/

TranscodeBuffer& buffer,
JS::MutableHandleScript scriptp,

: JS::FirstSubsumedFrame(cx, cx->realm()->principals(), ignoreSelfHostedFrames)

JS::MutableHandleObject stackp,