Implemented basic OOP.

Implemented basic OOP. Tests have not been added yet.

Author: aryan-programmer

Cargo.lock

@@ -9,7 +9,10 @@ edition = "2021"
 anyhow = { version = "1.0.71", features = ["backtrace"] }
 backtrace = "0.3.68"
 const-str = "0.5.6"
+debug-ignore = "1.0.5"
 delegate = "0.10.0"
+derivative = "2.2.0"
+either = "1.9.0"
 extend = "1.2.0"
 gc = { version = "0.5.0", features = ["derive", "gc_derive"] }
 lazy_static = "1.4.0"

Cargo.toml

@@ -1,6 +1,6 @@
 use crate::ast::operator::Operator;
 use crate::ast::statement::Statement;
-use crate::ast::structs::{CallExpression, FunctionDeclaration};
+use crate::ast::structs::{CallExpression, ClassDeclaration, FunctionDeclaration};
 
 pub type BoxExpression = Box<Expression>;
 
@@ -10,6 +10,7 @@ pub type IdentifierT = String;
 pub enum MemberIndexer {
 	PropertyName(IdentifierT),
 	SubscriptExpression(BoxExpression),
+	MethodNameArrow(IdentifierT),
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -18,8 +19,9 @@ pub enum Expression {
 	BooleanLiteral(bool),
 	IntegerLiteral(i64),
 	StringLiteral(String),
+	ParenthesizedExpression(BoxExpression),
 	// ThisExpression,
-	SuperExpression,
+	// SuperExpression,
 	UnaryExpression {
 		operator: Operator,
 		argument: BoxExpression,
@@ -42,6 +44,7 @@ pub enum Expression {
 	FunctionCall(CallExpression),
 	NewObjectExpression(CallExpression),
 	FunctionExpression(FunctionDeclaration),
+	ClassDeclarationExpression(Box<ClassDeclaration>),
 }
 
 impl Expression {
@@ -60,6 +63,11 @@ impl Expression {
 		return Expression::AssignmentExpression { operator, left, right };
 	}
 
+	#[inline(always)]
+	pub fn member_method_access(object: BoxExpression, property_name: IdentifierT) -> Expression {
+		return Expression::MemberAccess { object, member: MemberIndexer::MethodNameArrow(property_name) };
+	}
+
 	#[inline(always)]
 	pub fn member_property_access(object: BoxExpression, property_name: IdentifierT) -> Expression {
 		return Expression::MemberAccess { object, member: MemberIndexer::PropertyName(property_name) };
@@ -93,4 +101,9 @@ impl Expression {
 	pub fn consume_as_statement(self) -> Statement {
 		return Statement::from(self);
 	}
+
+	#[inline(always)]
+	pub fn consume_as_parenthesized(self) -> Expression {
+		return Expression::ParenthesizedExpression(self.into());
+	}
 }

src/lib/ast/expression.rs

@@ -1,5 +1,5 @@
 use crate::ast::expression::{Expression, IdentifierT};
-use crate::ast::structs::{FunctionDeclaration, FunctionParameterDeclaration, VariableDeclaration};
+use crate::ast::structs::{ClassDeclaration, FunctionDeclaration, FunctionParameterDeclaration, VariableDeclaration};
 
 pub type BoxStatement = Box<Statement>;
 
@@ -34,11 +34,7 @@ pub enum Statement {
 	BreakStatement(i64),
 	ContinueStatement(i64),
 	FunctionDeclarationStatement(FunctionDeclaration),
-	ClassDeclarationStatement {
-		name: IdentifierT,
-		super_class: Option<Expression>,
-		methods: Vec<FunctionDeclaration>,
-	},
+	ClassDeclarationStatement(ClassDeclaration),
 }
 
 impl Statement {
@@ -91,7 +87,7 @@ impl Statement {
 		super_class: Option<Expression>,
 		methods: Vec<FunctionDeclaration>,
 	) -> Statement {
-		return Statement::ClassDeclarationStatement { name, super_class, methods };
+		return Statement::ClassDeclarationStatement(ClassDeclaration::new(name, super_class, methods));
 	}
 }
 

src/lib/ast/statement.rs

@@ -40,6 +40,20 @@ impl FunctionDeclaration {
 	}
 }
 
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ClassDeclaration {
+	pub name: IdentifierT,
+	pub super_class: Option<Expression>,
+	pub methods: Vec<FunctionDeclaration>,
+}
+
+impl ClassDeclaration {
+	#[inline(always)]
+	pub fn new(name: IdentifierT, super_class: Option<Expression>, methods: Vec<FunctionDeclaration>) -> Self {
+		Self { name, super_class, methods }
+	}
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct CallExpression {
 	pub callee: BoxExpression,

src/lib/ast/structs.rs

@@ -8,14 +8,66 @@ use crate::ast::expression::{Expression, IdentifierT};
 use crate::ast::operator::Operator;
 use crate::ast::statement::Statement;
 use crate::interpreter::environment::statement_result::StatementExecution;
+use crate::interpreter::runtime_values::PrimitiveValue;
 use crate::tokenizer::Token;
 
 pub type ResultWithError<T, E = EvilangError> = anyhow::Result<T, E>;
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum Descriptor {
+	None,
+	Name(IdentifierT),
+	Value(PrimitiveValue),
+	Expression(Expression),
+	Both { value: PrimitiveValue, expression: Expression },
+}
+
+impl From<&str> for Descriptor {
+	fn from(value: &str) -> Self {
+		Descriptor::Name(value.to_string())
+	}
+}
+
+impl From<IdentifierT> for Descriptor {
+	fn from(value: IdentifierT) -> Self {
+		Descriptor::Name(value)
+	}
+}
+
+impl From<PrimitiveValue> for Descriptor {
+	fn from(value: PrimitiveValue) -> Self {
+		Descriptor::Value(value)
+	}
+}
+
+impl From<Expression> for Descriptor {
+	fn from(value: Expression) -> Self {
+		Descriptor::Expression(value)
+	}
+}
+
+#[derive(Debug, Clone, PartialEq, Error)]
+pub enum RuntimeError {
+	#[error("{0}")]
+	GenericError(String),
+	#[error("Expected {0:#?} to be a function")]
+	ExpectedFunction(Descriptor),
+	#[error("Expected {0:#?} to be a class object")]
+	ExpectedClassObject(Descriptor),
+	#[error("Expected {0:#?} to be an object")]
+	ExpectedObject(Descriptor),
+	#[error("Invalid number of arguments {got:?} expected {expected:?} to be function {func:#?}")]
+	InvalidNumberArgumentsToFunction { got: usize, expected: Option<String>, func: Descriptor },
+	#[error("Expected {0:#?} to be a valid subscript expression")]
+	ExpectedValidSubscript(Descriptor),
+}
+
 #[derive(Debug, Clone, PartialEq, Error)]
 pub enum ErrorT {
-	#[error("This error should never happen")]
-	NeverError,
+	#[error("This error should never happen: {0}")]
+	NeverError(String),
+	#[error(transparent)]
+	UnexpectedRuntimeError(#[from] RuntimeError),
 	#[error("End of Token Stream")]
 	EndOfTokenStream,
 	#[error("Invalid Token Type: {0:#?}")]
@@ -38,8 +90,6 @@ pub enum ErrorT {
 	UnimplementedBinaryOperatorForValues(Operator, Expression, Expression),
 	#[error("The interpreter does not support the unary operator: {0:?} for the value {1:#?}")]
 	UnimplementedUnaryOperatorForValues(Operator, Expression),
-	#[error("The following expression is not a function: {0:?}")]
-	NotAFunction(Expression),
 	#[error("A mutable borrow already exists")]
 	InvalidBorrow,
 	#[error("The cannot strip assignment from operator: {0:?}")]
@@ -52,6 +102,8 @@ pub enum ErrorT {
 	CantSetToHoistedValue,
 	#[error("Invalid unrolling from function {0:?}: {1:#?}")]
 	InvalidUnrollingOfFunction(IdentifierT, StatementExecution),
+	#[error("Member functions accessed by the arrow notation mus be immediately called: {0:#?}")]
+	InvalidMethodArrowAccess(Expression),
 }
 
 #[derive(Debug, Clone)]
@@ -85,6 +137,13 @@ impl From<ErrorT> for EvilangError {
 	}
 }
 
+impl From<RuntimeError> for EvilangError {
+	#[inline(always)]
+	fn from(value: RuntimeError) -> Self {
+		return EvilangError::new(ErrorT::UnexpectedRuntimeError(value));
+	}
+}
+
 impl EvilangError {
 	#[inline(always)]
 	pub fn new(typ: ErrorT) -> EvilangError {

src/lib/errors.rs

@@ -1,15 +1,25 @@
 use crate::interpreter::environment::native_functions::get_native_functions_list;
+use crate::interpreter::runtime_values::objects::runtime_object::RuntimeObject;
 use crate::interpreter::runtime_values::PrimitiveValue;
-use crate::interpreter::variables_map::{GlobalScope, VariablesMap};
+use crate::interpreter::variables_containers::{GlobalScope, VariablesMap};
 use crate::utils::cell_ref::{gc_box_from, GcBox};
+use crate::interpreter::utils::consts::{OBJECT};
+
+pub fn get_object_class() -> GcBox<RuntimeObject> {
+	return RuntimeObject::new_gc(VariablesMap::new(), None, OBJECT.into());
+}
 
 fn get_default_global_variables() -> VariablesMap {
 	return VariablesMap::new_direct(
 		get_native_functions_list()
 			.into_iter()
 			.map(|(name, f)| {
-				(name, gc_box_from(PrimitiveValue::new_native_function(f)))
+				(name, PrimitiveValue::new_native_function(f))
 			})
+			.chain([
+				(OBJECT.to_string(), PrimitiveValue::Object(get_object_class()))
+			].into_iter())
+			.map(|(name, val)| (name, gc_box_from(val)))
 			.collect()
 	);
 }