feat(error): errors now point to the Node that caused or threw them. …

…Errors caused by the evaluated code itself such as ThrowStatements will produce ThrownError objects that point to the original error as well as the Node that caused or threw it. Fixes #8

src/index.ts

@@ -14,6 +14,7 @@ export {EvaluationError} from "./interpreter/error/evaluation-error/evaluation-e
 export {MissingCatchOrFinallyAfterTryError} from "./interpreter/error/missing-catch-or-finally-after-try-error/missing-catch-or-finally-after-try-error";
 export {ModuleNotFoundError} from "./interpreter/error/module-not-found-error/module-not-found-error";
 export {NotCallableError} from "./interpreter/error/not-callable-error/not-callable-error";
+export {ThrownError} from "./interpreter/error/thrown-error/thrown-error";
 export {PolicyError} from "./interpreter/error/policy-error/policy-error";
 export {UndefinedIdentifierError} from "./interpreter/error/undefined-identifier-error/undefined-identifier-error";
 export {UndefinedLeftValueError} from "./interpreter/error/undefined-left-value-error/undefined-left-value-error";

src/interpreter/environment/create-sanitized-environment.ts

@@ -22,7 +22,7 @@ import {isConsoleOperation} from "../policy/console/is-console-operation";
  * @param {ICreateSanitizedEnvironmentOptions} options
  * @return {IndexLiteral}
  */
-export function createSanitizedEnvironment ({policy, env}: ICreateSanitizedEnvironmentOptions): IndexLiteral {
+export function createSanitizedEnvironment ({policy, env, getCurrentNode}: ICreateSanitizedEnvironmentOptions): IndexLiteral {
 
 	const hook = (item: PolicyProxyHookOptions<any>) => {
 
@@ -31,27 +31,27 @@ export function createSanitizedEnvironment ({policy, env}: ICreateSanitizedEnvir
 		}
 
 		if (!policy.io.read && isIoRead(item)) {
-			throw new IoError({kind: "read"});
+			throw new IoError({kind: "read", node: getCurrentNode()});
 		}
 
 		if (!policy.io.write && isIoWrite(item)) {
-			throw new IoError({kind: "write"});
+			throw new IoError({kind: "write", node: getCurrentNode()});
 		}
 
 		if (!policy.process.exit && isProcessExitOperation(item)) {
-			throw new ProcessError({kind: "exit"});
+			throw new ProcessError({kind: "exit", node: getCurrentNode()});
 		}
 
 		if (!policy.process.exit && isProcessSpawnChildOperation(item)) {
-			throw new ProcessError({kind: "spawnChild"});
+			throw new ProcessError({kind: "spawnChild", node: getCurrentNode()});
 		}
 
 		if (!policy.network && isNetworkOperation(item)) {
-			throw new NetworkError({operation: stringifyPolicyTrapKindOnPath(item.kind, item.path)});
+			throw new NetworkError({operation: stringifyPolicyTrapKindOnPath(item.kind, item.path), node: getCurrentNode()});
 		}
 
 		if (policy.deterministic && isNonDeterministic(item)) {
-			throw new NonDeterministicError({operation: stringifyPolicyTrapKindOnPath(item.kind, item.path)});
+			throw new NonDeterministicError({operation: stringifyPolicyTrapKindOnPath(item.kind, item.path), node: getCurrentNode()});
 		}
 
 		return true;

src/interpreter/environment/i-create-sanitized-environment-options.ts

@@ -1,7 +1,9 @@
 import {IEvaluatePolicySanitized} from "../policy/i-evaluate-policy";
 import {IndexLiteral} from "../literal/literal";
+import {Node} from "typescript";
 
 export interface ICreateSanitizedEnvironmentOptions {
 	policy: IEvaluatePolicySanitized;
 	env: IndexLiteral;
+	getCurrentNode (): Node;
 }

src/interpreter/error/evaluation-error/evaluation-error.ts

@@ -1,11 +1,18 @@
 import {IEvaluationErrorOptions} from "./i-evaluation-error-options";
+import {Node} from "typescript";
 
 /**
  * A Base class for EvaluationErrors
  */
 export class EvaluationError extends Error {
-	constructor ({message}: IEvaluationErrorOptions = {}) {
+	/**
+	 * The node that caused or thew the error
+	 */
+	public readonly node: Node;
+
+	constructor ({node, message}: IEvaluationErrorOptions) {
 		super(message);
 		Error.captureStackTrace(this, this.constructor);
+		this.node = node;
 	}
 }

src/interpreter/error/evaluation-error/i-evaluation-error-options.ts

@@ -1,3 +1,6 @@
+import {Node} from "typescript";
+
 export interface IEvaluationErrorOptions {
+	node: Node;
 	message?: string;
 }

src/interpreter/error/missing-catch-or-finally-after-try-error/i-missing-catch-or-finally-after-try-error-options.ts

@@ -2,5 +2,5 @@ import {TryStatement} from "typescript";
 import {IEvaluationErrorOptions} from "../evaluation-error/i-evaluation-error-options";
 
 export interface IMissingCatchOrFinallyAfterTryErrorOptions extends IEvaluationErrorOptions {
-	statement: TryStatement;
+	node: TryStatement;
 }

src/interpreter/error/missing-catch-or-finally-after-try-error/missing-catch-or-finally-after-try-error.ts

@@ -8,11 +8,11 @@ import {IMissingCatchOrFinallyAfterTryErrorOptions} from "./i-missing-catch-or-f
 export class MissingCatchOrFinallyAfterTryError extends EvaluationError {
 	/**
 	 * The TryStatement that lacks a catch/finally block
+	 * @type {TryStatement}
 	 */
-	public readonly statement: TryStatement;
+	public readonly node: TryStatement;
 
-	constructor ({statement, message = `Missing catch or finally after try`}: IMissingCatchOrFinallyAfterTryErrorOptions) {
-		super({message});
-		this.statement = statement;
+	constructor ({node, message = `Missing catch or finally after try`}: IMissingCatchOrFinallyAfterTryErrorOptions) {
+		super({node, message});
 	}
 }

src/interpreter/error/module-not-found-error/module-not-found-error.ts

@@ -12,8 +12,8 @@ export class ModuleNotFoundError extends EvaluationError {
 	 */
 	public readonly path: string;
 
-	constructor ({path, message = `Module '${path}' could not be resolved'`}: IModuleNotFoundErrorOptions) {
-		super({message});
+	constructor ({path, node, message = `Module '${path}' could not be resolved'`}: IModuleNotFoundErrorOptions) {
+		super({message, node});
 		this.path = path;
 	}
 }

src/interpreter/error/not-callable-error/not-callable-error.ts

@@ -12,8 +12,8 @@ export class NotCallableError extends EvaluationError {
 	 */
 	public readonly value: Literal;
 
-	constructor ({value, message = `${stringifyLiteral(value)} is not a function'`}: INotCallableErrorOptions) {
-		super({message});
+	constructor ({value, node, message = `${stringifyLiteral(value)} is not a function'`}: INotCallableErrorOptions) {
+		super({message, node});
 		this.value = value;
 	}
 }

src/interpreter/error/policy-error/io-error/io-error.ts

@@ -12,8 +12,8 @@ export class IoError extends PolicyError {
 	 */
 	public readonly kind: keyof IEvaluateIOPolicy;
 
-	constructor ({kind, message = `${kind} operations are in violation of the policy`}: IIoErrorOptions) {
-		super({violation: "io", message});
+	constructor ({node, kind, message = `${kind} operations are in violation of the policy`}: IIoErrorOptions) {
+		super({violation: "io", message, node});
 		this.kind = kind;
 	}
 }

src/interpreter/error/policy-error/max-op-duration-exceeded-error/max-op-duration-exceeded-error.ts

@@ -10,8 +10,8 @@ export class MaxOpDurationExceededError extends PolicyError {
 	 */
 	public readonly duration: number;
 
-	constructor ({duration, message = `Maximum operation duration exceeded: ${duration}`}: IMaxOpDurationExceededErrorOptions) {
-		super({violation: "maxOpDuration", message});
+	constructor ({duration, node, message = `Maximum operation duration exceeded: ${duration}`}: IMaxOpDurationExceededErrorOptions) {
+		super({violation: "maxOpDuration", message, node});
 		this.duration = duration;
 	}
 }

src/interpreter/error/policy-error/max-ops-exceeded-error/max-ops-exceeded-error.ts

@@ -10,8 +10,8 @@ export class MaxOpsExceededError extends PolicyError {
 	 */
 	public readonly ops: number;
 
-	constructor ({ops, message = `Maximum ops exceeded: ${ops}`}: IMaxOpsExceededErrorOptions) {
-		super({violation: "maxOps", message});
+	constructor ({ops, node, message = `Maximum ops exceeded: ${ops}`}: IMaxOpsExceededErrorOptions) {
+		super({violation: "maxOps", message, node});
 		this.ops = ops;
 	}
 }

src/interpreter/error/policy-error/network-error/network-error.ts

@@ -11,8 +11,8 @@ export class NetworkError extends PolicyError {
 	 */
 	public readonly operation: string;
 
-	constructor ({operation, message = `The operation: '${operation}' is performing network activity. That is in violation of the policy`}: INetworkErrorOptions) {
-		super({violation: "deterministic", message});
+	constructor ({operation, node, message = `The operation: '${operation}' is performing network activity. That is in violation of the policy`}: INetworkErrorOptions) {
+		super({violation: "deterministic", message, node});
 
 		this.operation = operation;
 	}

src/interpreter/error/policy-error/non-deterministic-error/non-deterministic-error.ts

@@ -12,8 +12,8 @@ export class NonDeterministicError extends PolicyError {
 	 */
 	public readonly operation: string;
 
-	constructor ({operation, message = `The operation: '${operation}' is nondeterministic. That is in violation of the policy`}: INonDeterministicErrorOptions) {
-		super({violation: "deterministic", message});
+	constructor ({operation, node, message = `The operation: '${operation}' is nondeterministic. That is in violation of the policy`}: INonDeterministicErrorOptions) {
+		super({violation: "deterministic", message, node});
 
 		this.operation = operation;
 	}

src/interpreter/error/policy-error/policy-error.ts

@@ -12,8 +12,8 @@ export class PolicyError extends EvaluationError {
 	 */
 	public readonly violation: keyof IEvaluatePolicySanitized;
 
-	constructor ({violation, message}: IPolicyErrorOptions) {
-		super({message: `[${violation}]: ${message}`});
+	constructor ({violation, node, message}: IPolicyErrorOptions) {
+		super({node, message: `[${violation}]: ${message}`});
 		this.violation = violation;
 	}
 }

src/interpreter/error/policy-error/process-error/process-error.ts

@@ -12,8 +12,8 @@ export class ProcessError extends PolicyError {
 	 */
 	public readonly kind: keyof IEvaluateProcessPolicy;
 
-	constructor ({kind, message = `${kind} operations are in violation of the policy`}: IProcessErrorOptions) {
-		super({violation: "process", message});
+	constructor ({kind, node, message = `${kind} operations are in violation of the policy`}: IProcessErrorOptions) {
+		super({violation: "process", message, node});
 		this.kind = kind;
 	}
 }

src/interpreter/error/thrown-error/i-thrown-error-options.ts

@@ -0,0 +1,5 @@
+import {IEvaluationErrorOptions} from "../evaluation-error/i-evaluation-error-options";
+
+export interface IThrownErrorOptions extends IEvaluationErrorOptions {
+	originalError: Error;
+}

src/interpreter/error/thrown-error/thrown-error.ts

@@ -0,0 +1,18 @@
+import {EvaluationError} from "../evaluation-error/evaluation-error";
+import {IThrownErrorOptions} from "./i-thrown-error-options";
+
+/**
+ * An Error that represents an error thrown from within the code that is being evaluated.
+ */
+export class ThrownError extends EvaluationError {
+	/**
+	 * The originally thrown Error
+	 * @type {Error}
+	 */
+	public readonly originalError: Error;
+
+	constructor ({originalError, node, message = originalError.message}: IThrownErrorOptions) {
+		super({message, node});
+		this.originalError = originalError;
+	}
+}

src/interpreter/error/undefined-identifier-error/i-undefined-identifier-error-options.ts

@@ -2,5 +2,5 @@ import {Identifier} from "typescript";
 import {IEvaluationErrorOptions} from "../evaluation-error/i-evaluation-error-options";
 
 export interface IUndefinedIdentifierErrorOptions extends IEvaluationErrorOptions {
-	identifier: Identifier;
+	node: Identifier;
 }

src/interpreter/error/undefined-identifier-error/undefined-identifier-error.ts

@@ -8,11 +8,11 @@ import {IUndefinedIdentifierErrorOptions} from "./i-undefined-identifier-error-o
 export class UndefinedIdentifierError extends EvaluationError {
 	/**
 	 * The identifier that is undefined in the context that created this error
+	 * @type {Identifier}
 	 */
-	public readonly identifier: Identifier;
+	public readonly node: Identifier;
 
-	constructor ({identifier, message = `'${identifier.text}' is not defined'`}: IUndefinedIdentifierErrorOptions) {
-		super({message});
-		this.identifier = identifier;
+	constructor ({node, message = `'${node.text}' is not defined'`}: IUndefinedIdentifierErrorOptions) {
+		super({message, node});
 	}
 }

src/interpreter/error/undefined-left-value-error/undefined-left-value-error.ts

@@ -6,7 +6,7 @@ import {IUndefinedLeftValueErrorOptions} from "./i-undefined-left-value-error-op
  */
 export class UndefinedLeftValueError extends EvaluationError {
 
-	constructor ({message = `'No leftValue could be determined'`}: IUndefinedLeftValueErrorOptions = {}) {
-		super({message});
+	constructor ({node, message = `'No leftValue could be determined'`}: IUndefinedLeftValueErrorOptions) {
+		super({message, node});
 	}
 }

src/interpreter/error/unexpected-node-error/i-unexpected-node-error-options.ts

@@ -1,6 +1,4 @@
-import {Node} from "typescript";
 import {IEvaluationErrorOptions} from "../evaluation-error/i-evaluation-error-options";
 
 export interface IUnexpectedNodeErrorOptions extends IEvaluationErrorOptions {
-	node: Node;
 }

src/interpreter/error/unexpected-node-error/unexpected-node-error.ts

@@ -1,18 +1,13 @@
-import {Node, SyntaxKind} from "typescript";
+import {SyntaxKind} from "typescript";
 import {EvaluationError} from "../evaluation-error/evaluation-error";
 import {IUnexpectedNodeErrorOptions} from "./i-unexpected-node-error-options";
 
 /**
  * An Error that can be thrown when an unexpected node is encountered
  */
 export class UnexpectedNodeError extends EvaluationError {
-	/**
-	 * The node that was unexpected in the context that spawned this error
-	 */
-	public readonly node: Node;
 
 	constructor ({node, message = `Unexpected Node: '${SyntaxKind[node.kind]}'`}: IUnexpectedNodeErrorOptions) {
-		super({message});
-		this.node = node;
+		super({message, node});
 	}
 }

src/interpreter/evaluate.ts

@@ -14,6 +14,9 @@ import {isDeclaration} from "./util/declaration/is-declaration";
 import {UnexpectedNodeError} from "./error/unexpected-node-error/unexpected-node-error";
 import {IEvaluatePolicySanitized} from "./policy/i-evaluate-policy";
 import {EnvironmentPresetKind} from "./environment/environment-preset-kind";
+import {Node} from "typescript";
+import {EvaluationError} from "./error/evaluation-error/evaluation-error";
+import {ThrownError} from "./error/thrown-error/thrown-error";
 
 /**
  * Will get a literal value for the given Expression, ExpressionStatement, or Declaration.
@@ -67,11 +70,34 @@ export function evaluate ({
 		}
 	};
 
+	// Prepare a reference to the Node that is currently being evaluated
+	let currentNode: Node = node;
+
+	// Prepare a logger
 	const logger = new Logger(logLevel);
-	const initialEnvironment = createLexicalEnvironment({preset, extra}, policy);
 
+	// Prepare the initial environment
+	const initialEnvironment = createLexicalEnvironment({
+		inputEnvironment: {
+			preset,
+			extra
+		},
+		policy,
+		getCurrentNode: () => currentNode
+	});
+
+	// Prepare a Stack
 	const stack: Stack = createStack();
-	const nodeEvaluator = createNodeEvaluator({policy, typeChecker, logger, stack, reporting});
+
+	// Prepare a NodeEvaluator
+	const nodeEvaluator = createNodeEvaluator({
+		policy,
+		typeChecker,
+		logger,
+		stack,
+		reporting,
+		nextNode: nextNode => currentNode = nextNode
+	});
 
 	try {
 		let value: Literal;
@@ -103,6 +129,10 @@ export function evaluate ({
 			value
 		};
 	} catch (reason) {
+		// If the Error hasn't been wrapped or wasn't thrown internally, wrap it in a ThrownError
+		if (!(reason instanceof EvaluationError)) {
+			reason = new ThrownError({originalError: reason, node: currentNode});
+		}
 		return {
 			success: false,
 			reason

src/interpreter/evaluator/evaluate-await-expression.ts

@@ -14,7 +14,7 @@ export function evaluateAwaitExpression ({node, environment, evaluate, policy, s
 	const timeout = policy.maxOpDuration === Infinity
 		? undefined
 		: setTimeout(() => {
-			throw new MaxOpDurationExceededError({duration: policy.maxOpDuration});
+			throw new MaxOpDurationExceededError({duration: policy.maxOpDuration, node});
 		}, policy.maxOpDuration);
 
 	const result = syncAwait(evaluate.expression(node.expression, environment, statementTraversalStack) as Promise<Literal>);

src/interpreter/evaluator/evaluate-binary-expression.ts

@@ -137,7 +137,7 @@ export function evaluateBinaryExpression ({node, environment, evaluate, logger,
 			}
 
 			else {
-				throw new UndefinedLeftValueError();
+				throw new UndefinedLeftValueError({node: node.left});
 			}
 
 			// The return value of an assignment is always the assigned value

src/interpreter/evaluator/evaluate-call-expression.ts

@@ -37,7 +37,7 @@ export function evaluateCallExpression ({node, environment, evaluate, statementT
 	// Otherwise, assume that the expression still needs calling
 	else {
 		if (typeof expressionResult !== "function") {
-			throw new NotCallableError({value: expressionResult});
+			throw new NotCallableError({value: expressionResult, node: node.expression});
 		}
 
 		const value = expressionResult(...evaluatedArgs);