Added support for native objects.

Added support for native objects.
Added a procedural macro to automatically generate the code for a native object.
Added vectors, dynamically sized arrays.
Added a double colon operator to call static functions. Removed the arrow operator for member functions, they can be called with the regular dot operator.
Added debug, print and to_string functions.

Author: aryan-programmer

Cargo.lock

@@ -11,8 +11,9 @@ authors = ["Aryan Chudasama"]
 
 [dependencies]
 clap = "4.3.23"
-evilang_lib = {version = "0.1.0", path = "evilang_lib"}
-evilang_traits = {version = "0.1.0", path = "evilang_traits"}
+either = "1.9.0"
+evilang_lib = { version = "0.1.0", path = "evilang_lib" }
+evilang_traits = { version = "0.1.0", path = "evilang_traits" }
 
 [[bin]]
 name = "evilang_main"

Cargo.toml

@@ -0,0 +1,3 @@
+fn main() {
+	// println!("cargo:rustc-env=RUSTC_BOOTSTRAP=evilang_lib");
+}

build.rs

@@ -16,6 +16,8 @@ regex = "1.9.1"
 static_assertions = "1.1.0"
 thiserror = "1.0.43"
 evilang_traits = { path = "../evilang_traits", version = "0.1.0" }
+maybe-owned = "0.3.4"
+itertools = "0.11.0"
 
 [lib]
 name = "evilang_lib"

evilang_lib/Cargo.toml

@@ -0,0 +1,3 @@
+fn main() {
+	// println!("cargo:rustc-env=RUSTC_BOOTSTRAP=1");
+}

evilang_lib/build.rs

@@ -4,19 +4,25 @@ use crate::ast::operator::Operator;
 use crate::ast::statement::Statement;
 use crate::ast::structs::{CallExpression, ClassDeclaration, FunctionDeclaration};
 use crate::errors::ResultWithError;
+use crate::tokenizer::Token;
 use crate::types::number::NumberT;
 use crate::types::string::StringT;
 
 pub type BoxExpression = Box<Expression>;
 
 pub type IdentifierT = StringT;
-pub type DottedIdentifiers = Vec<IdentifierT>;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct DottedIdentifiers {
+	pub identifiers: Vec<IdentifierT>,
+	pub delimiters: Vec<Token>,
+}
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum MemberIndexer {
 	PropertyName(IdentifierT),
 	SubscriptExpression(BoxExpression),
-	MethodNameArrow(IdentifierT),
+	// MethodNameArrow(IdentifierT),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -80,10 +86,10 @@ 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_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 {

evilang_lib/src/lib/ast/expression.rs

@@ -3,10 +3,9 @@ use std::fmt::{Display, Formatter};
 use std::io;
 
 use backtrace::Backtrace;
+use maybe_owned::MaybeOwned;
 use thiserror::Error;
 
-use evilang_traits::Clone__SilentlyFail;
-
 use crate::ast::expression::{Expression, IdentifierT};
 use crate::ast::operator::Operator;
 use crate::ast::statement::Statement;
@@ -22,14 +21,34 @@ pub enum Descriptor {
 	Name(IdentifierT),
 	Value(PrimitiveValue),
 	Expression(Expression),
-	Both { value: PrimitiveValue, expression: Expression },
+	ExpressionAndValue { value: PrimitiveValue, expression: Expression },
+	NameAndValue { name: IdentifierT, value: PrimitiveValue },
 }
 
 impl Descriptor {
-	pub fn new_both(value: &PrimitiveValue, expression: &Expression) -> Descriptor {
-		return Descriptor::Both {
-			value: value.clone__silently_fail(),
-			expression: expression.clone(),
+	pub fn new_both(value: MaybeOwned<PrimitiveValue>, expression: MaybeOwned<Expression>) -> Descriptor {
+		return Descriptor::ExpressionAndValue {
+			value: Self::value_to_owned(value),
+			expression: expression.into_owned(),
+		};
+	}
+
+	fn value_to_owned(value: MaybeOwned<PrimitiveValue>) -> PrimitiveValue {
+		match value {
+			MaybeOwned::Owned(v) => v,
+			MaybeOwned::Borrowed(v) => v.clone__silently_fail()
+		}
+	}
+
+	pub fn with_value(self, value: MaybeOwned<PrimitiveValue>) -> Descriptor {
+		let v = Self::value_to_owned(value);
+		return match self {
+			Descriptor::None => Descriptor::Value(v),
+			Descriptor::Name(name) => Descriptor::NameAndValue { name, value: v },
+			Descriptor::Value(_) => Descriptor::Value(v),
+			Descriptor::Expression(expression) => Descriptor::ExpressionAndValue { expression, value: v },
+			Descriptor::ExpressionAndValue { expression, value: _ } => Descriptor::ExpressionAndValue { expression, value: v },
+			Descriptor::NameAndValue { name, value: _ } => Descriptor::NameAndValue { name, value: v },
 		};
 	}
 }
@@ -48,12 +67,18 @@ impl Clone for Descriptor {
 			Descriptor::Expression(expr) => {
 				Descriptor::Expression(Clone::clone(expr))
 			}
-			Descriptor::Both { value, expression } => {
-				Descriptor::Both {
+			Descriptor::ExpressionAndValue { value, expression } => {
+				Descriptor::ExpressionAndValue {
 					value: value.clone__silently_fail(),
 					expression: Clone::clone(expression),
 				}
 			}
+			Descriptor::NameAndValue { name, value } => {
+				Descriptor::NameAndValue {
+					name: Clone::clone(name),
+					value: value.clone__silently_fail(),
+				}
+			}
 		}
 	}
 }
@@ -90,6 +115,14 @@ impl From<Expression> for Descriptor {
 pub enum RuntimeError {
 	#[error("{0}")]
 	GenericError(StringT),
+	#[error("Expected {0:#?} to not be null")]
+	UnexpectedNullValue(Descriptor),
+	#[error("Expected {0:#?} to be a boolean")]
+	ExpectedBoolean(Descriptor),
+	#[error("Expected {0:#?} to be a number")]
+	ExpectedNumber(Descriptor),
+	#[error("Expected {0:#?} to be a string")]
+	ExpectedString(Descriptor),
 	#[error("Expected {0:#?} to be a function")]
 	ExpectedFunction(Descriptor),
 	#[error("Expected {0:#?} to be a class object")]
@@ -98,6 +131,10 @@ pub enum RuntimeError {
 	ExpectedNamespaceObject(Descriptor),
 	#[error("Expected {0:#?} to be an object")]
 	ExpectedObject(Descriptor),
+	#[error("Expected {0:#?} to be a native struct object")]
+	ExpectedNativeObject(Descriptor),
+	#[error("Invalid arguments {0:#?}: {1:#?}")]
+	InvalidArgumentsToFunction(String, Descriptor),
 	#[error("Invalid number of arguments {got:?} expected {expected:?} to be function {func:#?}")]
 	InvalidNumberArgumentsToFunction { got: usize, expected: Option<StringT>, func: Descriptor },
 	#[error("Expected {0:#?} to be a valid subscript expression")]