fully implemented try-catch statements and throw statements

src/GigaScript/ast/ast.ts

@@ -5,6 +5,7 @@ export type ASTNodeType =
 	| 'FunctionDeclaration'
 	| 'ReturnStatement'
 	| 'TryCatchStatement'
+	| 'ThrowStatement'
 	| 'CodeBlockNode'
 	| 'EOF'
 	// Expressions

src/GigaScript/ast/statements.ast.ts

@@ -11,3 +11,8 @@ export interface TryCatchStatement extends STATEMENT {
 	catchBody: CodeBlockNode;
 	errorIdentifier: string;
 }
+
+export interface ThrowStatement extends STATEMENT {
+	kind: 'ThrowStatement';
+	message: EXPRESSION;
+}

src/GigaScript/parser/parser.ts

@@ -20,7 +20,11 @@ import {
 	Property,
 	StringLiteral,
 } from '../ast/literals.ast';
-import { ReturnStatement, TryCatchStatement } from '../ast/statements.ast';
+import {
+	ReturnStatement,
+	ThrowStatement,
+	TryCatchStatement,
+} from '../ast/statements.ast';
 import { tokenize } from '../lexer/tokenizer';
 import { NodeType } from '../nodes';
 import { Token, getTokenByTypeEnum } from '../tokens';
@@ -144,6 +148,9 @@ export default class Parser {
 			case NodeType.Return:
 				return this.parseReturnStatement();
 
+			case NodeType.Throw:
+				return this.parseThrowStatement();
+
 			default:
 				return this.parseExpr();
 		}
@@ -293,6 +300,18 @@ export default class Parser {
 		} as ReturnStatement;
 	}
 
+	private parseThrowStatement(): STATEMENT {
+		const throwTokenPos = this.advance().__GSC._POS;
+		const message = this.parseExpr();
+
+		return {
+			kind: 'ThrowStatement',
+			message,
+			start: throwTokenPos.start,
+			end: message.end,
+		} as ThrowStatement;
+	}
+
 	// [FUNCTIONS.ARGUMENTS/PARAMETERS]
 	private parseArgs(): Array<EXPRESSION> {
 		this.expect(NodeType.OpenParen, 'before parameter list');

src/GigaScript/runtime/interpreter/eval/statements.ts

@@ -1,9 +1,13 @@
-import { Program } from '../../../ast/ast';
+import { CodeBlockNode, Program } from '../../../ast/ast';
 import {
 	FunctionDeclaration,
 	VariableDeclaration,
 } from '../../../ast/declarations.ast';
-import { ReturnStatement } from '../../../ast/statements.ast';
+import {
+	ReturnStatement,
+	ThrowStatement,
+	TryCatchStatement,
+} from '../../../ast/statements.ast';
 import Environment from '../../env';
 import { DataConstructors, DataType, FuncVal, Value } from '../../types';
 import { evaluate } from '../interpreter';
@@ -55,3 +59,50 @@ export function evalReturnStatement(
 
 	return value;
 }
+
+export function evalTryCatchStatement(
+	statement: TryCatchStatement,
+	env: Environment
+): Value<DataType, any> {
+	const tryEnv = new Environment(env.cwd, env);
+	const catchEnv = new Environment(env.cwd, env);
+
+	try {
+		return evalCodeBlock(statement.tryBody, tryEnv, false);
+	} catch (e) {
+		catchEnv.delcareVar(
+			statement.errorIdentifier,
+			DataConstructors.STRING(String(e)),
+			true
+		);
+		return evalCodeBlock(statement.catchBody, catchEnv, false);
+	}
+}
+
+export function evalThrowStatement(
+	statement: ThrowStatement,
+	env: Environment
+): Value<'null', null> {
+	const message = evaluate(statement.message, env);
+
+	throw message.value;
+}
+
+export function evalCodeBlock(
+	body: CodeBlockNode,
+	env: Environment,
+	createNewEnv = true
+): Value<DataType, any> {
+	let scope: Environment;
+
+	if (createNewEnv) scope = new Environment(env.cwd, env);
+	else scope = env;
+
+	let res: Value<DataType, any> = DataConstructors.NULL();
+
+	for (const stmt of body.body) {
+		res = evaluate(stmt, scope);
+	}
+
+	return res;
+}

src/GigaScript/runtime/interpreter/interpreter.ts

@@ -13,7 +13,11 @@ import {
 	ObjectLiteral,
 	StringLiteral,
 } from '../../ast/literals.ast';
-import { ReturnStatement } from '../../ast/statements.ast';
+import {
+	ReturnStatement,
+	ThrowStatement,
+	TryCatchStatement,
+} from '../../ast/statements.ast';
 import { GSError } from '../../util/gserror';
 import Environment from '../env';
 import { DataType, Value } from '../types';
@@ -30,6 +34,8 @@ import {
 	evalProgram,
 	evalReturnStatement,
 	evalVarDeclaration,
+	evalTryCatchStatement,
+	evalThrowStatement,
 } from './eval/statements';
 
 export function evaluate(
@@ -93,6 +99,12 @@ export function evaluate(
 		case 'ReturnStatement':
 			return evalReturnStatement(node as ReturnStatement, env);
 
+		case 'TryCatchStatement':
+			return evalTryCatchStatement(node as TryCatchStatement, env);
+
+		case 'ThrowStatement':
+			return evalThrowStatement(node as ThrowStatement, env);
+
 		// Handle non implemented types
 		default:
 			console.log(

tests/main.g

@@ -21,6 +21,8 @@ print(obj.complex.foo)
 
 try {
     print("hello world!")
+    throw 'test'
 } catch (e) {
+    print('an error was caught!')
     print(e)
 }