Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Firefox/devtools/client/debugger/src/actions/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 7 kB

Quelle preview.js Sprache: JAVA

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */

import { isConsole } from "../utils/preview";
import { getGrip, getFront } from "../utils/evaluation-result";

import {
  isLineInScope,
  isSelectedFrameVisible,
  getSelectedSource,
  getSelectedLocation,
  getSelectedFrame,
  getCurrentThread,
  getSelectedException,
  getSelectedTraceIndex,
  getAllTraces,
} from "../selectors/index";
import { features } from "../utils/prefs";

import { getMappedExpression } from "./expressions";
const {
  TRACER_FIELDS_INDEXES,
} = require("resource://devtools/server/actors/tracer.js");

async function findExpressionMatches(state, parserWorker, editor, tokenPos) {
  const location = getSelectedLocation(state);
  if (!location) {
    return [];
  }
  if (features.codemirrorNext) {
    return editor.findBestMatchExpressions(tokenPos);
  }

  let match = await parserWorker.findBestMatchExpression(
    location.source.id,
    tokenPos
  );
  if (!match) {
    // Fallback on expression from codemirror cursor,
    // if parser worker misses symbols or is unable to find a match.
    match = editor.getExpressionFromCoords(tokenPos);
    return match ? [match] : [];
  }
  return [match];
}

/**
* Get a preview object for the currently selected frame in the JS Tracer.
*
* @param {Object} target
*        The hovered DOM Element within CodeMirror rendering.
* @param {Object} tokenPos
*        The CodeMirror position object for the hovered token.
* @param {Object} editor
*        The CodeMirror editor object.
*/
export function getTracerPreview(target, tokenPos, editor) {
  return async thunkArgs => {
    const { getState, parserWorker } = thunkArgs;
    const selectedTraceIndex = getSelectedTraceIndex(getState());
    if (selectedTraceIndex == null) {
      return null;
    }

    const trace = getAllTraces(getState())[selectedTraceIndex];

    // We may be selecting a mutation trace, which doesn't expose any value,
    // so only consider method calls.
    if (trace[TRACER_FIELDS_INDEXES.TYPE] != "enter") {
      return null;
    }

    const matches = await findExpressionMatches(
      getState(),
      parserWorker,
      editor,
      tokenPos
    );
    if (!matches.length) {
      return null;
    }

    let { expression, location } = matches[0];
    const source = getSelectedSource(getState());
    if (location && source.isOriginal) {
      const thread = getCurrentThread(getState());
      const mapResult = await getMappedExpression(
        expression,
        thread,
        thunkArgs
      );
      if (mapResult) {
        expression = mapResult.expression;
      }
    }

    const argumentValues = trace[TRACER_FIELDS_INDEXES.ENTER_ARGS];
    const argumentNames = trace[TRACER_FIELDS_INDEXES.ENTER_ARG_NAMES];
    if (!argumentNames || !argumentValues) {
      return null;
    }

    const argumentIndex = argumentNames.indexOf(expression);
    if (argumentIndex == -1) {
      return null;
    }

    const result = argumentValues[argumentIndex];
    // Values are either primitives, or an Object Front
    const resultGrip = result?.getGrip ? result?.getGrip() : result;

    const root = {
      // Force updating the ObjectInspector when hovering same-name variable on another trace.
      // See ObjectInspector.getNodeKey.
      path: `${selectedTraceIndex}-${expression}`,
      contents: {
        value: resultGrip,
        front: getFront(result),
      },
    };
    return {
      previewType: "tracer",
      target,
      tokenPos,
      cursorPos: target.getBoundingClientRect(),
      expression,
      root,
      resultGrip,
    };
  };
}

/**
* Get a preview object for the currently paused frame, if paused.
*
* @param {Object} target
*        The hovered DOM Element within CodeMirror rendering.
* @param {Object} tokenPos
*        The CodeMirror position object for the hovered token.
* @param {Object} editor
*        The CodeMirror editor object.
*/
export function getPausedPreview(target, tokenPos, editor) {
  return async thunkArgs => {
    const { getState, client, parserWorker } = thunkArgs;
    if (
      !isSelectedFrameVisible(getState()) ||
      !isLineInScope(getState(), tokenPos.line)
    ) {
      return null;
    }

    const source = getSelectedSource(getState());
    if (!source) {
      return null;
    }
    const thread = getCurrentThread(getState());
    const selectedFrame = getSelectedFrame(getState());
    if (!selectedFrame) {
      return null;
    }
    const matches = await findExpressionMatches(
      getState(),
      parserWorker,
      editor,
      tokenPos
    );
    if (!matches.length) {
      return null;
    }

    let { expression, location } = matches[0];

    if (isConsole(expression)) {
      return null;
    }

    if (location && source.isOriginal) {
      const mapResult = await getMappedExpression(
        expression,
        thread,
        thunkArgs
      );
      if (mapResult) {
        expression = mapResult.expression;
      }
    }

    const { result, hasException, exception } = await client.evaluate(
      expression,
      {
        frameId: selectedFrame.id,
      }
    );

    // The evaluation shouldn't return an exception.
    if (hasException) {
      const errorClass = exception?.getGrip()?.class || "Error";
      throw new Error(
        `Debugger internal exception: Preview for <${expression}> threw a ${errorClass}`
      );
    }

    const resultGrip = getGrip(result);

    // Error case occurs for a token that follows an errored evaluation
    // https://github.com/firefox-devtools/debugger/pull/8056
    // Accommodating for null allows us to show preview for falsy values
    // line "", false, null, Nan, and more
    if (resultGrip === null) {
      return null;
    }

    // Handle cases where the result is invisible to the debugger
    // and not possible to preview. Bug 1548256
    if (
      resultGrip &&
      resultGrip.class &&
      typeof resultGrip.class === "string" &&
      resultGrip.class.includes("InvisibleToDebugger")
    ) {
      return null;
    }

    const root = {
      path: expression,
      contents: {
        value: resultGrip,
        front: getFront(result),
      },
    };

    return {
      previewType: "pause",
      target,
      tokenPos,
      cursorPos: target.getBoundingClientRect(),
      expression,
      root,
      resultGrip,
    };
  };
}

export function getExceptionPreview(target, tokenPos, editor) {
  return async ({ getState, parserWorker }) => {
    const matches = await findExpressionMatches(
      getState(),
      parserWorker,
      editor,
      tokenPos
    );
    if (!matches.length) {
      return null;
    }
    let exception;
    // Lezer might return multiple matches in certain scenarios.
    // Example: For this expression `[].inlineException()` is likely to throw an exception,
    // but if the user hovers over `inlineException` lezer finds 2 matches :
    // 1) `inlineException` for `PropertyName`,
    // 2) `[].inlineException()` for `MemberExpression`
    // Babel seems to only include the `inlineException`.
    for (const match of matches) {
      const tokenColumnStart = match.location.start.column + 1;
      exception = getSelectedException(
        getState(),
        tokenPos.line,
        tokenColumnStart
      );
      if (exception) {
        break;
      }
    }

    if (!exception) {
      return null;
    }

    return {
      target,
      tokenPos,
      cursorPos: target.getBoundingClientRect(),
      exception,
    };
  };
}

quality95%

¤ Dauer der Verarbeitung: 0.1 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.