Refactoring changes.

Refactoring changes, to resolve Rust warnings.

Author: aryan-programmer

Cargo.lock

@@ -8,7 +8,7 @@ use crate::interpreter::environment::Environment;
 use crate::interpreter::environment::native_items::classes::object::ObjectSuperclass;
 use crate::interpreter::runtime_values::functions::GcPtrToFunction;
 use crate::interpreter::runtime_values::functions::ifunction::IFunction;
-use crate::interpreter::runtime_values::i_native_struct::{INativeClass, INativeClass_BuildClass, INativeClass_GetClassCached, native_wrap, NativeClassMemberFunctionContext, NativeClassStaticFunctionContext, auto_unwrap_exec_fn};
+use crate::interpreter::runtime_values::i_native_struct::{auto_unwrap_exec_fn, INativeClass, INativeClass_BuildClass, INativeClass_GetClassCached, native_wrap, NativeClassMemberFunctionContext, NativeClassStaticFunctionContext};
 use crate::interpreter::runtime_values::i_native_struct::INativeClass_IsStructWrapper;
 use crate::interpreter::runtime_values::i_native_struct::INativeStruct;
 use crate::interpreter::runtime_values::objects::runtime_object::{GcPtrToObject, RuntimeObject};
@@ -32,7 +32,7 @@ implement_get_class_cached!(Vector);
 
 impl INativeStruct for Vector {}
 
-#[derive_build_class(name = "Vector", evilang_lib_crate = crate)]
+#[derive_build_class(evilang_lib_crate = crate)]
 impl Vector {
 	#[export = "constructor"]
 	pub fn constructor(_ctx: NativeClassMemberFunctionContext) -> ResultWithError<Self> {
@@ -57,7 +57,7 @@ impl Vector {
 	#[export]
 	pub fn repeat(ctx: NativeClassStaticFunctionContext, v: PrimitiveValue, n: NumberT) -> ResultWithError<PrimitiveValue> {
 		let res = Self {
-			vec: (0..(n.floor_to_int() as usize)).map(|i| v.try_clone_err()).collect::<ResultWithError<Vec<_>>>()?
+			vec: (0..(n.floor_to_int() as usize)).map(|_i| v.try_clone_err()).collect::<ResultWithError<Vec<_>>>()?
 		};
 		let obj = RuntimeObject::allocate_instance(
 			Vector::get_class_cached(ctx.env)?,

evilang_lib/src/lib/interpreter/environment/native_items/classes/vector.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::ops::Deref;
 
 use crate::ast::expression::IdentifierT;
 use crate::errors::{Descriptor, ResultWithError, RuntimeError};
@@ -19,7 +18,7 @@ pub fn push_res_stack(env: &mut Environment, params: FunctionParameters) -> Resu
 	Ok(PrimitiveValue::Null.into())
 }
 
-pub fn to_string(env: &mut Environment, params: FunctionParameters) -> ResultWithError<FunctionReturnValue> {
+pub fn to_string(_env: &mut Environment, params: FunctionParameters) -> ResultWithError<FunctionReturnValue> {
 	Ok(PrimitiveValue::String(match params.first().unwrap() {
 		PrimitiveValue::Null => { "null".to_string() }
 		PrimitiveValue::Boolean(v) => { if *v { "true" } else { "false" }.to_string() }
@@ -35,14 +34,14 @@ pub fn to_string(env: &mut Environment, params: FunctionParameters) -> ResultWit
 	}))
 }
 
-pub fn print(env: &mut Environment, params: FunctionParameters) -> ResultWithError<FunctionReturnValue> {
+pub fn print(_env: &mut Environment, params: FunctionParameters) -> ResultWithError<FunctionReturnValue> {
 	for x in params.into_iter() {
 		print!("{}", x);
 	}
 	Ok(PrimitiveValue::Null.into())
 }
 
-pub fn debug(env: &mut Environment, params: FunctionParameters) -> ResultWithError<FunctionReturnValue> {
+pub fn debug(_env: &mut Environment, params: FunctionParameters) -> ResultWithError<FunctionReturnValue> {
 	println!("{0:#?}", params);
 	Ok(PrimitiveValue::Null.into())
 }

evilang_lib/src/lib/interpreter/environment/native_items/mod.rs

@@ -56,7 +56,7 @@ impl PartialEq for dyn IResolver {
 
 impl PartialEq<&BoxIResolver> for BoxIResolver {
 	fn eq(&self, other: &&Self) -> bool {
-		self.equals_resolver(other.deref().deref().deref())
+		self.equals_resolver(&***other)
 	}
 }
 
@@ -112,7 +112,7 @@ impl DefaultResolver {
 			.and_then(|env| env.get_actual(CURRENT_FILE.into()))
 			.and_then(|v| if v.borrow().deref() == &PrimitiveValue::Null { None } else { Some(v) }) else {
 			return fs::canonicalize(file_name).map_err(EvilangError::from);
-			return Ok(normalize_path(Path::new(&file_name)).to_path_buf());//.map_err(EvilangError::from);
+			//return Ok(normalize_path(Path::new(&file_name)).to_path_buf());//.map_err(EvilangError::from);
 		};
 		let this_file_path_borr = this_file_path_box.borrow();
 		let PrimitiveValue::String(this_file_path_str_ref) = this_file_path_borr.deref() else {

evilang_lib/src/lib/interpreter/environment/resolver.rs

@@ -1,4 +1,4 @@
-use std::fmt::{Display, Formatter, Write};
+use std::fmt::{Display, Formatter};
 
 use gc::{Finalize, Trace};
 
@@ -28,7 +28,7 @@ impl Display for Function {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		match self {
 			Function::NativeFunction(nf) => {
-				let mut res = std::fmt::Result::Ok(());
+				let mut res = Ok(());
 				backtrace::resolve(nf.f as *mut std::os::raw::c_void, |v| {
 					res = if let Some(name) = v.name() {
 						std::fmt::Display::fmt(&name, f)

evilang_lib/src/lib/interpreter/runtime_values/functions/mod.rs

@@ -1,4 +1,4 @@
-use std::fmt::{Display, Formatter, Write};
+use std::fmt::{Display, Formatter};
 use std::mem::swap;
 use std::ops::Deref;
 
@@ -48,14 +48,14 @@ pub enum PrimitiveValue {
 impl Display for PrimitiveValue {
 	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
 		match self {
-			PrimitiveValue::_HoistedVariable => {f.write_str("<hoisted_variable>")}
-			PrimitiveValue::Null => {f.write_str("null")}
-			PrimitiveValue::Boolean(b) => {std::fmt::Display::fmt(b, f)}
-			PrimitiveValue::Number(n) => {std::fmt::Display::fmt(n, f)}
-			PrimitiveValue::String(s) => {std::fmt::Display::fmt(s, f)}
-			PrimitiveValue::Function(fnc) => {std::fmt::Display::fmt(fnc.deref().deref(), f)}
-			PrimitiveValue::Object(o) => {std::fmt::Display::fmt(&o.name, f)}
-			PrimitiveValue::NativeStruct(ns) => {f.write_str("<native_struct>")}
+			PrimitiveValue::_HoistedVariable => { f.write_str("<hoisted_variable>") }
+			PrimitiveValue::Null => { f.write_str("null") }
+			PrimitiveValue::Boolean(b) => { std::fmt::Display::fmt(b, f) }
+			PrimitiveValue::Number(n) => { std::fmt::Display::fmt(n, f) }
+			PrimitiveValue::String(s) => { std::fmt::Display::fmt(s, f) }
+			PrimitiveValue::Function(fnc) => { std::fmt::Display::fmt(fnc.deref().deref(), f) }
+			PrimitiveValue::Object(o) => { std::fmt::Display::fmt(&o.name, f) }
+			PrimitiveValue::NativeStruct(_ns) => { f.write_str("<native_struct>") }
 		}
 	}
 }

evilang_lib/src/lib/interpreter/runtime_values/mod.rs

@@ -21,7 +21,7 @@ pub fn expect_object_fn<T>(object: &PrimitiveValue, desc_fn: T) -> ResultWithErr
 	return if let PrimitiveValue::Object(object_class_ref) = object {
 		Ok(object_class_ref)
 	} else {
-		Err(RuntimeError::ExpectedClassObject(desc_fn().with_value(object.deref().deref().into())).into())
+		Err(RuntimeError::ExpectedClassObject(desc_fn().with_value(object.into())).into())
 	};
 }
 

evilang_lib/src/lib/interpreter/utils/mod.rs

@@ -1,3 +1,5 @@
+#![allow(non_snake_case)]
+
 use std::borrow::Cow;
 use std::ops::Deref;
 
@@ -16,7 +18,6 @@ use crate::utils::crate_imports::CrateImports;
 fn define_alias_exports<'a, TIter: Iterator<Item=&'a FnExportData>>(
 	imports: &CrateImports,
 	iter: TIter,
-	orig_name: Cow<str>,
 	export_name: &Ident,
 ) -> Vec<TokenStream> {
 	let CrateImports { ResultWithError, Environment, FunctionParameters, FunctionReturnValue, .. } = imports;
@@ -98,7 +99,7 @@ fn define_export_for_constructor(
 			const THIS_PARAM_NAME: &'static str = #concat_str!("this parameter of ", FUNC_NAME);
 			let mut drain = params.drain(..);
 			let this_val = drain.next().unwrap();
-			#(#params_decl_list)*;
+			#(#params_decl_list)*
 			let this_obj = #expect_object_fn(
 				&this_val,
 				|| #Descriptor::Name(THIS_PARAM_NAME.into())
@@ -140,7 +141,6 @@ fn define_export_for_member_function(
 	let mut iter = fn_dat.exports.iter();
 	let main_export = iter.next().expect("Expected an export");
 	let orig_name = &fn_dat.signature.ident;
-	let orig_name_str = orig_name.to_string();
 	let export_name = &main_export.export_ident;
 	let first_arg = fn_dat.signature.inputs.first().expect("Expected at-least one argument");
 	let FnArg::Receiver(self_param) = first_arg else {
@@ -160,7 +160,6 @@ fn define_export_for_member_function(
 	let rest_exports = define_alias_exports(
 		&imports,
 		iter,
-		orig_name_str.into(),
 		&export_name,
 	);
 	let res = quote_spanned! { main_export.attribute.get_span() =>
@@ -181,7 +180,7 @@ fn define_export_for_member_function(
 			// }
 			let mut drain = params.drain(..);
 			let this_val = drain.next().unwrap();
-			#(#params_decl_list)*;
+			#(#params_decl_list)*
 			let this_val_ref = &this_val;
 			let result = #native_unwrap_exec_fn::<#ExpT, _, _, _>(
 				&this_val,
@@ -202,7 +201,6 @@ fn define_export_for_member_function(
 fn define_export_for_static_function(
 	imports: &CrateImports,
 	ExpT: &TokenStream,
-	NATIVE_BOX_WRAP_NAME: &TokenStream,
 	fn_dat: &FunctionData,
 ) -> TokenStream {
 	if fn_dat.exports.len() == 0 {
@@ -221,7 +219,6 @@ fn define_export_for_static_function(
 	let mut iter = fn_dat.exports.iter();
 	let main_export = iter.next().expect("Expected an export");
 	let orig_name = &fn_dat.signature.ident;
-	let orig_name_str = orig_name.to_string();
 	let export_name = &main_export.export_ident;
 	let (params_decl_list, param_names_list) = for_params(
 		fn_dat.signature.inputs.iter().skip(1/*skip ctx*/),
@@ -232,14 +229,13 @@ fn define_export_for_static_function(
 	let rest_exports = define_alias_exports(
 		&imports,
 		iter,
-		orig_name_str.into(),
 		&export_name,
 	);
 	let res = quote_spanned! { main_export.attribute.get_span() =>
 		pub fn #export_name(env: &mut #Environment, mut params: #FunctionParameters) ->
 			#ResultWithError<#FunctionReturnValue> {
 			let mut drain = params.drain(..);
-			#(#params_decl_list)*;
+			#(#params_decl_list)*
 			let result = #ExpT::#orig_name(
 				#NativeClassStaticFunctionContext::new(env),
 				#(#param_names_list),*
@@ -254,7 +250,6 @@ fn define_export_for_static_function(
 fn define_export_for_raw_native_function(
 	imports: &CrateImports,
 	ExpT: &TokenStream,
-	NATIVE_BOX_WRAP_NAME: &TokenStream,
 	fn_dat: &FunctionData,
 ) -> TokenStream {
 	if fn_dat.exports.len() == 0 {
@@ -270,12 +265,10 @@ fn define_export_for_raw_native_function(
 	let mut iter = fn_dat.exports.iter();
 	let main_export = iter.next().expect("Expected an export");
 	let orig_name = &fn_dat.signature.ident;
-	let orig_name_str = orig_name.to_string();
 	let export_name = &main_export.export_ident;
 	let rest_exports = define_alias_exports(
 		&imports,
 		iter,
-		orig_name_str.into(),
 		&export_name,
 	);
 	let res = quote_spanned! { main_export.attribute.get_span() =>
@@ -291,8 +284,8 @@ fn define_export_for_raw_native_function(
 
 #[derive(FromMeta, Debug, Default)]
 pub(crate) struct RootAttributes {
-	#[darling(default)]
-	name: Option<String>,
+	// #[darling(default)]
+	// name: Option<String>,
 	#[darling(default)]
 	evilang_lib_crate: Option<Path>,
 }
@@ -319,7 +312,7 @@ impl TryParseAttribute for ExportAttribute {
 		Self {
 			export_as: Some(expr_as_string(expr)),
 			attribute: None,
-			raw: false
+			raw: false,
 		}
 	}
 
@@ -390,7 +383,7 @@ impl RootData {
 			items: implementation.items.into_iter().map(|impl_item| match impl_item {
 				ImplItem::Fn(f) => {
 					// dbg!(&f.attrs);
-					let (mut exports_iter, attrs_iter) =
+					let (exports_iter, attrs_iter) =
 						f.attrs
 							.into_iter()
 							.map(ExportAttribute::try_parse_attribute)
@@ -418,14 +411,13 @@ impl RootData {
 		}, implementation)
 	}
 
-	#[allow(non_snake_case)]
-	pub fn generate_implementation(mut self) -> TokenStream {
+	pub fn generate_implementation(self) -> TokenStream {
 		let module = self.attributes.evilang_lib_crate
 			.as_ref()
 			.map(Path::to_token_stream)
 			.unwrap_or_else(|| quote! {::#MODULE_NAME});
 		let imports = CrateImports::new(module);
-		let CrateImports { ResultWithError, Descriptor, ErrorT, EvilangError, RuntimeError, Environment, GcPtrToObject, PrimitiveValue, expect_object_fn, FunctionReturnValue, FunctionParameters, concat_str, INativeClass, INativeClass_BuildClass, from_option_of_primitive_value, NativeClassMemberFunctionContext, native_wrap, native_unwrap_exec_fn, Some_, None_, Err_, Ok_, gc_ptr_cell_from, RuntimeObject, VariablesMap, HashMap, INativeClass_IsStructWrapper, .. } = &imports;
+		let CrateImports { ResultWithError, Environment, GcPtrToObject, PrimitiveValue, concat_str, INativeClass, INativeClass_BuildClass, Ok_, gc_ptr_cell_from, RuntimeObject, VariablesMap, HashMap, INativeClass_IsStructWrapper, .. } = &imports;
 		let SelfT = &self.self_ty;
 		let ExpT = quote! {super::#SelfT};
 		let Self_exports = str_concat_token_stream(
@@ -490,14 +482,12 @@ impl RootData {
 				return define_export_for_raw_native_function(
 					&imports,
 					&ExpT,
-					&NATIVE_BOX_WRAP_NAME,
 					func,
 				);
 			}
 			return define_export_for_static_function(
 				&imports,
 				&ExpT,
-				&NATIVE_BOX_WRAP_NAME,
 				func,
 			);
 		};
@@ -513,9 +503,9 @@ impl RootData {
 			}
 			impl #INativeClass_BuildClass for #SelfT {
 				fn build_class(env: &mut #Environment) -> #ResultWithError<#GcPtrToObject> {
-					#Ok_(#RuntimeObject::new_gc(#VariablesMap::new_direct(#HashMap::from([
+					return #Ok_(#RuntimeObject::new_gc(#VariablesMap::new_direct(#HashMap::from([
 						#(#export_tuples_for_functions),*
-					])), <#SelfT as #INativeClass>::get_parent_class(env)?, <#SelfT as #INativeClass>::NAME.into()))
+					])), <#SelfT as #INativeClass>::get_parent_class(env)?, <#SelfT as #INativeClass>::NAME.into()));
 				}
 			}
 			#[allow(non_snake_case)]

evilang_proc_macros/src/derive_build_class/mod.rs

@@ -1,10 +1,7 @@
-#[macro_use]
 extern crate darling;
 
-use proc_macro2;
-use quote::{quote, ToTokens};
+use quote::quote;
 use syn::{ItemImpl, parse_macro_input};
-use syn::spanned::Spanned;
 
 use crate::derive_build_class::RootData;
 
@@ -15,7 +12,7 @@ mod utils;
 pub fn derive_build_class(attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
 	let ic = item.clone();
 	let input = parse_macro_input!(ic as ItemImpl);
-	let (mut rv, item_impl) = RootData::parse_and_strip_extra_attributes(attr.clone(), input.clone());
+	let (rv, item_impl) = RootData::parse_and_strip_extra_attributes(attr.clone(), input.clone());
 	// println!("{0:#?}\n{1:#?}\n{2:#?}", attr, rv, input);
 	let new_impl = rv.generate_implementation();
 	// println!("{}", new_impl.to_string());

evilang_proc_macros/src/lib.rs

@@ -5,7 +5,6 @@ class Point {
 	}
 
 	fn calc(this) {
-		debug(this.x);
 		return this.x + this.y;
 	}
 }

resources/tests/import_test/sub/point.evil

@@ -1,6 +1,4 @@
-use evilang_lib::interpreter::runtime_values::PrimitiveValue;
-
-use crate::common::{run_asserts_in_file, TestData, TestRes};
+use crate::common::{run_asserts_in_file, TestRes};
 
 mod common;