trufflesuite/truffle

import debugModule from "debug";
const debug = debugModule("debugger:controller:selectors"); //eslint-disable-line no-unused-vars

import { createSelectorTree, createLeaf } from "reselect-tree";
import { isSkippedNodeType } from "lib/helpers";
import * as Codec from "@truffle/codec";

import evm from "lib/evm/selectors";
import sourcemapping from "lib/sourcemapping/selectors";
import stacktrace from "lib/stacktrace/selectors";
import data from "lib/data/selectors";
import trace from "lib/trace/selectors";

/**
 * @private
 */
const identity = x => x;

function anyNonSkippedInRange(
  findOverlappingRange,
  node,
  sourceStart,
  sourceLength
) {
  let sourceEnd = sourceStart + sourceLength;
  return findOverlappingRange(sourceStart, sourceLength).some(
    ({ range, node }) =>
      isOldStyleAssembly(node) ||
      (sourceStart <= range[0] && //we want to go by starting line
        range[0] < sourceEnd &&
        !isSkippedNodeType(node))
    //NOTE: this doesn't actually catch everything skipped!  But doing better
    //is hard
  );
}

//catches InlineAssembly nodes from before 0.6.0.
//We want to be able to place breakpoints if something merely *overlaps*
//one of these, because, well, we can't really look inside and do better.
function isOldStyleAssembly(node) {
  return node.nodeType === "InlineAssembly" && !node.AST;
}

/**
 * controller
 */
const controller = createSelectorTree({
  /**
   * controller.state
   */
  state: state => state.controller,
  /**
   * controller.current
   */
  current: {
    /**
     * controller.current.functionDepth
     */
    functionDepth: createLeaf([sourcemapping.current.functionDepth], identity),

    /**
     * controller.current.executionContext
     */
    executionContext: createLeaf([evm.current.call], identity),

    /**
     * controller.current.willJump
     */
    willJump: createLeaf([evm.current.step.isJump], identity),

    /**
     * controller.current.onBaseConstructorDefinition
     */
    onBaseConstructorDefinition: createLeaf(
      [
        "./location/node",
        evm.current.context,
        sourcemapping.current.contractNode
      ],
      (node, context, contract) =>
        node &&
        node.nodeType === "FunctionDefinition" &&
        Codec.Ast.Utils.functionKind(node) === "constructor" &&
        context.contractId !== contract.id //when are we on a *base* constructor
      //definition?  precisely when the contract we're in according to the source
      //mapping is different from the contract whose bytecode is executing
      //(note that we don't need to check whether the compilation IDs are different,
      //since these will always be the same)
    ),

    /**
     * controller.current.location.onYulFunctionDefinitionWhileEntering
     */
    onYulFunctionDefinitionWhileEntering: createLeaf(
      [sourcemapping.current.onYulFunctionDefinitionWhileEntering],
      identity
    ),

    /**
     * controller.current.location
     */
    location: {
      /**
       * controller.current.location.sourceRange
       */
      sourceRange: createLeaf(
        [sourcemapping.current.sourceRange, "/current/trace/loaded"],
        (range, loaded) => (loaded ? range : null)
      ),

      /**
       * controller.current.location.source
       */
      source: createLeaf(
        [sourcemapping.current.source, "/current/trace/loaded"],
        (source, loaded) => (loaded ? source : null)
      ),

      /**
       * controller.current.location.node
       */
      node: createLeaf(
        [sourcemapping.current.node, "/current/trace/loaded"],
        (node, loaded) => (loaded ? node : null)
      ),

      /**
       * controller.current.location.astRef
       */
      astRef: createLeaf([data.current.astRef], identity),

      /**
       * controller.current.location.isMultiline
       */
      isMultiline: createLeaf(
        [sourcemapping.current.isMultiline, "/current/trace/loaded"],
        (raw, loaded) => (loaded ? raw : false)
      )
    },

    /**
     * controller.current.callstack
     */
    callstack: createLeaf([stacktrace.current.callstack.preupdated], identity),

    /**
     * controller.current.isAnyFrameGenerated
     *
     * This selector checks whether there are any generated sources
     * stackframes on the callstack.  We should regard ourselves
     * as still inside a generated source until there are none.
     * (We only consider generated sources here, not other sorts of internal
     * sources, to prevent potential problems.)
     */
    isAnyFrameGenerated: createLeaf(["./callstack"], callstack =>
      callstack.some(frame => frame.sourceIsGenerated)
    ),

    /**
     * controller.current.trace
     */
    trace: {
      /**
       * controller.current.trace.finished
       */
      finished: createLeaf([trace.finished], identity),

      /**
       * controller.current.trace.loaded
       */
      loaded: createLeaf([trace.loaded], identity)
    }
  },

  /**
   * controller.breakpoints (namespace)
   */
  breakpoints: {
    /**
     * controller.breakpoints (selector)
     */
    _: createLeaf(["/state"], state => state.breakpoints),

    /**
     * controller.breakpoints.resolver (selector)
     * this selector returns a function that adjusts a given line-based
     * breakpoint (on node-based breakpoints it simply returns the input) by
     * repeatedly moving it down a line until it lands on a line where there's
     * actually somewhere to break.  if no such line exists beyond that point, it
     * returns null instead.
     */
    resolver: createLeaf(
      [sourcemapping.views.sources, sourcemapping.views.overlapFunctions],
      (sources, functions) => breakpoint => {
        let adjustedBreakpoint;
        if (breakpoint.node === undefined) {
          let line = breakpoint.line;
          if (line < 0) {
            line = 0; //prevents hang if user enters large negative number
          }
          const { sourceId } = breakpoint;
          debug("breakpoint: %O", breakpoint);
          debug("sources: %o", sources);
          const { source, ast } = sources[sourceId];
          if (!ast) {
            //if no ast, don't attempt to adjust
            return breakpoint;
          }
          const findOverlappingRange = functions[sourceId];
          const lineLengths = source.split("\n").map(line => line.length);
          //why does neither JS nor lodash have a scan function like Haskell??
          //guess we'll have to do our scan manually
          let lineStarts = [0];
          for (let length of lineLengths) {
            lineStarts.push(lineStarts[lineStarts.length - 1] + length + 1);
            //+1 for the /n itself
          }
          debug(
            "line: %s",
            source.slice(lineStarts[line], lineStarts[line] + lineLengths[line])
          );
          while (
            line < lineLengths.length &&
            !anyNonSkippedInRange(
              findOverlappingRange,
              ast,
              lineStarts[line],
              lineLengths[line]
            )
          ) {
            debug("incrementing");
            line++;
          }
          if (line >= lineLengths.length) {
            adjustedBreakpoint = null;
          } else {
            adjustedBreakpoint = { ...breakpoint, line };
          }
        } else {
          debug("node-based breakpoint");
          adjustedBreakpoint = breakpoint;
        }
        return adjustedBreakpoint;
      }
    )
  },

  /**
   * controller.finished
   * deprecated alias for controller.current.trace.finished
   */
  finished: createLeaf(["/current/trace/finished"], finished => finished),

  /**
   * controller.isStepping
   */
  isStepping: createLeaf(["./state"], state => state.isStepping),

  /**
   * controller.stepIntoInternalSources
   */
  stepIntoInternalSources: createLeaf(
    ["./state"],
    state => state.stepIntoInternalSources
  )
});

export default controller;