24834367427

Committed 23 Apr 2026 12:09PM UTC coverage: 78.541% (+0.2%) from 78.391%

Build # 24834367427

Build Type

Pull #1893

github

Committed by

web-flow

Commit Message

Merge ab101147d into 715603479

Pull Request Pull Request #1893: Error Handling and Stringify Changes

Coverage Stats

3126 of 4197 branches covered (74.48%)

Branch coverage included in aggregate %.

801 of 975 new or added lines in 76 files covered. (82.15%)

20 existing lines in 11 files now uncovered.

7056 of 8767 relevant lines covered (80.48%)

173930.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.37

/src/cse-machine/utils.ts

import type es from 'estree';
import { isFunction } from 'lodash';

import * as errors from '../errors/errors';
import { RuntimeSourceError } from '../errors/base';
import type {
  Context,
  Environment,
  Node,
  NodeTypeToNode,
  StatementSequence,
  Value,
} from '../types';
import * as ast from '../utils/ast/astCreator';
import { isIdentifier, isImportDeclaration, isVariableDeclaration } from '../utils/ast/typeGuards';
import assert from '../utils/assert';
import { extractDeclarations } from '../utils/ast/helpers';
import Closure from './closure';
import { Continuation, isCallWithCurrentContinuation } from './continuations';
import Heap from './heap';
import * as instr from './instrCreator';
import type { Control } from './interpreter';
import {
  type AppInstr,
  type ControlItem,
  type EnvArray,
  type Instr,
  InstrType,
  type InstrTypeToInstr,
} from './types';

/**
 * Typeguard for Instr to distinguish between program statements and instructions.
 *
 * @param command A ControlItem
 * @returns true if the ControlItem is an instruction and false otherwise.
 */
export const isInstr = (command: ControlItem): command is Instr => {
  return 'instrType' in command;
};

/**
 * Typeguard for Node to distinguish between program statements and instructions.
 *
 * @param command A ControlItem
 * @returns true if the ControlItem is a Node or StatementSequence, false if it is an instruction.
 */
export const isNode = (command: ControlItem): command is Node => {
  return 'type' in command;
};

/**
 * Typeguard for esReturnStatement. To verify if a Node is an esReturnStatement.
 *
 * @param node a Node
 * @returns true if node is an esReturnStatement, false otherwise.
 */
export const isReturnStatement = (node: Node): node is es.ReturnStatement => {
  return node.type === 'ReturnStatement';
};

/**
 * Typeguard for esIfStatement. To verify if a Node is an esIfStatement.
 *
 * @param node a Node
 * @returns true if node is an esIfStatement, false otherwise.
 */
export const isIfStatement = (node: Node): node is es.IfStatement => {
  return node.type === 'IfStatement';
};

/**
 * Typeguard for esBlockStatement. To verify if a Node is a block statement.
 *
 * @param node a Node
 * @returns true if node is an esBlockStatement, false otherwise.
 */
export const isBlockStatement = (node: Node): node is es.BlockStatement => {
  return node.type === 'BlockStatement';
};

/**
 * Typeguard for StatementSequence. To verify if a ControlItem is a statement sequence.
 *
 * @param node a ControlItem
 * @returns true if node is a StatementSequence, false otherwise.
 */
export const isStatementSequence = (node: ControlItem): node is StatementSequence => {
  return isNode(node) && node.type === 'StatementSequence';
};

/**
 * Typeguard for esRestElement. To verify if a Node is a block statement.
 *
 * @param node a Node
 * @returns true if node is an esRestElement, false otherwise.
 */
export const isRestElement = (node: Node): node is es.RestElement => {
  return node.type == 'RestElement';
};

/**
 * Generate a unique id, for use in environments, arrays and closures.
 *
 * @param context the context used to provide the new unique id
 * @returns a unique id
 */
export const uniqueId = (context: Context): string => {
  return `${context.runtime.objectCount++}`;
};

/**
 * Returns whether `item` is an array with `id` and `environment` properties already attached.
 */
export const isEnvArray = (item: any): item is EnvArray => {
  return (
    Array.isArray(item) &&
    {}.hasOwnProperty.call(item, 'id') &&
    {}.hasOwnProperty.call(item, 'environment')
  );
};

/**
 * Returns whether `item` is a non-closure function that returns a stream.
 * If the function has been called already and we have the result, we can
 * pass it in here as a 2nd argument for stronger checking
 */
export const isStreamFn = (item: any, result?: any): result is [any, () => any] => {
  if (result == null || !Array.isArray(result) || result.length !== 2) return false;
  return (
    isFunction(item) &&
    !(item instanceof Closure) &&
    (item.name === 'stream' || {}.hasOwnProperty.call(item, 'environment'))
  );
};

/**
 * Adds the properties `id` and `environment` to the given array, and adds the array to the
 * current environment's heap. Adds the array to the heap of `envOverride` instead if it's defined.
 *
 * @param context the context used to provide the current environment and new unique id
 * @param array the array to attach properties to, and for addition to the heap
 */
export const handleArrayCreation = (
  context: Context,
  array: any[],
  envOverride?: Environment,
): void => {
  const environment = envOverride ?? currentEnvironment(context);
  // Both id and environment are non-enumerable so iterating
  // through the array will not return these values
  Object.defineProperties(array, {
    id: { value: uniqueId(context) },
    // Make environment writable as there are cases on the frontend where
    // environments of objects need to be modified
    environment: { value: environment, writable: true },
  });
  environment.heap.add(array as EnvArray);
};

/**
 * A helper function for handling sequences of statements.
 * Statements must be pushed in reverse order, and each statement is separated by a pop
 * instruction so that only the result of the last statement remains on stash.
 * Value producing statements have an extra pop instruction.
 *
 * @param seq Array of statements.
 * @returns Array of commands to be pushed into control.
 */
export const handleSequence = (seq: es.Program['body']): ControlItem[] => {
  const result: ControlItem[] = [];
  let valueProduced = false;
  for (const command of seq) {
    if (!isImportDeclaration(command)) {
      if (valueProducing(command)) {
        // Value producing statements have an extra pop instruction
        if (valueProduced) {
          result.push(instr.popInstr(command));
        } else {
          valueProduced = true;
        }
      }
      result.push(command);
    }
  }
  // Push statements in reverse order
  return result.reverse();
};

/**
 * This function is used for ConditionalExpressions and IfStatements, to create the sequence
 * of control items to be added.
 */
export const reduceConditional = (
  node: es.IfStatement | es.ConditionalExpression,
): ControlItem[] => {
  return [instr.branchInstr(node.consequent, node.alternate, node), node.test];
};

/**
 * To determine if a control item is value producing. JavaScript distinguishes value producing
 * statements and non-value producing statements.
 * Refer to https://sourceacademy.nus.edu.sg/sicpjs/4.1.2 exercise 4.8.
 *
 * @param command Control item to determine if it is value producing.
 * @returns true if it is value producing, false otherwise.
 */
export const valueProducing = (command: Node): boolean => {
  const type = command.type;
  return (
    type !== 'VariableDeclaration' &&
    type !== 'FunctionDeclaration' &&
    type !== 'ContinueStatement' &&
    type !== 'BreakStatement' &&
    type !== 'DebuggerStatement' &&
    (type !== 'BlockStatement' || command.body.some(valueProducing))
  );
};

/**
 * To determine if a control item changes the environment.
 * There is a change in the environment when
 *  1. pushEnvironment() is called when creating a new frame, if there are variable declarations.
 *     Called in Program, BlockStatement, and Application instructions.
 *  2. there is an assignment.
 *     Called in Assignment and Array Assignment instructions.
 *  3. a new object is created.
 *     Called in ExpressionStatement that contains an ArrowFunctionExpression, or an ArrowFunctionExpression
 *
 * @param command Control item to check against.
 * @returns true if it changes the environment, false otherwise.
 */
export const envChanging = (command: ControlItem): boolean => {
  if (isNode(command)) {
    const type = command.type;
    return (
      type === 'Program' ||
      type === 'BlockStatement' ||
      type === 'ArrowFunctionExpression' ||
      (type === 'ExpressionStatement' && command.expression.type === 'ArrowFunctionExpression')
    );
  } else if (isInstr(command)) {
    const type = command.instrType;
    return (
      type === InstrType.ENVIRONMENT ||
      type === InstrType.ARRAY_LITERAL ||
      type === InstrType.ASSIGNMENT ||
      type === InstrType.ARRAY_ASSIGNMENT ||
      (type === InstrType.APPLICATION && (command as AppInstr).numOfArgs > 0)
    );
  } else {
    // TODO deal with scheme control items
    // for now, as per the CSE machine paper,
    // we decide to ignore environment optimizations
    // for scheme control items :P
    return true;
  }
};

// TODO: This type guard does not seem to be doing what it thinks its doing
/**
 * To determine if the function is simple.
 * Simple functions contain a single return statement.
 *
 * @param node The function to check against.
 * @returns true if the function is simple, false otherwise.
 */
export const isSimpleFunction = (node: any) => {
  if (node.body.type !== 'BlockStatement' && node.body.type !== 'StatementSequence') {
    return true;
  } else {
    const block = node.body;
    return block.body.length === 1 && block.body[0].type === 'ReturnStatement';
  }
};

/**
 * Environments
 */

export const currentEnvironment = (context: Context) => context.runtime.environments[0];

export const createEnvironment = (
  context: Context,
  closure: Closure,
  args: Value[],
  callExpression: es.CallExpression,
): Environment => {
  const environment: Environment = {
    name: isIdentifier(callExpression.callee)
      ? callExpression.callee.name
      : (closure.declaredName ?? closure.functionName),
    tail: closure.environment,
    head: {},
    heap: new Heap(),
    id: uniqueId(context),
    callExpression: {
      ...callExpression,
      arguments: args.map(ast.primitive),
    },
  };
  closure.node.params.forEach((param, index) => {
    if (isRestElement(param)) {
      const array = args.slice(index);
      handleArrayCreation(context, array, environment);
      environment.head[(param.argument as es.Identifier).name] = array;
    } else {
      environment.head[(param as es.Identifier).name] = args[index];
    }
  });
  return environment;
};

export const popEnvironment = (context: Context) => context.runtime.environments.shift();

export const pushEnvironment = (context: Context, environment: Environment) => {
  context.runtime.environments.unshift(environment);
  context.runtime.environmentTree.insert(environment);
};

export const createBlockEnvironment = (
  context: Context,
  name = 'blockEnvironment',
): Environment => {
  return {
    name,
    tail: currentEnvironment(context),
    head: {},
    heap: new Heap(),
    id: uniqueId(context),
  };
};

export const createProgramEnvironment = (context: Context, isPrelude: boolean): Environment => {
  return createBlockEnvironment(context, isPrelude ? 'prelude' : 'programEnvironment');
};

/**
 * Variables
 */

const UNASSIGNED_CONST = Symbol('const declaration');
const UNASSIGNED_LET = Symbol('let declaration');

export function declareIdentifier(
  context: Context,
  name: string,
  node:
    | es.Declaration
    | es.ImportSpecifier
    | es.ImportDefaultSpecifier
    | es.ImportNamespaceSpecifier,
  environment: Environment,
  constant: boolean = false,
) {
  if (environment.head.hasOwnProperty(name)) {
    const descriptors = Object.getOwnPropertyDescriptors(environment.head);

    if (isVariableDeclaration(node)) {
      return handleRuntimeError(
        context,
        new errors.VariableRedeclarationError(node, name, !!descriptors[name].writable),
      );
    }

    assert(descriptors[name].writable === false, `${node.type} should not be reassignable`);

    return handleRuntimeError(
      context,
      new errors.VariableRedeclarationError(node, name, descriptors[name].writable),
    );
  }
  environment.head[name] = constant ? UNASSIGNED_CONST : UNASSIGNED_LET;
  return environment;
}

function declareVariables(
  context: Context,
  node: es.VariableDeclaration,
  environment: Environment,
) {
  // Retrieve declaration type from node
  const constant = node.kind === 'const';
  for (const id of extractDeclarations(node)) {
    declareIdentifier(context, id.name, node, environment, constant);
  }
}

export function declareFunctionsAndVariables(
  context: Context,
  node: es.BlockStatement | es.Program,
  environment: Environment,
) {
  for (const statement of node.body) {
    switch (statement.type) {
      case 'VariableDeclaration':
        declareVariables(context, statement, environment);
        break;
      case 'FunctionDeclaration':
        // FunctionDeclaration is always of type constant
        declareIdentifier(context, statement.id.name, statement, environment, true);
        break;
    }
  }
}

export function defineVariable(
  context: Context,
  name: string,
  value: Value,
  constant = false,
  node:
    | es.VariableDeclaration
    | es.ImportSpecifier
    | es.ImportDefaultSpecifier
    | es.ImportNamespaceSpecifier
    | es.FunctionDeclaration,
) {
  const environment = currentEnvironment(context);

  if (environment.head[name] !== UNASSIGNED_CONST && environment.head[name] !== UNASSIGNED_LET) {
    return handleRuntimeError(
      context,
      new errors.VariableRedeclarationError(node, name, !constant),
    );
  }

  if (constant && value instanceof Closure) {
    value.declaredName = name;
  }

  Object.defineProperty(environment.head, name, {
    value,
    writable: !constant,
    enumerable: true,
  });

  return environment;
}

export const getVariable = (context: Context, name: string, node: es.Identifier) => {
  let environment: Environment | null = currentEnvironment(context);
  while (environment) {
    if (environment.head.hasOwnProperty(name)) {
      if (
        environment.head[name] === UNASSIGNED_CONST ||
        environment.head[name] === UNASSIGNED_LET
      ) {
        return handleRuntimeError(context, new errors.UnassignedVariableError(name, node));
      } else {
        return environment.head[name];
      }
    } else {
      environment = environment.tail;
    }
  }
  return handleRuntimeError(context, new errors.UndefinedVariableError(name, node));
};

export const setVariable = (
  context: Context,
  name: string,
  value: any,
  node: es.AssignmentExpression,
) => {
  let environment: Environment | null = currentEnvironment(context);
  while (environment) {
    if (environment.head.hasOwnProperty(name)) {
      if (
        environment.head[name] === UNASSIGNED_CONST ||
        environment.head[name] === UNASSIGNED_LET
      ) {
        break;
      }
      const descriptors = Object.getOwnPropertyDescriptors(environment.head);
      if (descriptors[name].writable) {
        environment.head[name] = value;
        return undefined;
      }
      return handleRuntimeError(context, new errors.ConstAssignmentError(node, name));
    } else {
      environment = environment.tail;
    }
  }
  return handleRuntimeError(context, new errors.UndefinedVariableError(name, node));
};

export function handleRuntimeError(context: Context, error: RuntimeSourceError<any>) {
  context.errors.push(error);
  throw error;
}

export const checkNumberOfArguments = (
  context: Context,
  callee: Closure | Value,
  args: Value[],
  exp: es.CallExpression,
) => {
  if (callee instanceof Closure) {
    // User-defined or Pre-defined functions
    const params = callee.node.params;
    const hasVarArgs = params[params.length - 1]?.type === 'RestElement';
    if (hasVarArgs ? params.length - 1 > args.length : params.length !== args.length) {
      return handleRuntimeError(
        context,
        new errors.InvalidNumberOfArgumentsError(
          exp,
          hasVarArgs ? params.length - 1 : params.length,
          args.length,
          undefined,
          hasVarArgs,
        ),
      );
    }
  } else if (isCallWithCurrentContinuation(callee)) {
    // call/cc should have a single argument
    if (args.length !== 1) {
      return handleRuntimeError(
        context,
        new errors.InvalidNumberOfArgumentsError(exp, 1, args.length, undefined, false),
      );
    }
    return undefined;
  } else if (callee instanceof Continuation) {
    // Continuations have variadic arguments,
    // and so we can let it pass
    // TODO: in future, if we can somehow check the number of arguments
    // expected by the continuation, we can add a check here.
    return undefined;
  } else {
    // Pre-built functions
    const hasVarArgs = callee.minArgsNeeded != undefined;
    if (hasVarArgs ? callee.minArgsNeeded > args.length : callee.length !== args.length) {
      return handleRuntimeError(
        context,
        new errors.InvalidNumberOfArgumentsError(
          exp,
          hasVarArgs ? callee.minArgsNeeded : callee.length,
          args.length,
          undefined,
          hasVarArgs,
        ),
      );
    }
  }
  return undefined;
};

/**
 * This function can be used to check for a stack overflow.
 * The current limit is set to be a control size of 1.0 x 10^5, if the control
 * flows beyond this limit an error is thrown.
 * This corresponds to about 10mb of space according to tests ran.
 */
export const checkStackOverFlow = (context: Context, control: Control) => {
  if (control.size() > 100000) {
    const stacks: es.CallExpression[] = [];
    let counter = 0;
    for (
      let i = 0;
      counter < errors.MaximumStackLimitExceededError.MAX_CALLS_TO_SHOW &&
      i < context.runtime.environments.length;
      i++
    ) {
      if (context.runtime.environments[i].callExpression) {
        stacks.unshift(context.runtime.environments[i].callExpression!);
        counter++;
      }
    }
    handleRuntimeError(
      context,
      new errors.MaximumStackLimitExceededError(context.runtime.nodes[0], stacks),
    );
  }
};

/**
 * Checks whether an `if` statement returns in every possible branch.
 * @param body The `if` statement to be checked
 * @return `true` if every branch has a return statement, else `false`.
 */
export const hasReturnStatementIf = (statement: es.IfStatement): boolean => {
  let hasReturn = true;
  // Parser enforces that if/else have braces (block statement)
  hasReturn = hasReturn && hasReturnStatement(statement.consequent as es.BlockStatement);
  if (statement.alternate) {
    if (isIfStatement(statement.alternate)) {
      hasReturn = hasReturn && hasReturnStatementIf(statement.alternate);
    } else if (isBlockStatement(statement.alternate) || isStatementSequence(statement.alternate)) {
      hasReturn = hasReturn && hasReturnStatement(statement.alternate);
    }
  }
  return hasReturn;
};

/**
 * Checks whether a block returns in every possible branch.
 * @param body The block to be checked
 * @return `true` if every branch has a return statement, else `false`.
 */
export const hasReturnStatement = (block: es.BlockStatement | StatementSequence): boolean => {
  let hasReturn = false;
  for (const statement of block.body) {
    if (isReturnStatement(statement)) {
      hasReturn = true;
    } else if (isIfStatement(statement)) {
      // Parser enforces that if/else have braces (block statement)
      hasReturn = hasReturn || hasReturnStatementIf(statement);
    } else if (isBlockStatement(statement) || isStatementSequence(statement)) {
      hasReturn = hasReturn && hasReturnStatement(statement);
    }
  }
  return hasReturn;
};

function nodeVisitor(node: Node, type: Node['type']): boolean {
  switch (node.type) {
    case 'BlockStatement':
    case 'StatementSequence':
    case 'Program':
      return node.body.some(each => nodeVisitor(each, type));
    case 'IfStatement': {
      const { consequent, alternate } = node;
      if (nodeVisitor(consequent, type)) return true;

      return !!alternate && nodeVisitor(alternate, type);
    }
    default:
      return node.type === type;
  }
}

/**
 * Checks whether a block OR any of its child blocks has a `break` statement.
 * @param body The block to be checked
 * @return `true` if there is a `break` statement, else `false`.
 */
export const hasBreakStatement = (block: es.BlockStatement | StatementSequence): boolean => {
  return nodeVisitor(block, 'BreakStatement');
};

/**
 * Checks whether a block OR any of its child blocks has a `continue` statement.
 * @param body The block to be checked
 * @return `true` if there is a `continue` statement, else `false`.
 */
export const hasContinueStatement = (block: es.BlockStatement | StatementSequence): boolean => {
  return nodeVisitor(block, 'ContinueStatement');
};

/**
 * Utility type for getting all the keys of a ControlItem that have values
 * that are assignable to Nodes
 */
type GetNodeKeys<T extends ControlItem> = {
  [K in keyof T as T[K] extends Node | null | undefined ? K : never]: K;
};
/**
 * Extracts all the keys of a ControlItem that have values that are assignable to Nodes
 * as a union
 */
type KeysOfNodeProperties<T extends ControlItem> = GetNodeKeys<T>[keyof GetNodeKeys<T>];

/**
 * To provide a specification on how to calculate whether a ControlItem is env dependent or not:
 * - If a boolean is provided, that value is used directly
 * - If a string is provided, it is treated as the name of a property. `isEnvDependent` is then called on the value of that property.
 * - If an array of strings is provided, all values are treated as names of properties and `isEnvDependent` is called on all
 * their values
 * - If a function is provided, the function is called with the node and the return value is used
 */
type EnvDependentCalculator<T extends ControlItem> =
  | ((item: T) => boolean)
  | boolean
  | KeysOfNodeProperties<T>
  | KeysOfNodeProperties<T>[];

type EnvCalculators = {
  [K in Node['type']]?: EnvDependentCalculator<NodeTypeToNode<K>>;
} & {
  [K in InstrType]?: EnvDependentCalculator<InstrTypeToInstr<K>>;
};

const envCalculators: EnvCalculators = {
  ArrayExpression: ({ elements }) => elements.some(isEnvDependent),
  ArrowFunctionExpression: true,
  AssignmentExpression: ['left', 'right'],
  BlockStatement: ({ body }) => body.some(isEnvDependent),
  BinaryExpression: ['left', 'right'],
  BreakStatement: false,
  CallExpression: node => [node.callee, ...node.arguments].some(isEnvDependent),
  ConditionalExpression: ['alternate', 'consequent', 'test'],
  ContinueStatement: false,
  DebuggerStatement: false,
  ExpressionStatement: 'expression',
  ForStatement: ['body', 'init', 'test', 'update'],
  FunctionDeclaration: true,
  Identifier: true,
  IfStatement: ['alternate', 'consequent', 'test'],
  ImportDeclaration: ({ specifiers }) => specifiers.some(isEnvDependent),
  ImportDefaultSpecifier: true,
  ImportSpecifier: true,
  Literal: false,
  LogicalExpression: ['left', 'right'],
  MemberExpression: ['object', 'property'],
  Program: ({ body }) => body.some(isEnvDependent),
  ReturnStatement: 'argument',
  StatementSequence: ({ body }) => body.some(isEnvDependent),
  UnaryExpression: 'argument',
  VariableDeclaration: true,
  WhileStatement: ['body', 'test'],

  //Instruction
  [InstrType.APPLICATION]: true,
  [InstrType.ARRAY_ACCESS]: false,
  [InstrType.ARRAY_ASSIGNMENT]: false,
  [InstrType.ARRAY_LITERAL]: true,
  [InstrType.ASSIGNMENT]: true,
  [InstrType.BINARY_OP]: false,
  [InstrType.BRANCH]: ['alternate', 'consequent'],
  [InstrType.BREAK_MARKER]: false,
  [InstrType.CONTINUE]: false,
  [InstrType.CONTINUE_MARKER]: false,
  [InstrType.ENVIRONMENT]: false,
  [InstrType.MARKER]: false,
  [InstrType.POP]: false,
  [InstrType.RESET]: false,
  [InstrType.SPREAD]: false,
  [InstrType.UNARY_OP]: false,
  [InstrType.WHILE]: ['body', 'test'],
  [InstrType.FOR]: ['body', 'init', 'test', 'update'],
};
/**
 * Checks whether the evaluation of the given control item depends on the current environment.
 * The item is also considered environment dependent if its evaluation introduces
 * environment dependent items
 * @param item The control item to be checked
 * @return `true` if the item is environment depedent, else `false`.
 */

export function isEnvDependent(item: ControlItem | null | undefined): boolean {
  if (item === null || item === undefined) {
    return false;
  }

  // If result is already calculated, return it
  if (item.isEnvDependent !== undefined) {
    return item.isEnvDependent;
  }

  let calculator;
  if (isNode(item)) {
    calculator = envCalculators[item.type];
  } else if (isInstr(item)) {
    calculator = envCalculators[item.instrType];
  }

  switch (typeof calculator) {
    case 'boolean': {
      item.isEnvDependent = calculator;
      break;
    }
    case 'string': {
      // @ts-expect-error Indexing with an arbitrary index
      item.isEnvDependent = isEnvDependent(item[calculator]);
      break;
    }
    case 'function': {
      // @ts-expect-error Function parameter gets narrowed to never
      item.isEnvDependent = calculator(item);
      break;
    }
    case 'undefined': {
      item.isEnvDependent = false;
      break;
    }
    default: {
      if (!Array.isArray(calculator)) throw new Error(`Invalid setter for ${item}: ${calculator}`);

      // @ts-expect-error Indexing with an arbitrary index
      item.isEnvDependent = calculator.some(each => isEnvDependent(item[each]));
      break;
    }
  }

  return item.isEnvDependent;
}

source-academy / js-slang / 24834367427

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous