From 9a0dd553d122c3e44a7123c00ff59cbaee21a66a Mon Sep 17 00:00:00 2001 From: "2038975825@qq.com" <2038975825@qq.com> Date: Tue, 28 Mar 2023 01:38:24 +0800 Subject: [PATCH 1/2] refactor:fix clippy --- immix/src/allocator/big_obj_allocator.rs | 38 +-- immix/src/allocator/thread_local_allocator.rs | 7 +- immix/src/block.rs | 2 +- immix/src/collector.rs | 2 +- pl_linker/src/linker.rs | 77 +++--- src/ast/builder/llvmbuilder.rs | 89 +++---- src/ast/builder/mod.rs | 3 +- src/ast/builder/no_op_builder.rs | 7 +- src/ast/compiler.rs | 19 +- src/ast/ctx.rs | 205 +++++++-------- src/ast/diag.rs | 111 ++++---- src/ast/fmt.rs | 21 +- src/ast/macros.rs | 10 +- src/ast/node/comment.rs | 2 +- src/ast/node/control.rs | 24 +- src/ast/node/function.rs | 58 ++-- src/ast/node/global.rs | 10 +- src/ast/node/implement.rs | 59 ++--- src/ast/node/interface.rs | 14 +- src/ast/node/macro_nodes.rs | 13 +- src/ast/node/mod.rs | 56 ++-- src/ast/node/operator.rs | 76 +++--- src/ast/node/pkg.rs | 24 +- src/ast/node/pointer.rs | 14 +- src/ast/node/primary.rs | 73 +++--- src/ast/node/program.rs | 22 +- src/ast/node/ret.rs | 6 +- src/ast/node/statement.rs | 10 +- src/ast/node/string_literal.rs | 2 +- src/ast/node/types.rs | 119 +++++---- src/ast/plmod.rs | 52 ++-- src/ast/pltype.rs | 248 +++++++++--------- src/ast/range.rs | 2 +- src/ast/test.rs | 6 +- src/ast/tokens.rs | 1 + src/flow/mod.rs | 12 +- src/flow/test.rs | 8 +- src/lsp/mem_docs.rs | 9 +- src/lsp/mod.rs | 10 +- src/lsp/text.rs | 2 +- src/main.rs | 7 +- src/nomparser/array.rs | 4 +- src/nomparser/constval.rs | 4 +- src/nomparser/expression.rs | 21 +- src/nomparser/function.rs | 5 +- src/nomparser/helper.rs | 5 +- src/nomparser/identifier.rs | 10 +- src/nomparser/mod.rs | 6 +- src/nomparser/pkg.rs | 8 +- src/nomparser/program.rs | 12 +- src/nomparser/string_literal.rs | 6 +- src/nomparser/structure.rs | 7 +- src/nomparser/types.rs | 9 +- src/utils/plc_new.rs | 2 +- src/utils/read_config.rs | 48 ++-- 55 files changed, 816 insertions(+), 861 deletions(-) diff --git a/immix/src/allocator/big_obj_allocator.rs b/immix/src/allocator/big_obj_allocator.rs index 49af71adb..73c1d278d 100644 --- a/immix/src/allocator/big_obj_allocator.rs +++ b/immix/src/allocator/big_obj_allocator.rs @@ -56,24 +56,28 @@ impl BigObjAllocator { for i in 0..self.unused_chunks.len() { let unused_obj = self.unused_chunks[i]; let unused_size = unsafe { (*unused_obj).size }; - if unused_size == size { - self.unused_chunks.remove(i); - // self.mmap.commit(unused_obj as *mut u8, size); - println!( - "get_chunk: {:p}[reused {}/{}]", - unused_obj, size, unused_size - ); - return unused_obj; - } else if unused_size > size { - let ptr = unsafe { (unused_obj as *mut u8).add(unused_size - size) }; - let new_obj = BigObj::new(ptr, size); - unsafe { - (*unused_obj).size -= size; + match unused_size.cmp(&size) { + std::cmp::Ordering::Less => {} + std::cmp::Ordering::Equal => { + self.unused_chunks.remove(i); + // self.mmap.commit(unused_obj as *mut u8, size); + println!( + "get_chunk: {:p}[reused {}/{}]", + unused_obj, size, unused_size + ); + return unused_obj; } - // self.mmap.commit(new_obj as *mut BigObj as *mut u8, size); - println!("get_chunk: {:p}[reused {}/{}]", new_obj, size, unused_size); - return new_obj; - } + std::cmp::Ordering::Greater => { + let ptr = unsafe { (unused_obj as *mut u8).add(unused_size - size) }; + let new_obj = BigObj::new(ptr, size); + unsafe { + (*unused_obj).size -= size; + } + // self.mmap.commit(new_obj as *mut BigObj as *mut u8, size); + println!("get_chunk: {:p}[reused {}/{}]", new_obj, size, unused_size); + return new_obj; + } + }; } let chunk = self.alloc_chunk(size).unwrap(); diff --git a/immix/src/allocator/thread_local_allocator.rs b/immix/src/allocator/thread_local_allocator.rs index bbdabf5f4..7bc197769 100644 --- a/immix/src/allocator/thread_local_allocator.rs +++ b/immix/src/allocator/thread_local_allocator.rs @@ -223,11 +223,10 @@ impl ThreadLocalAllocator { let uf = self.recyclable_blocks.pop_front().unwrap(); self.unavailable_blocks.push(uf); let ff = self.recyclable_blocks.front(); - if ff.is_none() { - // recycle blocks全用光了 - return self.alloc(size, obj_type); + if let Some(ff) = ff { + f = ff; } else { - f = ff.unwrap() + return self.alloc(size, obj_type); } } } diff --git a/immix/src/block.rs b/immix/src/block.rs index baa1b27a4..54db95fec 100644 --- a/immix/src/block.rs +++ b/immix/src/block.rs @@ -233,7 +233,7 @@ impl Block { // 未使用或者未标记 if !self.line_map[idx].get_used() || (self.line_map[idx] & 0b10 == 0 //即使标记位为0，也有可能是被标记的对象数据体 - && (!marked || (marked && self.line_map[idx] & 0b10000010 == 0b10000000))) + && (!marked || self.line_map[idx] & 0b10000010 == 0b10000000)) { len += 1; self.line_map[idx] &= 0; diff --git a/immix/src/collector.rs b/immix/src/collector.rs index ec3ba596d..7809c349e 100644 --- a/immix/src/collector.rs +++ b/immix/src/collector.rs @@ -176,7 +176,7 @@ impl Collector { .as_mut() .unwrap() .alloc(size, obj_type); - debug_assert!(ptr.is_null() == false); + debug_assert!(!ptr.is_null()); ptr } } diff --git a/pl_linker/src/linker.rs b/pl_linker/src/linker.rs index 07b6d0089..c498d3430 100644 --- a/pl_linker/src/linker.rs +++ b/pl_linker/src/linker.rs @@ -226,13 +226,7 @@ impl Linker for Ld64Linker { // use ld for default linker, as lld has a bug affcting backtrace on arm64 target // https://github.com/rust-lang/backtrace-rs/issues/150 let re = Command::new("ld").args(&self.args).output(); - if re.is_err() { - println!("ld not found, try to link with lld, this may break gc(https://github.com/rust-lang/backtrace-rs/issues/150)"); - lld_rs::link(lld_rs::LldFlavor::MachO, &self.args) - .ok() - .map_err(LinkerError::LinkError) - } else { - let re = re.unwrap(); + if let Ok(re) = re { if !re.status.success() { eprintln!( "link failed\nargs: {:?}\nld stdout: {}, stderr: {}", @@ -244,6 +238,11 @@ impl Linker for Ld64Linker { } else { Ok(()) } + } else { + println!("ld not found, try to link with lld, this may break gc(https://github.com/rust-lang/backtrace-rs/issues/150)"); + lld_rs::link(lld_rs::LldFlavor::MachO, &self.args) + .ok() + .map_err(LinkerError::LinkError) } } else { lld_rs::link(lld_rs::LldFlavor::MachO, &self.args) @@ -319,14 +318,7 @@ impl Linker for MsvcLinker { let re = Command::new(linker.expect("failed to find link.exe")) .args(&self.args) .output(); - - if re.is_err() { - return Err(LinkerError::LinkError(format!( - "link failed: {:?}", - re.err() - ))); - } else { - let re = re.unwrap(); + if let Ok(re) = re { if !re.status.success() { eprintln!( "link failed\nargs: {:?}\nld stdout: {}, stderr: {}", @@ -338,6 +330,11 @@ impl Linker for MsvcLinker { } else { Ok(()) } + } else { + Err(LinkerError::LinkError(format!( + "link failed: {:?}", + re.err() + ))) } } @@ -388,33 +385,29 @@ fn get_win_sdk_lib_paths() -> (Option, Vec) { }); let sdkroot = PathBuf::from(r"C:\Program Files (x86)\Windows Kits\"); assert!(sdkroot.is_dir(), "Windows SDK not found"); - for dir in sdkroot.read_dir().unwrap() { - if let Ok(dir) = dir { - if dir.path().is_symlink() || !dir.path().is_dir() { - continue; - } - let mut p = dir.path(); - p.push("Lib"); - if p.is_dir() { - for d in p.read_dir().unwrap() { - if let Ok(d) = d { - if d.path().is_dir() { - let mut p = d.path(); - p.push("ucrt\\x64"); - if p.exists() { - paths.push(p); - } - let mut p = d.path(); - p.push("um\\x64"); - if p.exists() { - paths.push(p); - } - if paths.len() == 4 { - return (linker_path, paths); - } else { - paths = paths[0..2].to_vec(); - } - } + for dir in sdkroot.read_dir().unwrap().flatten() { + if dir.path().is_symlink() || !dir.path().is_dir() { + continue; + } + let mut p = dir.path(); + p.push("Lib"); + if p.is_dir() { + for d in p.read_dir().unwrap().flatten() { + if d.path().is_dir() { + let mut p = d.path(); + p.push("ucrt\\x64"); + if p.exists() { + paths.push(p); + } + let mut p = d.path(); + p.push("um\\x64"); + if p.exists() { + paths.push(p); + } + if paths.len() == 4 { + return (linker_path, paths); + } else { + paths = paths[0..2].to_vec(); } } } diff --git a/src/ast/builder/llvmbuilder.rs b/src/ast/builder/llvmbuilder.rs index bcef53a54..5edea82f9 100644 --- a/src/ast/builder/llvmbuilder.rs +++ b/src/ast/builder/llvmbuilder.rs @@ -51,7 +51,7 @@ const DW_ATE_SIGNED: u32 = 0x05; const DW_ATE_UNSIGNED: u32 = 0x07; static ID: AtomicI64 = AtomicI64::new(0); // const DW_TAG_REFERENCE_TYPE: u32 = 16; -fn get_dw_ate_encoding<'a, 'ctx>(pritp: &PriType) -> u32 { +fn get_dw_ate_encoding(pritp: &PriType) -> u32 { match pritp { PriType::I8 | PriType::I16 | PriType::I32 | PriType::I64 | PriType::I128 => DW_ATE_SIGNED, PriType::U8 | PriType::U16 | PriType::U32 | PriType::U64 | PriType::U128 => DW_ATE_UNSIGNED, @@ -70,7 +70,7 @@ pub struct MemberType<'ctx> { pub ptr_depth: usize, } -fn get_nth_mark_fn<'ctx>(f: FunctionValue<'ctx>, n: u32) -> CallableValue<'ctx> { +fn get_nth_mark_fn(f: FunctionValue, n: u32) -> CallableValue { f.get_nth_param(n) .unwrap() .into_pointer_value() @@ -217,7 +217,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { size_val, ) .unwrap(); - if let PLType::STRUCT(_) = pltype { + if let PLType::Struct(_) = pltype { let f = self.get_or_insert_st_visit_fn_handle(&p); let i = self.builder.build_ptr_to_int( f.as_global_value().as_pointer_value(), @@ -226,7 +226,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { ); let vtable = self.builder.build_struct_gep(p, 0, "vtable").unwrap(); self.builder.build_store(vtable, i); - } else if let PLType::ARR(tp) = pltype { + } else if let PLType::Arr(tp) = pltype { let f = self.gen_or_get_arr_visit_function(ctx, tp); let i = self.builder.build_ptr_to_int( f.as_global_value().as_pointer_value(), @@ -236,16 +236,16 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { let vtable = self.builder.build_struct_gep(p, 0, "vtable").unwrap(); self.builder.build_store(vtable, i); } - declare.map(|p| { + if let Some(p) = declare { self.build_dbg_location(p); self.insert_var_declare( name, p, - &PLType::POINTER(Arc::new(RefCell::new(pltype.clone()))), + &PLType::Pointer(Arc::new(RefCell::new(pltype.clone()))), self.get_llvm_value_handle(&stack_root.as_any_value_enum()), ctx, ); - }); + } let v_stack = self.get_llvm_value_handle(&stack_root.as_any_value_enum()); let v_heap = self.get_llvm_value_handle(&p.as_any_value_enum()); self.heap_stack_map.borrow_mut().insert(v_heap, v_stack); @@ -453,17 +453,17 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { let visit_complex_f = get_nth_mark_fn(f, 3); let visit_trait_f = get_nth_mark_fn(f, 4); match &*v.element_type.borrow() { - PLType::ARR(_) | PLType::STRUCT(_) => { + PLType::Arr(_) | PLType::Struct(_) => { // call the visit_complex function self.builder .build_call(visit_complex_f, &[visitor.into(), elm.into()], "call"); } - PLType::POINTER(_) => { + PLType::Pointer(_) => { // call the visit_ptr function self.builder .build_call(visit_ptr_f, &[visitor.into(), elm.into()], "call"); } - PLType::TRAIT(_) => { + PLType::Trait(_) => { // call the visit_trait function self.builder .build_call(visit_trait_f, &[visitor.into(), elm.into()], "call"); @@ -543,10 +543,8 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { false, ); let fn_type = ftp; - let fn_value = self - .module - .add_function(&llvmname, fn_type, Some(Linkage::External)); - fn_value + self.module + .add_function(&llvmname, fn_type, Some(Linkage::External)) } fn get_fn_type(&self, fnvalue: &FNValue, ctx: &mut Ctx<'a>) -> FunctionType<'ctx> { @@ -585,7 +583,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { /// used in code generation fn get_basic_type_op(&self, pltp: &PLType, ctx: &mut Ctx<'a>) -> Option> { match pltp { - PLType::GENERIC(g) => match &g.curpltype { + PLType::Generic(g) => match &g.curpltype { Some(pltype) => self.get_basic_type_op(&pltype.borrow(), ctx), None => Some({ let name = &format!("__placeholder__{}", g.name); @@ -601,23 +599,23 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { .into() }), }, - PLType::FN(f) => Some( + PLType::Fn(f) => Some( self.get_fn_type(f, ctx) .ptr_type(AddressSpace::default()) .as_basic_type_enum(), ), - PLType::STRUCT(s) => Some(self.struct_type(s, ctx).as_basic_type_enum()), - PLType::TRAIT(s) => Some(self.struct_type(s, ctx).as_basic_type_enum()), - PLType::ARR(a) => Some(self.arr_type(a, ctx)), - PLType::PRIMITIVE(t) => Some(self.get_pri_basic_type(t)), - PLType::VOID => None, - PLType::POINTER(p) => Some( + PLType::Struct(s) => Some(self.struct_type(s, ctx).as_basic_type_enum()), + PLType::Trait(s) => Some(self.struct_type(s, ctx).as_basic_type_enum()), + PLType::Arr(a) => Some(self.arr_type(a, ctx)), + PLType::Primitive(t) => Some(self.get_pri_basic_type(t)), + PLType::Void => None, + PLType::Pointer(p) => Some( self.get_basic_type_op(&p.borrow(), ctx) .unwrap() .ptr_type(AddressSpace::default()) .as_basic_type_enum(), ), - PLType::PLACEHOLDER(p) => Some({ + PLType::PlaceHolder(p) => Some({ let name = &format!("__placeholder__{}", p.name); self.module .get_struct_type(name) @@ -636,8 +634,8 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { /// get the return type, which is void type or primitive type fn get_ret_type(&self, pltp: &PLType, ctx: &mut Ctx<'a>) -> RetTypeEnum<'ctx> { match pltp { - PLType::VOID => RetTypeEnum::VOID(self.context.void_type()), - _ => RetTypeEnum::BASIC(self.get_basic_type_op(pltp, ctx).unwrap()), + PLType::Void => RetTypeEnum::Void(self.context.void_type()), + _ => RetTypeEnum::Basic(self.get_basic_type_op(pltp, ctx).unwrap()), } } /// array type in fact is a struct with two fields, @@ -674,7 +672,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { .borrow_mut() .get(&*RefCell::borrow(&field_pltype).get_full_elm_name()) { - if !matches!(*RefCell::borrow(&field_pltype), PLType::POINTER(_)) { + if !matches!(*RefCell::borrow(&field_pltype), PLType::Pointer(_)) { // 出现循环引用，但是不是指针 // TODO 应该只需要一层是指针就行，目前的检查要求每一层都是指针 ctx.add_diag(field.range.new_err(ErrorCode::ILLEGAL_SELF_RECURSION)); @@ -720,17 +718,17 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { fn get_ditype(&self, pltp: &PLType, ctx: &mut Ctx<'a>) -> Option> { let td = self.targetmachine.get_target_data(); match pltp { - PLType::FN(_) => self.get_ditype(&PLType::PRIMITIVE(PriType::I64), ctx), - PLType::GENERIC(g) => { + PLType::Fn(_) => self.get_ditype(&PLType::Primitive(PriType::I64), ctx), + PLType::Generic(g) => { if g.curpltype.is_some() { let pltype = g.curpltype.as_ref().unwrap(); self.get_ditype(&pltype.clone().borrow(), ctx) } else { - self.get_ditype(&PLType::PRIMITIVE(PriType::I64), ctx) + self.get_ditype(&PLType::Primitive(PriType::I64), ctx) } } - PLType::PLACEHOLDER(_) => self.get_ditype(&PLType::PRIMITIVE(PriType::I64), ctx), - PLType::ARR(arr) => { + PLType::PlaceHolder(_) => self.get_ditype(&PLType::Primitive(PriType::I64), ctx), + PLType::Arr(arr) => { let elemdi = self.get_ditype(&arr.element_type.borrow(), ctx)?; let etp = &self .get_basic_type_op(&arr.element_type.borrow(), ctx) @@ -739,7 +737,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { let size = td.get_bit_size(etp) * arr.size as u64; let align = td.get_preferred_alignment(etp); let st_size = td.get_bit_size(&arr_st_tp); - let vtabledi = self.get_ditype(&PLType::PRIMITIVE(PriType::U64), ctx)?; + let vtabledi = self.get_ditype(&PLType::Primitive(PriType::U64), ctx)?; let offset = td.offset_of_element(&arr_st_tp, 0).unwrap(); let vtabletp = self.dibuilder.create_member_type( self.diunit.get_file().as_debug_info_scope(), @@ -787,7 +785,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { .as_type(); Some(st) } - PLType::STRUCT(x) | PLType::TRAIT(x) => { + PLType::Struct(x) | PLType::Trait(x) => { let sttp = self.struct_type(x, ctx); // 若已经生成过，直接查表返回 if RefCell::borrow(&self.ditypes).contains_key(&x.get_st_full_name()) { @@ -876,7 +874,7 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { self.ditypes.borrow_mut().insert(x.get_st_full_name(), st); Some(st) } - PLType::PRIMITIVE(pt) => { + PLType::Primitive(pt) => { let mut size = td.get_bit_size(&self.get_pri_basic_type(pt)); if size < 8 { size = 8; // walkaround for lldb issue @@ -888,8 +886,8 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { .as_type(), ); } - PLType::VOID => None, - PLType::POINTER(p) => { + PLType::Void => None, + PLType::Pointer(p) => { let elemdi = self.get_ditype(&p.borrow(), ctx)?; let etp = &self .get_basic_type_op(&p.borrow(), ctx) @@ -916,10 +914,8 @@ impl<'a, 'ctx> LLVMBuilder<'a, 'ctx> { return v; } let fn_type = self.get_fn_type(pltp, ctx); - let fn_value = self - .module - .add_function(&llvmname, fn_type, Some(Linkage::External)); - fn_value + self.module + .add_function(&llvmname, fn_type, Some(Linkage::External)) } fn struct_type(&self, pltp: &STType, ctx: &mut Ctx<'a>) -> StructType<'ctx> { let st = self.module.get_struct_type(&pltp.get_st_full_name()); @@ -1527,7 +1523,7 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> { for para in paralist.iter() { let pltype = para.typenode.get_type(child, &self.clone().into())?; match &*pltype.borrow() { - PLType::VOID => { + PLType::Void => { return Err(child .add_diag(para.range.new_err(ErrorCode::VOID_TYPE_CANNOT_BE_PARAMETER))) } @@ -1571,6 +1567,7 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> { self.builder.build_return(None); } } + #[allow(clippy::too_many_arguments)] fn create_parameter_variable( &self, fnvalue: &FNValue, @@ -1588,7 +1585,7 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> { self.diunit.get_file(), pos.line as u32, self.get_ditype( - &PLType::POINTER( + &PLType::Pointer( fnvalue.fntype.param_pltypes[i] .get_type(child, &self.clone().into()) .unwrap(), @@ -1699,28 +1696,28 @@ impl<'a, 'ctx> IRBuilder<'a, 'ctx> for LLVMBuilder<'a, 'ctx> { let visit_trait_f = get_nth_mark_fn(f, 4); let f = self.builder.build_struct_gep(st, i, "gep").unwrap(); // 指针类型，递归调用visit函数 - if let PLType::POINTER(_) = field_pltp { + if let PLType::Pointer(_) = field_pltp { let ptr = f; let casted = self.builder.build_bitcast(ptr, i8ptrtp, "casted_arg"); self.builder .build_call(visit_ptr_f, &[visitor.into(), casted.into()], "call"); } // 数组类型，递归调用visit函数 - else if let PLType::ARR(_) = field_pltp { + else if let PLType::Arr(_) = field_pltp { let ptr = f; let casted = self.builder.build_bitcast(ptr, i8ptrtp, "casted_arg"); self.builder .build_call(visit_complex_f, &[visitor.into(), casted.into()], "call"); } // 结构体类型，递归调用visit函数 - else if let PLType::STRUCT(_) = field_pltp { + else if let PLType::Struct(_) = field_pltp { let ptr = f; let casted = self.builder.build_bitcast(ptr, i8ptrtp, "casted_arg"); self.builder .build_call(visit_complex_f, &[visitor.into(), casted.into()], "call"); } // trait类型，递归调用visit函数 - else if let PLType::TRAIT(_) = field_pltp { + else if let PLType::Trait(_) = field_pltp { let ptr = f; let casted = self.builder.build_bitcast(ptr, i8ptrtp, "casted_arg"); self.builder diff --git a/src/ast/builder/mod.rs b/src/ast/builder/mod.rs index d407f48d3..41fbf57b0 100644 --- a/src/ast/builder/mod.rs +++ b/src/ast/builder/mod.rs @@ -80,6 +80,7 @@ pub trait IRBuilder<'a, 'ctx> { ) -> Result<(), PLDiag>; fn clear_insertion_position(&self); fn const_string(&self, s: &str) -> ValueHandle; + #[allow(clippy::too_many_arguments)] fn create_parameter_variable( &self, fntype: &FNValue, @@ -190,7 +191,7 @@ pub trait IRBuilder<'a, 'ctx> { pub type ValueHandle = usize; pub type BlockHandle = usize; - +#[allow(clippy::upper_case_acronyms)] #[enum_dispatch(IRBuilder)] pub enum BuilderEnum<'a, 'ctx> { LLVM(LLVMBuilder<'a, 'ctx>), diff --git a/src/ast/builder/no_op_builder.rs b/src/ast/builder/no_op_builder.rs index 5ab39c250..042237a22 100644 --- a/src/ast/builder/no_op_builder.rs +++ b/src/ast/builder/no_op_builder.rs @@ -8,14 +8,9 @@ use crate::ast::{ use super::{IRBuilder, ValueHandle}; /// 什么都不干的builder，用来测试和lsp模式 +#[derive(Default)] pub struct NoOpBuilder {} -impl NoOpBuilder { - pub fn new() -> Self { - Self {} - } -} - impl<'a, 'ctx> IRBuilder<'a, 'ctx> for NoOpBuilder { fn bitcast( &self, diff --git a/src/ast/compiler.rs b/src/ast/compiler.rs index f61d0c0a8..89bdd0d8f 100644 --- a/src/ast/compiler.rs +++ b/src/ast/compiler.rs @@ -56,7 +56,7 @@ impl Default for HashOptimizationLevel { } impl HashOptimizationLevel { - pub fn to_llvm(&self) -> OptimizationLevel { + pub fn to_llvm(self) -> OptimizationLevel { match self { HashOptimizationLevel::None => OptimizationLevel::None, HashOptimizationLevel::Less => OptimizationLevel::Less, @@ -222,7 +222,7 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) { for e in errs.iter() { let mut path = e.0.clone(); for e in e.1.iter() { - if let Some(src) = e.source.clone() { + if let Some(src) = e.raw.source.clone() { path = src; } e.print( @@ -243,14 +243,14 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) { "{}", format!("compile failed: there is {} error", errs_num).bright_red() ); - println!("{}", format!("{}", dot::ERROR)); + println!("{}", dot::ERROR); return; } log::error!( "{}", format!("compile failed: there are {} errors", errs_num).bright_red() ); - println!("{}", format!("{}", dot::TOOMANYERROR)); + println!("{}", dot::TOOMANYERROR); return; } } @@ -342,12 +342,11 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) { return; } let root = root.unwrap(); - let vmpath; - if cfg!(target_os = "windows") { + let vmpath = if cfg!(target_os = "windows") { // cmd = Command::new("clang"); // f = out.clone(); fo.push_str(".exe"); - vmpath = format!("{}\\vm.lib", root); + format!("{}\\vm.lib", root) // cmd.arg("-lws2_32") // .arg("-lbcrypt") // .arg("-luserenv") @@ -355,13 +354,13 @@ pub fn compile(db: &dyn Db, docs: MemDocsInput, out: String, op: Options) { } else { let mut p = PathBuf::from(&root); p.push("libvm.a"); - vmpath = dunce::canonicalize(&p) + dunce::canonicalize(&p) .expect("failed to find libvm") .to_str() .unwrap() - .to_string(); + .to_string() // cmd.arg("-pthread").arg("-ldl"); - } + }; for o in objs { t.add_object(o.as_path()).unwrap(); } diff --git a/src/ast/ctx.rs b/src/ast/ctx.rs index 819a4b8ef..3aa13197f 100644 --- a/src/ast/ctx.rs +++ b/src/ast/ctx.rs @@ -59,6 +59,13 @@ use std::path::Path; use std::path::PathBuf; use std::sync::Arc; +#[derive(Clone)] +pub struct PLSymbol { + pub value: ValueHandle, + pub pltype: Arc>, + pub range: Range, + pub refs: Option>>, +} /// # Ctx /// Context for code generation pub struct Ctx<'a> { @@ -75,15 +82,7 @@ pub struct Ctx<'a> { pub return_block: Option<(BlockHandle, Option)>, // the block to jump to when return and value pub errs: &'a RefCell>, // diagnostic list pub edit_pos: Option, // lsp params - pub table: FxHashMap< - String, - ( - ValueHandle, - Arc>, - Range, - Arc>, - ), - >, // variable table + pub table: FxHashMap, // variable table pub config: Config, // config pub db: &'a dyn Db, pub rettp: Option>>, @@ -228,7 +227,7 @@ impl<'a, 'ctx> Ctx<'a> { builder: &'b BuilderEnum<'a, 'ctx>, ) -> Result { let (st_pltype, st_value) = self.auto_deref(st_pltype, st_value, builder); - if let (PLType::TRAIT(t), PLType::STRUCT(st)) = + if let (PLType::Trait(t), PLType::Struct(st)) = (&*trait_pltype.borrow(), &*st_pltype.borrow()) { if !st.implements_trait(t, &self.plmod) { @@ -254,7 +253,7 @@ impl<'a, 'ctx> Ctx<'a> { let st_value = builder.bitcast( self, st_value, - &PLType::POINTER(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::I64)))), + &PLType::Pointer(Arc::new(RefCell::new(PLType::Primitive(PriType::I64)))), "traitcast_tmp", ); let v_ptr = builder.build_struct_gep(trait_handle, 1, "v_tmp").unwrap(); @@ -267,6 +266,7 @@ impl<'a, 'ctx> Ctx<'a> { builder.build_store(type_hash, hash); return Ok(trait_handle); } + #[allow(clippy::needless_return)] return Err(mismatch_err!( self, st_range, @@ -279,7 +279,7 @@ impl<'a, 'ctx> Ctx<'a> { self.function = Some(builder.add_function( &self.plmod.get_full_name("__init_global"), &[], - PLType::VOID, + PLType::Void, self, )); self.init_func = self.function; @@ -315,28 +315,24 @@ impl<'a, 'ctx> Ctx<'a> { &'b self, name: &str, builder: &'b BuilderEnum<'a, 'ctx>, - ) -> Option<( - ValueHandle, - Arc>, - Range, - Option>>, - bool, - )> { + ) -> Option<(PLSymbol, bool)> { let v = self.table.get(name); - if let Some((h, pltype, range, refs)) = v { - return Some((*h, pltype.clone(), *range, Some(refs.clone()), false)); + if let Some(symbol) = v { + return Some((symbol.clone(), false)); } if let Some(father) = self.father { return father.get_symbol(name, builder); } if let Some(GlobalVar { tp: pltype, range }) = self.plmod.get_global_symbol(name) { return Some(( - builder - .get_global_var_handle(&self.plmod.get_full_name(name)) - .unwrap(), - pltype.clone(), - *range, - None, + PLSymbol { + value: builder + .get_global_var_handle(&self.plmod.get_full_name(name)) + .unwrap(), + pltype: pltype.clone(), + range: *range, + refs: None, + }, true, )); } @@ -359,7 +355,15 @@ impl<'a, 'ctx> Ctx<'a> { self.plmod.add_global_symbol(name, pltype, range)?; } else { let refs = Arc::new(RefCell::new(vec![])); - self.table.insert(name, (pv, pltype, range, refs.clone())); + self.table.insert( + name, + PLSymbol { + value: pv, + pltype, + range, + refs: Some(refs.clone()), + }, + ); self.set_if_refs(refs, range); } self.send_if_go_to_def(range, range, self.plmod.path.clone()); @@ -392,7 +396,7 @@ impl<'a, 'ctx> Ctx<'a> { } pub fn init_global<'b>(&'b mut self, builder: &'b BuilderEnum<'a, 'ctx>) { let mut set: FxHashSet = FxHashSet::default(); - for (_, sub) in &self.plmod.clone().submods { + for sub in self.plmod.clone().submods.values() { self.init_global_walk(sub, &mut set, builder); } @@ -402,7 +406,7 @@ impl<'a, 'ctx> Ctx<'a> { .get_function(&self.plmod.get_full_name("__init_global")) .unwrap(), &[], - &PLType::VOID, + &PLType::Void, self, ); } @@ -416,12 +420,12 @@ impl<'a, 'ctx> Ctx<'a> { if set.contains(&name) { return; } - for (_, sub) in &m.submods { + for sub in m.submods.values() { self.init_global_walk(sub, set, builder); } - let f = builder.add_function(&name, &[], PLType::VOID, self); + let f = builder.add_function(&name, &[], PLType::Void, self); builder.rm_curr_debug_location(); - builder.build_call(f, &[], &PLType::VOID, self); + builder.build_call(f, &[], &PLType::Void, self); set.insert(name); } @@ -431,7 +435,7 @@ impl<'a, 'ctx> Ctx<'a> { pltype: Arc>, range: Range, ) -> Result<(), PLDiag> { - if let PLType::GENERIC(g) = &*pltype.borrow() { + if let PLType::Generic(g) = &*pltype.borrow() { if g.curpltype.is_some() { let cur = g.curpltype.as_ref().unwrap(); return self.add_type( @@ -450,7 +454,7 @@ impl<'a, 'ctx> Ctx<'a> { Ok(()) } pub fn add_type_without_check(&mut self, pltype: Arc>) { - if let PLType::GENERIC(_) = &*pltype.borrow() { + if let PLType::Generic(_) = &*pltype.borrow() { unreachable!() } let name = pltype.borrow().get_name(); @@ -463,7 +467,7 @@ impl<'a, 'ctx> Ctx<'a> { } pub fn add_doc_symbols(&mut self, pltype: Arc>) { match &*RefCell::borrow(&pltype) { - PLType::FN(fnvalue) => { + PLType::Fn(fnvalue) => { if !fnvalue.fntype.method { self.plmod .doc_symbols @@ -471,7 +475,7 @@ impl<'a, 'ctx> Ctx<'a> { .push(fnvalue.get_doc_symbol()) } } - PLType::STRUCT(st) => self + PLType::Struct(st) => self .plmod .doc_symbols .borrow_mut() @@ -751,11 +755,11 @@ impl<'a, 'ctx> Ctx<'a> { let mut insert_text = None; let mut command = None; let tp = match &*v.clone().borrow() { - PLType::STRUCT(s) => { + PLType::Struct(s) => { skip_if_not_modified_by!(s.modifier, TokenType::PUB); CompletionItemKind::STRUCT } - PLType::FN(fnvalue) => { + PLType::Fn(fnvalue) => { skip_if_not_modified_by!(fnvalue.fntype.modifier, TokenType::PUB); insert_text = Some(fnvalue.gen_snippet()); command = Some(Command::new( @@ -797,15 +801,15 @@ impl<'a, 'ctx> Ctx<'a> { fn get_tp_completions(&self, m: &mut FxHashMap) { for (k, f) in self.plmod.types.iter() { let tp = match &*f.borrow() { - PLType::FN(_) => continue, - PLType::ARR(_) => continue, - PLType::PLACEHOLDER(_) => CompletionItemKind::STRUCT, - PLType::GENERIC(_) => CompletionItemKind::TYPE_PARAMETER, - PLType::STRUCT(_) => CompletionItemKind::STRUCT, - PLType::TRAIT(_) => CompletionItemKind::INTERFACE, - PLType::PRIMITIVE(_) => CompletionItemKind::KEYWORD, - PLType::VOID => CompletionItemKind::KEYWORD, - PLType::POINTER(_) => todo!(), + PLType::Fn(_) => continue, + PLType::Arr(_) => continue, + PLType::PlaceHolder(_) => CompletionItemKind::STRUCT, + PLType::Generic(_) => CompletionItemKind::TYPE_PARAMETER, + PLType::Struct(_) => CompletionItemKind::STRUCT, + PLType::Trait(_) => CompletionItemKind::INTERFACE, + PLType::Primitive(_) => CompletionItemKind::KEYWORD, + PLType::Void => CompletionItemKind::KEYWORD, + PLType::Pointer(_) => todo!(), }; m.insert( k.to_string(), @@ -849,7 +853,7 @@ impl<'a, 'ctx> Ctx<'a> { let mut insert_text = None; let mut command = None; let tp = match &*f.clone().borrow() { - PLType::FN(f) => { + PLType::Fn(f) => { insert_text = Some(f.gen_snippet()); command = Some(Command::new( "trigger help".to_string(), @@ -858,14 +862,14 @@ impl<'a, 'ctx> Ctx<'a> { )); CompletionItemKind::FUNCTION } - PLType::STRUCT(_) => CompletionItemKind::STRUCT, - PLType::TRAIT(_) => CompletionItemKind::INTERFACE, - PLType::ARR(_) => CompletionItemKind::KEYWORD, - PLType::PRIMITIVE(_) => CompletionItemKind::KEYWORD, - PLType::GENERIC(_) => CompletionItemKind::STRUCT, - PLType::VOID => CompletionItemKind::KEYWORD, - PLType::POINTER(_) => todo!(), - PLType::PLACEHOLDER(_) => CompletionItemKind::STRUCT, + PLType::Struct(_) => CompletionItemKind::STRUCT, + PLType::Trait(_) => CompletionItemKind::INTERFACE, + PLType::Arr(_) => CompletionItemKind::KEYWORD, + PLType::Primitive(_) => CompletionItemKind::KEYWORD, + PLType::Generic(_) => CompletionItemKind::STRUCT, + PLType::Void => CompletionItemKind::KEYWORD, + PLType::Pointer(_) => todo!(), + PLType::PlaceHolder(_) => CompletionItemKind::STRUCT, }; if k.starts_with('|') { // skip method @@ -889,7 +893,7 @@ impl<'a, 'ctx> Ctx<'a> { } pub fn push_semantic_token(&self, range: Range, tp: SemanticTokenType, modifiers: u32) { - if self.need_highlight != 0 { + if self.need_highlight != 0 || self.in_macro { return; } self.plmod.semantic_tokens_builder.borrow_mut().push( @@ -1023,14 +1027,9 @@ impl<'a, 'ctx> Ctx<'a> { ) -> (Arc>, ValueHandle) { let mut tp = tp; let mut value = value; - loop { - match &*RefCell::borrow(&tp.clone()) { - PLType::POINTER(p) => { - tp = p.clone(); - value = builder.build_load(value, "load"); - } - _ => break, - } + while let PLType::Pointer(p) = &*tp.clone().borrow() { + tp = p.clone(); + value = builder.build_load(value, "load"); } (tp, value) } @@ -1039,13 +1038,8 @@ impl<'a, 'ctx> Ctx<'a> { /// 自动解pltype引用，有几层解几层 pub fn auto_deref_tp(&self, tp: Arc>) -> Arc> { let mut tp = tp; - loop { - match &*RefCell::borrow(&tp.clone()) { - PLType::POINTER(p) => { - tp = p.clone(); - } - _ => break, - } + while let PLType::Pointer(p) = &*tp.clone().borrow() { + tp = p.clone() } tp } @@ -1061,58 +1055,51 @@ impl<'a, 'ctx> Ctx<'a> { } // when need eq trait and sttype,the left mut be trait pub fn eq(&self, l: Arc>, r: Arc>) -> EqRes { - match (&*l.borrow(), &*r.borrow()) { - (PLType::GENERIC(l), PLType::GENERIC(r)) => { - if l == r { - return EqRes { - eq: true, - need_up_cast: false, - }; - } + if let (PLType::Generic(l), PLType::Generic(r)) = (&*l.borrow(), &*r.borrow()) { + if l == r { + return EqRes { + eq: true, + need_up_cast: false, + }; } - _ => {} } - match &mut *l.borrow_mut() { - PLType::GENERIC(l) => { - if l.curpltype.is_some() { - return self.eq(l.curpltype.as_ref().unwrap().clone(), r); - } - if l.trait_impl.is_some() { - if !self - .eq(l.trait_impl.as_ref().unwrap().clone(), r.clone()) - .eq - { - return EqRes { - eq: false, - need_up_cast: false, - }; - } - } - l.set_type(r); + if let PLType::Generic(l) = &mut *l.borrow_mut() { + if l.curpltype.is_some() { + return self.eq(l.curpltype.as_ref().unwrap().clone(), r); + } + if l.trait_impl.is_some() + && !self + .eq(l.trait_impl.as_ref().unwrap().clone(), r.clone()) + .eq + { return EqRes { - eq: true, + eq: false, need_up_cast: false, }; } - _ => {} + l.set_type(r); + return EqRes { + eq: true, + need_up_cast: false, + }; } EqRes { eq: match (&*l.borrow(), &*r.borrow()) { - (PLType::PRIMITIVE(l), PLType::PRIMITIVE(r)) => l == r, - (PLType::VOID, PLType::VOID) => true, - (PLType::POINTER(l), PLType::POINTER(r)) => self.eq(l.clone(), r.clone()).eq, - (PLType::ARR(l), PLType::ARR(r)) => { + (PLType::Primitive(l), PLType::Primitive(r)) => l == r, + (PLType::Void, PLType::Void) => true, + (PLType::Pointer(l), PLType::Pointer(r)) => self.eq(l.clone(), r.clone()).eq, + (PLType::Arr(l), PLType::Arr(r)) => { self.eq(l.get_elem_type(), r.get_elem_type()).eq && l.size == r.size } - (PLType::STRUCT(l), PLType::STRUCT(r)) => l.name == r.name && l.path == r.path, - (PLType::FN(l), PLType::FN(r)) => l == r, - (PLType::PLACEHOLDER(l), PLType::PLACEHOLDER(r)) => l == r, + (PLType::Struct(l), PLType::Struct(r)) => l.name == r.name && l.path == r.path, + (PLType::Fn(l), PLType::Fn(r)) => l == r, + (PLType::PlaceHolder(l), PLType::PlaceHolder(r)) => l == r, _ => { if l != r { let trait_pltype = l.clone(); let st_pltype = r.clone(); let st_pltype = self.auto_deref_tp(st_pltype); - if let (PLType::TRAIT(t), PLType::STRUCT(st)) = + if let (PLType::Trait(t), PLType::Struct(st)) = (&*trait_pltype.borrow(), &*st_pltype.borrow()) { return EqRes { diff --git a/src/ast/diag.rs b/src/ast/diag.rs index df7f447cc..187709fc0 100644 --- a/src/ast/diag.rs +++ b/src/ast/diag.rs @@ -13,6 +13,7 @@ macro_rules! define_error { ),*) => { #[derive(Debug, PartialEq, Clone, Copy, Eq, Hash, Default)] #[allow(non_camel_case_types, dead_code)] + #[allow(clippy::upper_case_acronyms)] pub enum ErrorCode { #[default] UNKNOWN = 114513, $($ident),* @@ -115,7 +116,8 @@ macro_rules! define_warn { $ident:ident = $string_keyword:expr ),*) => { #[derive(Debug, PartialEq, Clone, Copy, Eq, Hash, Default)] - #[allow(non_camel_case_types, dead_code)] + #[allow(non_camel_case_types)] + #[allow(clippy::upper_case_acronyms)] pub enum WarnCode { #[default] UNKNOWN = 1919809, $($ident),* @@ -163,16 +165,26 @@ use super::{ range::{Pos, Range}, }; -/// # PLDiag -/// Diagnostic for pivot-lang #[range] #[derive(Debug, Clone, Default, PartialEq, Eq, Hash)] -pub struct PLDiag { +pub struct PLLabel { + file: String, + txt: Option<(String, Vec)>, +} +#[range] +#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)] +pub struct PLDiagRaw { code: DiagCode, - help: Option>, - labels: Vec<(Range, String, Option<(String, Vec)>)>, + help: Option, + labels: Vec, pub source: Option, } +/// # PLDiag +/// Diagnostic for pivot-lang +#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)] +pub struct PLDiag { + pub raw: Box, +} const PL_DIAG_SOURCE: &str = "plsp"; @@ -188,24 +200,24 @@ impl PLDiag { let mut rb = Report::build( self.get_report_kind(), path, - self.range.start.utf8_offset(&f(db, path)), + self.raw.range.start.utf8_offset(&f(db, path)), ) - .with_code(self.code) + .with_code(self.raw.code) .with_message(self.get_msg()); - let mut labels = vec![]; - labels.push(( - self.range, - path.to_string(), - Some(("here".to_string(), vec![])), - )); + let labels = vec![PLLabel { + range: self.raw.range, + file: path.to_string(), + txt: Some(("here".to_string(), vec![])), + }]; - for (range, path, txt) in labels.iter().chain(self.labels.iter()) { + for label in labels.iter().chain(self.raw.labels.iter()) { let color = colors.next(); let mut lab; - if let Some((tpl, args)) = txt { + if let Some((tpl, args)) = &label.txt { lab = Label::new(( - path.as_str(), - range.start.utf8_offset(&f(db, path))..range.end.utf8_offset(&f(db, path)), + label.file.as_str(), + label.range.start.utf8_offset(&f(db, path)) + ..label.range.end.utf8_offset(&f(db, path)), )); let mut msg = tpl.clone(); msg = msg.format( @@ -218,46 +230,47 @@ impl PLDiag { } else { lab = Label::new(( path, - range.start.utf8_offset(&f(db, path))..range.end.utf8_offset(&f(db, path)), + label.range.start.utf8_offset(&f(db, path)) + ..label.range.end.utf8_offset(&f(db, path)), )); } rb = rb.with_label(lab.with_color(color)); } - if let Some(help) = &self.help { + if let Some(help) = &self.raw.help { rb = rb.with_help(help); } let r = rb.finish(); r.eprint(PLFileCache::new(db, Box::new(f))).unwrap(); } fn get_report_kind(&self) -> ReportKind { - match self.code { + match self.raw.code { DiagCode::Err(_) => ReportKind::Error, DiagCode::Warn(_) => ReportKind::Warning, } } pub fn is_err(&self) -> bool { - match self.code { + match self.raw.code { DiagCode::Err(_) => true, DiagCode::Warn(_) => false, } } pub fn get_msg(&self) -> String { - match self.code { + match self.raw.code { DiagCode::Err(code) => ERR_MSG[&code].to_string(), DiagCode::Warn(code) => WARN_MSG[&code].to_string(), } } pub fn get_diagnostic(&self, p: &str, diags: &mut FxHashMap>) { - let mut d = match self.code { + let mut d = match self.raw.code { DiagCode::Err(code) => Diagnostic::new_with_code_number( - self.range.to_diag_range(), + self.raw.range.to_diag_range(), DiagnosticSeverity::ERROR, code as i32, Some(PL_DIAG_SOURCE.to_string()), ERR_MSG[&code].to_string(), ), DiagCode::Warn(code) => Diagnostic::new_with_code_number( - self.range.to_diag_range(), + self.raw.range.to_diag_range(), DiagnosticSeverity::WARNING, code as i32, Some(PL_DIAG_SOURCE.to_string()), @@ -265,41 +278,43 @@ impl PLDiag { ), }; let mut labels = vec![]; - self.labels.iter().for_each(|(range, file, txt)| { + self.raw.labels.iter().for_each(|label| { let mut lab = lsp_types::DiagnosticRelatedInformation { location: lsp_types::Location { - uri: Url::from_file_path(file).unwrap(), - range: range.to_diag_range(), + uri: Url::from_file_path(&label.file).unwrap(), + range: label.range.to_diag_range(), }, message: "related source here".to_string(), }; - if let Some((tpl, args)) = txt { + if let Some((tpl, args)) = &label.txt { lab.message = tpl.clone(); lab.message = lab.message.format(args); } labels.push(lab); }); d.related_information = Some(labels); - let p = if let Some(source) = &self.source { + let p = if let Some(source) = &self.raw.source { source.clone() } else { p.to_string() }; - diags.entry(p.to_string()).or_default().push(d); + diags.entry(p).or_default().push(d); } pub fn new_error(range: Range, code: ErrorCode) -> Self { PLDiag { - range, - code: DiagCode::Err(code), - ..Default::default() + raw: Box::new(PLDiagRaw { + range, + code: DiagCode::Err(code), + ..Default::default() + }), } } pub fn set_source(&mut self, source: &str) -> &mut Self { - self.source = Some(source.to_string()); + self.raw.source = Some(source.to_string()); self } pub fn add_help(&mut self, help: &str) -> &mut Self { - self.help = Some(Box::new(help.to_string())); + self.raw.help = Some(help.to_string()); self } pub fn add_to_ctx(&self, ctx: &Ctx) -> PLDiag { @@ -315,34 +330,36 @@ impl PLDiag { &mut self, range: Range, file: String, - label: Option<(String, Vec)>, + txt: Option<(String, Vec)>, ) -> &mut Self { - self.labels.push((range, file, label)); + self.raw.labels.push(PLLabel { file, txt, range }); self } pub fn set_range(&mut self, range: Range) -> &mut Self { - self.range = range; + self.raw.range = range; self } pub fn new_warn(range: Range, code: WarnCode) -> Self { PLDiag { - range, - code: DiagCode::Warn(code), - ..Default::default() + raw: Box::new(PLDiagRaw { + range, + code: DiagCode::Warn(code), + ..Default::default() + }), } } } pub struct PLFileCache<'a> { db: &'a dyn Db, - f: Box Source>, + f: PLDb2Src<'a>, cache: FxHashMap, } - +type PLDb2Src<'a> = Box Source>; impl<'a> PLFileCache<'a> { - pub fn new(db: &'a dyn Db, f: Box Source>) -> Self { + pub fn new(db: &'a dyn Db, f: PLDb2Src<'a>) -> Self { Self { db, f, @@ -354,7 +371,7 @@ impl<'a> PLFileCache<'a> { impl<'a> Cache<&str> for PLFileCache<'a> { fn fetch(&mut self, id: &&str) -> Result<&Source, Box> { if !self.cache.contains_key(*id) { - self.cache.insert((*id).to_string(), (self.f)(self.db, *id)); + self.cache.insert((*id).to_string(), (self.f)(self.db, id)); } Ok(self.cache.get(*id).unwrap()) } diff --git a/src/ast/fmt.rs b/src/ast/fmt.rs index 44408f2e5..25b8020d3 100644 --- a/src/ast/fmt.rs +++ b/src/ast/fmt.rs @@ -45,7 +45,7 @@ impl FmtBuilder { prefix: " ", } } - pub fn generate_node(node: &Box) -> String { + pub fn generate_node(node: &TypeNodeEnum) -> String { let mut b = FmtBuilder::new(); node.format(&mut b); b.generate() @@ -198,11 +198,11 @@ impl FmtBuilder { self.space(); self.l_brace(); self.add_tab(); - for (field, _i, modi) in &node.fields { - if let Some((modi, _)) = modi { + for field in &node.fields { + if let Some((modi, _)) = field.modifier { self.token(modi.get_str()); } - field.format(self); + field.id.format(self); } self.enter(); self.sub_tab(); @@ -297,9 +297,8 @@ impl FmtBuilder { pub fn parse_statements_node(&mut self, node: &StatementsNode) { self.enter(); for statement in &node.statements { - match &**statement { - NodeEnum::Empty(_) => continue, - _ => {} + if let NodeEnum::Empty(_) = &**statement { + continue; } self.prefix(); statement.format(self); @@ -343,8 +342,8 @@ impl FmtBuilder { } pub fn parse_pointer_op_node(&mut self, node: &PointerOpNode) { match node.op { - PointerOpEnum::ADDR => self.and(), - PointerOpEnum::DEREF => self.asterisk(), + PointerOpEnum::Addr => self.and(), + PointerOpEnum::Deref => self.asterisk(), } node.value.format(self); } @@ -553,9 +552,9 @@ impl FmtBuilder { self.token(node.value.to_string().as_str()); } pub fn parse_num_node(&mut self, node: &NumNode) { - if let Num::INT(x) = node.value { + if let Num::Int(x) = node.value { self.token(x.to_string().as_str()); - } else if let Num::FLOAT(x) = node.value { + } else if let Num::Float(x) = node.value { self.token(x.to_string().as_str()); } else { panic!("not implemented") diff --git a/src/ast/macros.rs b/src/ast/macros.rs index 05eb117ff..73b38a79b 100644 --- a/src/ast/macros.rs +++ b/src/ast/macros.rs @@ -26,7 +26,7 @@ macro_rules! add_basic_types { ),+) => { $( paste::paste! { - let [] = PLType::PRIMITIVE(PriType::[<$ident:upper>]); + let [] = PLType::Primitive(PriType::[<$ident:upper>]); $map .insert(stringify!($ident).to_string(), Arc::new(RefCell::new( []))); } @@ -45,7 +45,7 @@ macro_rules! generic_impl { } for (_, v) in self.generic_map.iter() { match &*v.clone().borrow() { - PLType::GENERIC(g) => { + PLType::Generic(g) => { if g.curpltype.is_none() { return false; } @@ -61,8 +61,8 @@ macro_rules! generic_impl { .generic_map .iter() .map(|(k, pltype)| { - if let PLType::GENERIC(g) = &*pltype.borrow() { - return (k.clone(), Arc::new(RefCell::new(PLType::GENERIC(g.clone())))); + if let PLType::Generic(g) = &*pltype.borrow() { + return (k.clone(), Arc::new(RefCell::new(PLType::Generic(g.clone())))); } unreachable!() }) @@ -70,7 +70,7 @@ macro_rules! generic_impl { res.generic_map .iter() .for_each(|(_, v)| match &mut *v.clone().borrow_mut() { - PLType::GENERIC(g) => { + PLType::Generic(g) => { g.clear_type(); } _ => unreachable!(), diff --git a/src/ast/node/comment.rs b/src/ast/node/comment.rs index 99c51208e..b25342945 100644 --- a/src/ast/node/comment.rs +++ b/src/ast/node/comment.rs @@ -24,6 +24,6 @@ impl Node for CommentNode { _builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { ctx.push_semantic_token(self.range, SemanticTokenType::COMMENT, 0); - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } diff --git a/src/ast/node/control.rs b/src/ast/node/control.rs index 6760486b9..0cdb1fc15 100644 --- a/src/ast/node/control.rs +++ b/src/ast/node/control.rs @@ -44,7 +44,7 @@ impl Node for IfNode { ctx.position_at_end(cond_block, builder); let condrange = self.cond.range(); let (cond, pltype, _) = self.cond.emit(ctx, builder)?; - if pltype.is_none() || !pltype.clone().unwrap().borrow().is(&PriType::BOOL) { + if pltype.is_none() || !pltype.unwrap().borrow().is(&PriType::BOOL) { return Err(ctx.add_diag( condrange .new_err(ErrorCode::IF_CONDITION_MUST_BE_BOOL) @@ -69,13 +69,13 @@ impl Node for IfNode { builder.build_unconditional_branch(after_block); } if then_terminator.is_return() && else_terminator.is_return() { - TerminatorEnum::RETURN + TerminatorEnum::Return } else { - TerminatorEnum::NONE + TerminatorEnum::None } } else { builder.build_unconditional_branch(after_block); - TerminatorEnum::NONE + TerminatorEnum::None }; ctx.position_at_end(after_block, builder); if terminator.is_return() { @@ -120,7 +120,7 @@ impl Node for WhileNode { let condrange = self.cond.range(); let start = self.cond.range().start; let (cond, pltype, _) = self.cond.emit(ctx, builder)?; - if pltype.is_none() || !pltype.clone().unwrap().borrow().is(&PriType::BOOL) { + if pltype.is_none() || !pltype.unwrap().borrow().is(&PriType::BOOL) { return Err(ctx.add_diag(condrange.new_err(ErrorCode::WHILE_CONDITION_MUST_BE_BOOL))); } let cond = ctx.try_load2var(condrange, cond.unwrap(), builder)?; @@ -136,9 +136,9 @@ impl Node for WhileNode { None, None, if terminator.is_return() { - TerminatorEnum::RETURN + TerminatorEnum::Return } else { - TerminatorEnum::NONE + TerminatorEnum::None }, )) } @@ -194,7 +194,7 @@ impl Node for ForNode { let condrange = self.cond.range(); let cond_start = self.cond.range().start; let (cond, pltype, _) = self.cond.emit(ctx, builder)?; - if pltype.is_none() || !pltype.clone().unwrap().borrow().is(&PriType::BOOL) { + if pltype.is_none() || !pltype.unwrap().borrow().is(&PriType::BOOL) { return Err(ctx.add_diag(condrange.new_err(ErrorCode::FOR_CONDITION_MUST_BE_BOOL))); } let cond = ctx.try_load2var(condrange, cond.unwrap(), builder)?; @@ -217,9 +217,9 @@ impl Node for ForNode { None, None, if terminator.is_return() { - TerminatorEnum::RETURN + TerminatorEnum::Return } else { - TerminatorEnum::NONE + TerminatorEnum::None }, )) } @@ -250,7 +250,7 @@ impl Node for BreakNode { let err = ctx.add_diag(self.range.new_err(ErrorCode::BREAK_MUST_BE_IN_LOOP)); return Err(err); } - Ok((None, None, TerminatorEnum::BREAK)) + Ok((None, None, TerminatorEnum::Break)) } } @@ -278,6 +278,6 @@ impl Node for ContinueNode { let err = ctx.add_diag(self.range.new_err(ErrorCode::CONTINUE_MUST_BE_IN_LOOP)); return Err(err); } - Ok((None, None, TerminatorEnum::CONTINUE)) + Ok((None, None, TerminatorEnum::Continue)) } } diff --git a/src/ast/node/function.rs b/src/ast/node/function.rs index 6d762f22f..3ad47a526 100644 --- a/src/ast/node/function.rs +++ b/src/ast/node/function.rs @@ -5,7 +5,7 @@ use super::{types::TypedIdentifierNode, Node, TypeNode}; use crate::ast::diag::ErrorCode; use crate::ast::node::{deal_line, tab}; -use crate::ast::pltype::{get_type_deep, FNType, FNValue, PLType}; +use crate::ast::pltype::{get_type_deep, FNValue, FnType, PLType}; use crate::ast::tokens::TokenType; use crate::plv; use indexmap::IndexMap; @@ -48,7 +48,7 @@ impl Node for FuncCallNode { } let pltype = pltype.unwrap(); let mut fnvalue = match &*pltype.borrow() { - PLType::FN(f) => { + PLType::Fn(f) => { let mut res = f.clone(); res.fntype = res.fntype.new_pltype(); res @@ -65,25 +65,23 @@ impl Node for FuncCallNode { )); } let generic_types = generic_params.get_generic_types(ctx, builder)?; - let mut i = 0; - for (_, pltype) in fnvalue.fntype.generic_map.iter() { + for (i, (_, pltype)) in fnvalue.fntype.generic_map.iter().enumerate() { if i >= fnvalue.fntype.generics_size { break; } if generic_types[i].is_some() { ctx.eq(pltype.clone(), generic_types[i].as_ref().unwrap().clone()); } - i += 1; } } let mut skip = 0; let mut para_values = vec![]; let mut receiver_type = None; - let fn_handle = plvalue.and_then(|plvalue| { + let fn_handle = plvalue.map(|plvalue| { if let Some((receiver, tp)) = plvalue.receiver { (skip, para_values, receiver_type) = (1, vec![receiver], tp); } - Some(plvalue.value) + plvalue.value }); if fnvalue.fntype.param_pltypes.len() - skip as usize != self.paralist.len() { return Err(ctx.add_diag(self.range.new_err(ErrorCode::PARAMETER_LENGTH_NOT_MATCH))); @@ -118,7 +116,7 @@ impl Node for FuncCallNode { let pararange = para.range(); let (value, value_pltype, _) = para.emit(ctx, builder)?; if value.is_none() || value_pltype.is_none() { - return Ok((None, None, TerminatorEnum::NONE)); + return Ok((None, None, TerminatorEnum::None)); } let value_pltype = value_pltype.unwrap(); let value_pltype = get_type_deep(value_pltype); @@ -153,7 +151,7 @@ impl Node for FuncCallNode { if eqres.need_up_cast { let mut value = para_values[i + skip as usize]; let ptr2v = - builder.alloc("tmp_up_cast_ptr", &*value_pltype.borrow(), ctx, None); + builder.alloc("tmp_up_cast_ptr", &value_pltype.borrow(), ctx, None); builder.build_store(ptr2v, value); let trait_pltype = fnvalue.fntype.param_pltypes[i + skip as usize] .get_type(ctx, builder)?; @@ -161,11 +159,11 @@ impl Node for FuncCallNode { trait_pltype, value_pltype.clone(), fnvalue.fntype.param_pltypes[i + skip as usize].range(), - pararange.clone(), + *pararange, ptr2v, builder, )?; - value = ctx.try_load2var(pararange.clone(), plv!(value), builder)?; + value = ctx.try_load2var(*pararange, plv!(value), builder)?; para_values[i + skip as usize] = value; } } @@ -198,13 +196,13 @@ impl Node for FuncCallNode { { Some(plv!(v)) }, Some({ match &*rettp.clone().borrow() { - PLType::GENERIC(g) => g.curpltype.as_ref().unwrap().clone(), + PLType::Generic(g) => g.curpltype.as_ref().unwrap().clone(), _ => rettp, } }), - TerminatorEnum::NONE, + TerminatorEnum::None, )), - None => Ok((None, Some(rettp), TerminatorEnum::NONE)), + None => Ok((None, Some(rettp), TerminatorEnum::None)), } }); ctx.set_if_refs_tp(pltype, id_range); @@ -251,7 +249,7 @@ impl TypeNode for FuncDefNode { generic_map .iter() .for_each(|(_, pltype)| match &mut *pltype.borrow_mut() { - PLType::GENERIC(g) => { + PLType::Generic(g) => { g.set_place_holder(child); } _ => unreachable!(), @@ -273,7 +271,7 @@ impl TypeNode for FuncDefNode { child.plmod.get_full_name(&self.id.name) }, path: child.plmod.path.clone(), - fntype: FNType { + fntype: FnType { ret_pltype: self.ret.clone(), param_pltypes, method, @@ -288,7 +286,7 @@ impl TypeNode for FuncDefNode { if self.generics.is_none() { builder.get_or_insert_fn_handle(&fnvalue, child); } - let pltype = Arc::new(RefCell::new(PLType::FN(fnvalue.clone()))); + let pltype = Arc::new(RefCell::new(PLType::Fn(fnvalue.clone()))); child.set_if_refs_tp(pltype.clone(), self.id.range); child.add_doc_symbols(pltype.clone()); if method { @@ -299,8 +297,8 @@ impl TypeNode for FuncDefNode { .typenode .get_type(child, builder) .unwrap(); - if let PLType::POINTER(s) = &*receiver_pltype.borrow() { - if let PLType::STRUCT(s) = &*s.borrow() { + if let PLType::Pointer(s) = &*receiver_pltype.borrow() { + if let PLType::Struct(s) = &*s.borrow() { let fullname = s.get_st_full_name_except_generic(); flater = Some(move |ctx: &mut Ctx| { ctx.add_method( @@ -321,7 +319,7 @@ impl TypeNode for FuncDefNode { Ok(pltype) } - fn emit_highlight<'a, 'ctx>(&self, ctx: &mut Ctx<'a>) { + fn emit_highlight(&self, ctx: &mut Ctx) { ctx.emit_comment_highlight(&self.precom); ctx.push_semantic_token(self.id.range, SemanticTokenType::FUNCTION, 0); if let Some(generics) = &self.generics { @@ -363,7 +361,7 @@ impl FuncDefNode { ctx: &'b mut Ctx<'a>, builder: &'b BuilderEnum<'a, 'ctx>, ) -> Result<(), PLDiag> { - if let Ok(_) = ctx.get_type(self.id.name.as_str(), self.id.range) { + if ctx.get_type(self.id.name.as_str(), self.id.range).is_ok() { return Err(ctx.add_diag(self.range.new_err(ErrorCode::REDEFINE_SYMBOL))); } let pltype = self.get_type(ctx, builder)?; @@ -378,11 +376,11 @@ impl FuncDefNode { fnvalue: FNValue, ) -> Result<(), PLDiag> { let child = &mut ctx.new_child(self.range.start, builder); - return child.protect_generic_context(&fnvalue.fntype.generic_map, |child| { + child.protect_generic_context(&fnvalue.fntype.generic_map, |child| { if first && fnvalue.fntype.generic { fnvalue.fntype.generic_map.iter().for_each(|(_, pltype)| { match &mut *pltype.borrow_mut() { - PLType::GENERIC(g) => { + PLType::Generic(g) => { g.set_place_holder(child); } _ => unreachable!(), @@ -398,7 +396,7 @@ impl FuncDefNode { place_holder_fn.generic_infer = Arc::new(RefCell::new(IndexMap::default())); fnvalue.generic_infer.borrow_mut().insert( name, - Arc::new(RefCell::new(PLType::FN(place_holder_fn.clone()))), + Arc::new(RefCell::new(PLType::Fn(place_holder_fn.clone()))), ); } let funcvalue = builder.get_or_insert_fn_handle(&fnvalue, child); @@ -417,7 +415,7 @@ impl FuncDefNode { child.position_at_end(entry, builder); let ret_value_ptr = match &*fnvalue.fntype.ret_pltype.get_type(child, builder)?.borrow() { - PLType::VOID => None, + PLType::Void => None, other => { builder.rm_curr_debug_location(); let retv = builder.alloc("retvalue", other, child, None); @@ -482,8 +480,8 @@ impl FuncDefNode { } child.position_at_end(allocab, builder); builder.build_unconditional_branch(entry); - return Ok(()); - }); + Ok(()) + }) } } @@ -538,15 +536,15 @@ impl Node for FuncDefNode { } if self.body.is_some() { let fntype = match &*pltype.borrow() { - PLType::FN(f) => { + PLType::Fn(f) => { let mut res = f.clone(); res.fntype = res.fntype.new_pltype(); res } - _ => return Ok((None, None, TerminatorEnum::NONE)), + _ => return Ok((None, None, TerminatorEnum::None)), }; self.gen_fntype(ctx, true, builder, fntype)?; } - Ok((None, Some(pltype), TerminatorEnum::NONE)) + Ok((None, Some(pltype), TerminatorEnum::None)) } } diff --git a/src/ast/node/global.rs b/src/ast/node/global.rs index d041449b5..befcf3b86 100644 --- a/src/ast/node/global.rs +++ b/src/ast/node/global.rs @@ -35,16 +35,16 @@ impl Node for GlobalNode { ctx.push_semantic_token(self.var.range, SemanticTokenType::VARIABLE, 0); let (value, pltype, _) = self.exp.emit(ctx, builder)?; - ctx.push_type_hints(self.var.range, pltype.clone().unwrap()); + ctx.push_type_hints(self.var.range, pltype.unwrap()); let base_value = ctx.try_load2var(exp_range, value.unwrap(), builder)?; let res = ctx.get_symbol(&self.var.name, builder); if res.is_none() { - return Ok((None, None, TerminatorEnum::NONE)); + return Ok((None, None, TerminatorEnum::None)); } - let (globalptr, _, _, _, _) = res.unwrap(); + let (global, _) = res.unwrap(); ctx.position_at_end(entry, builder); - builder.build_store(globalptr, base_value); - Ok((None, None, TerminatorEnum::NONE)) + builder.build_store(global.value, base_value); + Ok((None, None, TerminatorEnum::None)) } } impl GlobalNode { diff --git a/src/ast/node/implement.rs b/src/ast/node/implement.rs index cb4914123..96683d012 100644 --- a/src/ast/node/implement.rs +++ b/src/ast/node/implement.rs @@ -41,9 +41,9 @@ impl Node for ImplNode { if let Some((t, (_, r))) = &self.impl_trait { let tp = t.get_type(ctx, builder); if let Ok(tp) = tp { - if let PLType::TRAIT(st) = &*tp.borrow() { + if let PLType::Trait(st) = &*tp.borrow() { traittpandrange = Some((tp.clone(), t.range())); - for (name, _) in &st.fields { + for name in st.fields.keys() { traitfns.insert(name.clone()); } } @@ -53,14 +53,14 @@ impl Node for ImplNode { } self.target.emit_highlight(ctx); let mut method_docsymbols = vec![]; - if let TypeNodeEnum::PointerTypeNode(pt) = &*self.target { - if let TypeNodeEnum::BasicTypeNode(bt) = &*pt.elm { + if let TypeNodeEnum::Pointer(pt) = &*self.target { + if let TypeNodeEnum::Basic(bt) = &*pt.elm { let st_pltype = bt.get_origin_type_with_infer(ctx, builder)?; - if let PLType::STRUCT(sttp) = &*st_pltype.borrow() { + if let PLType::Struct(sttp) = &*st_pltype.borrow() { if let Some((t, _)) = &self.impl_trait { let trait_tp = t.get_type(ctx, builder)?; let name = trait_tp.borrow().get_kind_name(); - if let PLType::TRAIT(st) = &*trait_tp.borrow_mut() { + if let PLType::Trait(st) = &*trait_tp.borrow_mut() { ctx.send_if_go_to_def(t.range(), st.range, st.path.clone()); } else { t.range() @@ -105,31 +105,26 @@ impl Node for ImplNode { // 检查方法是否在trait中 let trait_tp = traittpandrange.clone().unwrap().0; - if let PLType::TRAIT(st) = &*trait_tp.borrow() { - if st - .fields - .iter() - .find(|(_, f)| { - let tp = f.typenode.get_type(ctx, builder); - if tp.is_err() { - return false; - } - let tp = tp.unwrap(); - let re = match (&*tp.borrow(), &*tmp.borrow()) { - (PLType::FN(f1), PLType::FN(f2)) => { - if f1.eq_except_receiver(f2, ctx, builder) { - traitfns.remove(&f1.name); - true - } else { - false - } + if let PLType::Trait(st) = &*trait_tp.borrow() { + if !st.fields.iter().any(|(_, f)| { + let tp = f.typenode.get_type(ctx, builder); + if tp.is_err() { + return false; + } + let tp = tp.unwrap(); + let re = match (&*tp.borrow(), &*tmp.borrow()) { + (PLType::Fn(f1), PLType::Fn(f2)) => { + if f1.eq_except_receiver(f2, ctx, builder) { + traitfns.remove(&f1.name); + true + } else { + false } - _ => unreachable!(), - }; - re - }) - .is_none() - { + } + _ => unreachable!(), + }; + re + }) { method .range() .new_err(ErrorCode::METHOD_NOT_IN_TRAIT) @@ -150,7 +145,7 @@ impl Node for ImplNode { } }; } - let f = if let PLType::FN(f) = &*tmp.borrow() { + let f = if let PLType::Fn(f) = &*tmp.borrow() { f.get_doc_symbol() } else { continue; @@ -190,6 +185,6 @@ impl Node for ImplNode { children: Some(method_docsymbols), }; ctx.plmod.doc_symbols.borrow_mut().push(docsymbol); - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } diff --git a/src/ast/node/interface.rs b/src/ast/node/interface.rs index 41106084e..5fed867bf 100644 --- a/src/ast/node/interface.rs +++ b/src/ast/node/interface.rs @@ -27,9 +27,9 @@ impl TraitBoundNode { return Err(ctx.add_diag(self.generic.range().new_err(ErrorCode::GENERIC_NOT_FOUND))); } let trait_pltype = self.impl_trait.get_type(ctx, builder)?; - if matches!(*trait_pltype.borrow(), PLType::TRAIT(_)) { + if matches!(*trait_pltype.borrow(), PLType::Trait(_)) { let generic_type = generic_map.get(&self.generic.name).unwrap(); - if let PLType::GENERIC(generic_type) = &mut *generic_type.borrow_mut() { + if let PLType::Generic(generic_type) = &mut *generic_type.borrow_mut() { generic_type.trait_impl = Some(trait_pltype); return Ok(()); } @@ -75,7 +75,7 @@ impl Node for TraitDefNode { for method in &self.methods { method.emit_highlight(ctx); } - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } @@ -85,7 +85,7 @@ impl TraitDefNode { ctx: &'b mut Ctx<'a>, builder: &'b BuilderEnum<'a, 'ctx>, ) { - let stu = Arc::new(RefCell::new(PLType::TRAIT(STType { + let stu = Arc::new(RefCell::new(PLType::Trait(STType { generic_map: IndexMap::default(), name: self.id.name.clone(), path: ctx.plmod.path.clone(), @@ -124,7 +124,7 @@ impl TraitDefNode { // pointer to real value order_fields.push(Field { index: i, - typenode: Box::new(TypeNodeEnum::PointerTypeNode(PointerTypeNode { + typenode: Box::new(TypeNodeEnum::Pointer(PointerTypeNode { elm: Box::new(TypeNameNode::new_from_str("i64").into()), range: Default::default(), })), @@ -175,7 +175,7 @@ impl TraitDefNode { ctx, ); ctx.plmod.types = clone_map; - if let PLType::TRAIT(st) = &mut *pltype.borrow_mut() { + if let PLType::Trait(st) = &mut *pltype.borrow_mut() { st.fields = fields; st.ordered_fields = newf; st.derives = derives; @@ -194,7 +194,7 @@ fn new_i64ptr_tf_with_name(n: &str) -> TypedIdentifierNode { name: n.to_string(), range: Default::default(), }, - typenode: Box::new(TypeNodeEnum::PointerTypeNode(PointerTypeNode { + typenode: Box::new(TypeNodeEnum::Pointer(PointerTypeNode { elm: Box::new(TypeNameNode::new_from_str("i64").into()), range: Default::default(), })), diff --git a/src/ast/node/macro_nodes.rs b/src/ast/node/macro_nodes.rs index 70e650b0f..6310f13d0 100644 --- a/src/ast/node/macro_nodes.rs +++ b/src/ast/node/macro_nodes.rs @@ -40,8 +40,8 @@ impl Node for MacroNode { ctx.set_glob_refs(&ctx.plmod.get_full_name(&self.id.name), self.id.range); ctx.push_semantic_token(self.id.range, SemanticTokenType::MACRO, 0); self.file = ctx.plmod.path.clone(); - ctx.plmod.add_macro(&self); - Ok((None, None, TerminatorEnum::NONE)) + ctx.plmod.add_macro(self); + Ok((None, None, TerminatorEnum::None)) } } @@ -96,7 +96,7 @@ impl MacroMatchExp { break; } } - return Ok((new, ())); + Ok((new, ())) } } } @@ -258,8 +258,7 @@ impl Node for MacroCallNode { let mut next = false; for e in rule.match_exp.iter() { let re = e.parse(ctx, span).map_err(|e| { - if let nom::Err::Error(e) = e { - let mut e = e.clone(); + if let nom::Err::Error(mut e) = e { e.add_label( self.range, ctx.get_file(), @@ -289,7 +288,7 @@ impl Node for MacroCallNode { .with_diag_src(&src, |ctx| ctx.with_macro_emit(|ctx| b.emit(ctx, builder))); match re { Ok(_) => { - return Ok((None, None, TerminatorEnum::NONE)); + return Ok((None, None, TerminatorEnum::None)); } Err(e) => { last_err = Some(e); @@ -305,6 +304,6 @@ impl Node for MacroCallNode { _ => unreachable!(), } - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } diff --git a/src/ast/node/mod.rs b/src/ast/node/mod.rs index a7efe8fb3..ccc04cb5b 100644 --- a/src/ast/node/mod.rs +++ b/src/ast/node/mod.rs @@ -56,17 +56,17 @@ pub mod string_literal; pub mod types; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum TerminatorEnum { - NONE, - RETURN, - BREAK, - CONTINUE, + None, + Return, + Break, + Continue, } impl TerminatorEnum { pub fn is_none(self) -> bool { - self == TerminatorEnum::NONE + self == TerminatorEnum::None } pub fn is_return(self) -> bool { - self == TerminatorEnum::RETURN + self == TerminatorEnum::Return } } #[macro_export] @@ -83,10 +83,10 @@ macro_rules! plv { #[derive(Debug, Clone, PartialEq, Eq)] #[enum_dispatch(TypeNode, RangeTrait, FmtTrait, PrintTrait)] pub enum TypeNodeEnum { - BasicTypeNode(TypeNameNode), - ArrayTypeNode(ArrayTypeNameNode), - PointerTypeNode(PointerTypeNode), - FuncTypeNode(FuncDefNode), + Basic(TypeNameNode), + Array(ArrayTypeNameNode), + Pointer(PointerTypeNode), + Func(FuncDefNode), } #[enum_dispatch] pub trait TypeNode: RangeTrait + FmtTrait + PrintTrait { @@ -96,7 +96,7 @@ pub trait TypeNode: RangeTrait + FmtTrait + PrintTrait { ctx: &'b mut Ctx<'a>, builder: &'b BuilderEnum<'a, 'ctx>, ) -> TypeNodeResult; - fn emit_highlight<'a, 'ctx>(&self, ctx: &mut Ctx<'a>); + fn emit_highlight(&self, ctx: &mut Ctx); fn eq_or_infer<'a, 'ctx, 'b>( &self, ctx: &'b mut Ctx<'a>, @@ -129,7 +129,7 @@ pub enum NodeEnum { Num(NumNode), Bool(BoolConstNode), Err(ErrorNode), - STS(StatementsNode), + Sts(StatementsNode), Empty(EmptyNode), Comment(CommentNode), Program(program::ProgramNode), @@ -199,8 +199,8 @@ impl PLValue { } #[derive(Debug, PartialEq, Clone, Copy)] pub enum Num { - INT(u64), - FLOAT(f64), + Int(u64), + Float(f64), } impl Eq for Num { @@ -255,8 +255,8 @@ impl<'a, 'ctx> Ctx<'a> { let num = numnode.value; // TODO: check overflow let v = match num { - Num::INT(i) => match &*expect.borrow() { - PLType::PRIMITIVE(tp) => { + Num::Int(i) => match &*expect.borrow() { + PLType::Primitive(tp) => { let sign_ext = match tp { PriType::I8 | PriType::I16 @@ -291,8 +291,8 @@ impl<'a, 'ctx> Ctx<'a> { )) } }, - Num::FLOAT(f) => match &*expect.borrow() { - PLType::PRIMITIVE(tp) => match tp { + Num::Float(f) => match &*expect.borrow() { + PLType::Primitive(tp) => match tp { PriType::F32 | PriType::F64 => builder.float_value(tp, f), _ => { return Err(mismatch_err!( @@ -324,7 +324,7 @@ impl<'a, 'ctx> Ctx<'a> { receiver: None, }), Some(expect), - TerminatorEnum::NONE, + TerminatorEnum::None, )); } } @@ -361,8 +361,8 @@ pub fn deal_line(tabs: usize, line: &mut Vec, end: bool) { } } pub fn tab(tabs: usize, line: Vec, end: bool) { - for i in 0..tabs { - if line[i] { + for item in line.iter().take(tabs) { + if *item { print!(" "); } else { print!(" │ "); @@ -392,11 +392,11 @@ pub fn print_params(paralist: &[Box]) -> String { FmtBuilder::generate_node(¶list[0].typenode) ); } - for i in 1..paralist.len() { + for item in paralist.iter().skip(1) { str += &format!( ", {}: {}", - paralist[i].id.name, - FmtBuilder::generate_node(¶list[i].typenode) + item.id.name, + FmtBuilder::generate_node(&item.typenode) ); } str @@ -407,14 +407,14 @@ macro_rules! handle_calc { ($ctx:ident, $op:ident, $opf:ident, $lpltype:ident, $left:ident, $right:ident, $range: expr,$builder:ident) => { paste::item! { match *$lpltype.clone().unwrap().borrow() { - PLType::PRIMITIVE(PriType::I128|PriType::I64|PriType::I32|PriType::I16|PriType::I8| + PLType::Primitive(PriType::I128|PriType::I64|PriType::I32|PriType::I16|PriType::I8| PriType::U128|PriType::U64|PriType::U32|PriType::U16|PriType::U8) => { return Ok((Some(plv!( $builder.[]( - $left, $right, "addtmp"))),Some($lpltype.unwrap()),TerminatorEnum::NONE)); + $left, $right, "addtmp"))),Some($lpltype.unwrap()),TerminatorEnum::None)); }, - PLType::PRIMITIVE(PriType::F64|PriType::F32) => { + PLType::Primitive(PriType::F64|PriType::F32) => { return Ok((Some(plv!( $builder.[]( - $left, $right, "addtmp"))),Some($lpltype.unwrap()),TerminatorEnum::NONE)); + $left, $right, "addtmp"))),Some($lpltype.unwrap()),TerminatorEnum::None)); }, _ => return Err($ctx.add_diag( $range.new_err( diff --git a/src/ast/node/operator.rs b/src/ast/node/operator.rs index 55074626d..6e371a3b9 100644 --- a/src/ast/node/operator.rs +++ b/src/ast/node/operator.rs @@ -50,21 +50,21 @@ impl Node for UnaryOpNode { let exp = ctx.try_load2var(exp_range, exp.unwrap(), builder)?; return Ok(match (&*pltype.borrow(), self.op.0) { ( - PLType::PRIMITIVE( + PLType::Primitive( PriType::I128 | PriType::I64 | PriType::I32 | PriType::I16 | PriType::I8, ), TokenType::MINUS, ) => ( Some(plv!(builder.build_int_neg(exp, "negtmp"))), Some(pltype.clone()), - TerminatorEnum::NONE, + TerminatorEnum::None, ), - (PLType::PRIMITIVE(PriType::F64 | PriType::F32), TokenType::MINUS) => ( + (PLType::Primitive(PriType::F64 | PriType::F32), TokenType::MINUS) => ( Some(plv!(builder.build_float_neg(exp, "negtmp"))), Some(pltype.clone()), - TerminatorEnum::NONE, + TerminatorEnum::None, ), - (PLType::PRIMITIVE(PriType::BOOL), TokenType::NOT) => ( + (PLType::Primitive(PriType::BOOL), TokenType::NOT) => ( { let bool_origin = builder.build_int_compare( IntPredicate::EQ, @@ -80,7 +80,7 @@ impl Node for UnaryOpNode { Some(plv!(bool_origin)) }, Some(pltype.clone()), - TerminatorEnum::NONE, + TerminatorEnum::None, ), (_exp, _op) => { return Err(ctx.add_diag(self.range.new_err(ErrorCode::INVALID_UNARY_EXPRESSION))); @@ -122,7 +122,7 @@ impl Node for BinOpNode { let left = ctx.try_load2var(lrange, lv.unwrap(), builder)?; if self.op.0 == TokenType::AND || self.op.0 == TokenType::OR { return Ok(match *lpltype.clone().unwrap().borrow() { - PLType::PRIMITIVE(PriType::BOOL) => ( + PLType::Primitive(PriType::BOOL) => ( { // and: left && right // or : left || right @@ -158,7 +158,7 @@ impl Node for BinOpNode { // merge bb builder.position_at_end_block(merge_bb); let phi = builder.build_phi( - &PLType::PRIMITIVE(PriType::BOOL), + &PLType::Primitive(PriType::BOOL), ctx, &[(left, incoming_bb1), (right, incoming_bb2)], ); @@ -169,8 +169,8 @@ impl Node for BinOpNode { // ))) Some(plv!(phi)) }, - Some(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::BOOL)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Primitive(PriType::BOOL)))), + TerminatorEnum::None, ), _ => { return Err(ctx @@ -210,7 +210,7 @@ impl Node for BinOpNode { | TokenType::GEQ | TokenType::GREATER | TokenType::LESS => match *lpltype.unwrap().borrow() { - PLType::PRIMITIVE( + PLType::Primitive( PriType::I128 | PriType::I64 | PriType::I32 @@ -232,10 +232,10 @@ impl Node for BinOpNode { // ))) Some(plv!(bool_origin)) }, - Some(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::BOOL)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Primitive(PriType::BOOL)))), + TerminatorEnum::None, ), - PLType::PRIMITIVE(PriType::F64 | PriType::F32) => ( + PLType::Primitive(PriType::F64 | PriType::F32) => ( { let bool_origin = builder.build_float_compare(self.op.0.get_fop(), left, right, "cmptmp"); @@ -246,8 +246,8 @@ impl Node for BinOpNode { // ))) Some(plv!(bool_origin)) }, - Some(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::BOOL)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Primitive(PriType::BOOL)))), + TerminatorEnum::None, ), _ => return Err(ctx.add_diag(self.range.new_err(ErrorCode::VALUE_NOT_COMPARABLE))), }, @@ -294,8 +294,8 @@ impl Node for TakeOpNode { } let head_pltype = get_type_deep(pltype.unwrap()); if !matches!( - &*head_pltype.clone().borrow(), - PLType::STRUCT(_) | PLType::POINTER(_) | PLType::TRAIT(_) + &*head_pltype.borrow(), + PLType::Struct(_) | PLType::Pointer(_) | PLType::Trait(_) ) { return Err(ctx.add_diag( self.head @@ -306,9 +306,9 @@ impl Node for TakeOpNode { if self.field.is_none() { // end with ".", gen completions ctx.if_completion(self.range, || { - match &*ctx.auto_deref_tp(head_pltype).clone().borrow() { - PLType::STRUCT(s) => s.get_completions(ctx), - PLType::TRAIT(s) => s.get_trait_completions(ctx), + match &*ctx.auto_deref_tp(head_pltype).borrow() { + PLType::Struct(s) => s.get_completions(ctx), + PLType::Trait(s) => s.get_trait_completions(ctx), _ => vec![], } }); @@ -318,12 +318,12 @@ impl Node for TakeOpNode { let id_range = id.range(); let (head_pltype, headptr) = ctx.auto_deref(head_pltype, plvalue.unwrap().value, builder); match &*head_pltype.clone().borrow() { - PLType::TRAIT(s) => { + PLType::Trait(s) => { let field = s.fields.get(&id.name); if let Some(field) = field { _ = s.expect_field_pub(ctx, field, id_range); ctx.push_semantic_token(id_range, SemanticTokenType::METHOD, 0); - ctx.set_field_refs(head_pltype.clone(), field, id_range); + ctx.set_field_refs(head_pltype, field, id_range); ctx.send_if_go_to_def(id_range, field.range, s.path.clone()); let re = field.typenode.get_type(ctx, builder)?; let fnv = builder @@ -340,23 +340,23 @@ impl Node for TakeOpNode { receiver: Some((headptr, None)), }), Some(re), - TerminatorEnum::NONE, + TerminatorEnum::None, )); } - return Err(ctx.add_diag(id.range.new_err(ErrorCode::STRUCT_FIELD_NOT_FOUND))); + Err(ctx.add_diag(id.range.new_err(ErrorCode::STRUCT_FIELD_NOT_FOUND))) } - PLType::STRUCT(s) => { + PLType::Struct(s) => { if let Some(field) = s.fields.get(&id.name) { _ = s.expect_field_pub(ctx, field, id_range); ctx.push_semantic_token(id_range, SemanticTokenType::PROPERTY, 0); - ctx.set_field_refs(head_pltype.clone(), field, id_range); + ctx.set_field_refs(head_pltype, field, id_range); ctx.send_if_go_to_def(id_range, field.range, s.path.clone()); return Ok(( Some(plv!(builder .build_struct_gep(headptr, field.index, "structgep") .unwrap())), Some(field.typenode.get_type(ctx, builder)?), - TerminatorEnum::NONE, + TerminatorEnum::None, )); } if let Some(mthd) = s.find_method(ctx, &id.name) { @@ -373,22 +373,20 @@ impl Node for TakeOpNode { is_const: false, receiver: Some(( headptr, - Some(Arc::new(RefCell::new(PLType::POINTER(head_pltype)))), + Some(Arc::new(RefCell::new(PLType::Pointer(head_pltype)))), )), }), - Some(Arc::new(RefCell::new(PLType::FN(mthd)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Fn(mthd)))), + TerminatorEnum::None, )); }; - return Err(ctx.add_diag(id.range.new_err(ErrorCode::STRUCT_FIELD_NOT_FOUND))); - } - _ => { - return Err(ctx.add_diag( - self.head - .range() - .new_err(ErrorCode::ILLEGAL_GET_FIELD_OPERATION), - )) + Err(ctx.add_diag(id.range.new_err(ErrorCode::STRUCT_FIELD_NOT_FOUND))) } + _ => Err(ctx.add_diag( + self.head + .range() + .new_err(ErrorCode::ILLEGAL_GET_FIELD_OPERATION), + )), } } } diff --git a/src/ast/node/pkg.rs b/src/ast/node/pkg.rs index 4d6613acf..e480eb0ca 100644 --- a/src/ast/node/pkg.rs +++ b/src/ast/node/pkg.rs @@ -49,14 +49,14 @@ impl Node for UseNode { _builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { let mut path = PathBuf::from(&ctx.config.root); - let head = self.ids[0].get_name(ctx).clone(); + let head = self.ids[0].get_name(ctx); if !self.ids.is_empty() { // head is project name or deps name let dep = ctx.config.deps.as_ref().unwrap().get(&head); if head == ctx.config.project || dep.is_some() { // change path - if dep.is_some() { - path = path.join(&dep.unwrap().path); + if let Some(dep) = dep { + path = path.join(&dep.path); } for i in 1..self.ids.len() { path = path.join(&self.ids[i].get_name(ctx)); @@ -77,7 +77,7 @@ impl Node for UseNode { if self.ids.len() < 2 && self.complete { completions.clear(); if let Some(deps) = &ctx.config.deps { - for (dep, _) in deps { + for dep in deps.keys() { completions.push(lsp_types::CompletionItem { label: dep.clone(), kind: Some(lsp_types::CompletionItemKind::MODULE), @@ -96,7 +96,7 @@ impl Node for UseNode { if !self.complete { return Err(ctx.add_diag(self.range.new_err(crate::ast::diag::ErrorCode::COMPLETION))); } - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } @@ -179,17 +179,17 @@ impl Node for ExternIdNode { res }), Some(pltype), - TerminatorEnum::NONE, + TerminatorEnum::None, )); } if let Some(tp) = plmod.get_type(&self.id.get_name(ctx)) { let range = &tp.borrow().get_range(); let re = match &*tp.clone().borrow() { - PLType::FN(_) => { + PLType::Fn(_) => { // 必须是public的 _ = tp.borrow().expect_pub(ctx, self.range); ctx.push_semantic_token(self.id.range, SemanticTokenType::FUNCTION, 0); - Ok((None, Some(tp), TerminatorEnum::NONE)) + Ok((None, Some(tp), TerminatorEnum::None)) } _ => return Err(ctx.add_diag(self.range.new_err(ErrorCode::COMPLETION))), }; @@ -202,7 +202,7 @@ impl Node for ExternIdNode { } } impl ExternIdNode { - pub fn get_type<'a, 'ctx>(&'a self, ctx: &Ctx<'a>) -> NodeResult { + pub fn get_type(&self, ctx: &Ctx) -> NodeResult { if self.ns.is_empty() { if self.complete { // 如果该节点只有一个id，且完整，那么就是一个普通的包内符号，直接调用idnode @@ -234,7 +234,7 @@ impl ExternIdNode { // 必须是public的 _ = tp.borrow().expect_pub(ctx, self.range); let re = match *tp.clone().borrow() { - PLType::STRUCT(_) | PLType::TRAIT(_) => Ok((None, Some(tp), TerminatorEnum::NONE)), + PLType::Struct(_) | PLType::Trait(_) => Ok((None, Some(tp), TerminatorEnum::None)), _ => unreachable!(), }; return re; @@ -242,11 +242,11 @@ impl ExternIdNode { Err(ctx.add_diag(self.range.new_err(ErrorCode::SYMBOL_NOT_FOUND))) } - pub fn get_macro<'a, 'ctx>(&'a self, ctx: &Ctx<'a>) -> Result, PLDiag> { + pub fn get_macro(&self, ctx: &Ctx) -> Result, PLDiag> { if self.ns.is_empty() { // 如果该节点只有一个id，且完整，那么就是一个普通的包内符号，直接调用idnode if let Some(m) = ctx.get_macro(&self.id.get_name(ctx)) { - return Ok(m.clone()); + return Ok(m); } return Err(ctx.add_diag(self.range.new_err(ErrorCode::MACRO_NOT_FOUND))); } diff --git a/src/ast/node/pointer.rs b/src/ast/node/pointer.rs index 44554291a..16ca2a5ad 100644 --- a/src/ast/node/pointer.rs +++ b/src/ast/node/pointer.rs @@ -18,8 +18,8 @@ pub struct PointerOpNode { #[derive(Clone, PartialEq, Eq, Debug)] pub enum PointerOpEnum { - DEREF, - ADDR, + Deref, + Addr, } impl PrintTrait for PointerOpNode { @@ -40,20 +40,20 @@ impl Node for PointerOpNode { let (value, mut tp, _) = self.value.emit(ctx, builder)?; let value = value.unwrap(); let value = match self.op { - PointerOpEnum::DEREF => { + PointerOpEnum::Deref => { if tp.is_none() { return Err(ctx.add_diag(self.range.new_err(ErrorCode::NOT_A_POINTER))); } - if let PLType::POINTER(tp1) = &*tp.unwrap().borrow() { + if let PLType::Pointer(tp1) = &*tp.unwrap().borrow() { tp = Some(tp1.clone()); builder.build_load(value.value, "deref") } else { return Err(ctx.add_diag(self.range.new_err(ErrorCode::NOT_A_POINTER))); } } - PointerOpEnum::ADDR => { + PointerOpEnum::Addr => { // let old_tp = tp.clone().unwrap(); - tp = Some(Arc::new(RefCell::new(PLType::POINTER(tp.unwrap())))); + tp = Some(Arc::new(RefCell::new(PLType::Pointer(tp.unwrap())))); if value.is_const { return Err(ctx.add_diag(self.range.new_err(ErrorCode::CAN_NOT_REF_CONSTANT))); } @@ -63,6 +63,6 @@ impl Node for PointerOpNode { v } }; - Ok((Some(plv!(value)), tp, TerminatorEnum::NONE)) + Ok((Some(plv!(value)), tp, TerminatorEnum::None)) } } diff --git a/src/ast/node/primary.rs b/src/ast/node/primary.rs index 032031b22..354b0ddc0 100644 --- a/src/ast/node/primary.rs +++ b/src/ast/node/primary.rs @@ -63,8 +63,8 @@ impl Node for BoolConstNode { self.value as u64, true ))), - Some(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::BOOL)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Primitive(PriType::BOOL)))), + TerminatorEnum::None, )) } } @@ -87,19 +87,19 @@ impl Node for NumNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { ctx.push_semantic_token(self.range, SemanticTokenType::NUMBER, 0); - if let Num::INT(x) = self.value { + if let Num::Int(x) = self.value { let b = builder.int_value(&PriType::I64, x, true); return Ok(( Some(plv!(b)), - Some(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::I64)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Primitive(PriType::I64)))), + TerminatorEnum::None, )); - } else if let Num::FLOAT(x) = self.value { + } else if let Num::Float(x) = self.value { let b = builder.float_value(&PriType::F64, x); return Ok(( Some(plv!(b)), - Some(Arc::new(RefCell::new(PLType::PRIMITIVE(PriType::F64)))), - TerminatorEnum::NONE, + Some(Arc::new(RefCell::new(PLType::Primitive(PriType::F64)))), + TerminatorEnum::None, )); } panic!("not implemented") @@ -150,34 +150,35 @@ impl Node for VarNode { } } ctx.if_completion(self.range, || ctx.get_completions()); - let v = ctx.get_symbol(&self.name, builder); - if let Some((v, pltype, dst, refs, is_const)) = v { + if let Some((symbol, is_const)) = ctx.get_symbol(&self.name, builder) { ctx.push_semantic_token(self.range, SemanticTokenType::VARIABLE, 0); let o = Ok(( Some({ - let mut res: PLValue = plv!(v); + let mut res: PLValue = plv!(symbol.value); res.set_const(is_const); res }), - Some(pltype), - TerminatorEnum::NONE, + Some(symbol.pltype), + TerminatorEnum::None, )); - ctx.send_if_go_to_def(self.range, dst, ctx.plmod.path.clone()); - refs.map(|refs| { - ctx.set_if_refs(refs, self.range); - }) - .or_else(|| { - ctx.set_glob_refs(&ctx.plmod.get_full_name(&self.name), self.range); - Some(()) - }); + ctx.send_if_go_to_def(self.range, symbol.range, ctx.plmod.path.clone()); + symbol + .refs + .map(|refs| { + ctx.set_if_refs(refs, self.range); + }) + .or_else(|| { + ctx.set_glob_refs(&ctx.plmod.get_full_name(&self.name), self.range); + Some(()) + }); return o; } if let Ok(tp) = ctx.get_type(&self.name, self.range) { match &*tp.borrow() { - PLType::FN(f) => { + PLType::Fn(f) => { ctx.send_if_go_to_def(self.range, f.range, ctx.plmod.path.clone()); ctx.push_semantic_token(self.range, SemanticTokenType::FUNCTION, 0); - return Ok((None, Some(tp.clone()), TerminatorEnum::NONE)); + return Ok((None, Some(tp.clone()), TerminatorEnum::None)); } _ => return Err(ctx.add_diag(self.range.new_err(ErrorCode::VAR_NOT_FOUND))), } @@ -196,13 +197,13 @@ impl PrintTrait for VarNode { impl VarNode { fn is_macro_var(&self) -> bool { - self.name.starts_with("$") + self.name.starts_with('$') } pub fn get_name(&self, ctx: &Ctx) -> String { if self.is_macro_var() { let re = ctx.macro_vars.get(&self.name[1..]).unwrap(); if let MacroReplaceNode::NodeEnum(NodeEnum::Var(v)) = re { - return v.name.clone(); + v.name.clone() } else { todo!() } @@ -211,7 +212,7 @@ impl VarNode { } } - pub fn get_type<'a, 'ctx>(&'a self, ctx: &Ctx<'a>) -> NodeResult { + pub fn get_type(&self, ctx: &Ctx) -> NodeResult { if self.is_macro_var() { let re = ctx.macro_vars.get(&self.name[1..]).unwrap(); if let MacroReplaceNode::NodeEnum(NodeEnum::Var(v)) = re { @@ -224,17 +225,17 @@ impl VarNode { if let Ok(tp) = ctx.get_type(&self.name, self.range) { match *tp.borrow() { - PLType::STRUCT(_) - | PLType::TRAIT(_) - | PLType::PRIMITIVE(_) - | PLType::VOID - | PLType::GENERIC(_) - | PLType::PLACEHOLDER(_) => { - if let PLType::STRUCT(st) | PLType::TRAIT(st) = &*tp.clone().borrow() { + PLType::Struct(_) + | PLType::Trait(_) + | PLType::Primitive(_) + | PLType::Void + | PLType::Generic(_) + | PLType::PlaceHolder(_) => { + if let PLType::Struct(st) | PLType::Trait(st) = &*tp.clone().borrow() { ctx.send_if_go_to_def(self.range, st.range, ctx.plmod.path.clone()); // ctx.set_if_refs(st.refs.clone(), self.range); } - return Ok((None, Some(tp.clone()), TerminatorEnum::NONE)); + return Ok((None, Some(tp.clone()), TerminatorEnum::None)); } _ => return Err(ctx.add_diag(self.range.new_err(ErrorCode::UNDEFINED_TYPE))), } @@ -266,7 +267,7 @@ impl Node for ArrayElementNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { let (arr, pltype, _) = self.arr.emit(ctx, builder)?; - if let PLType::ARR(arrtp) = &*pltype.unwrap().borrow() { + if let PLType::Arr(arrtp) = &*pltype.unwrap().borrow() { let arr = arr.unwrap(); // TODO: check if index is out of bounds let index_range = self.index.range(); @@ -284,7 +285,7 @@ impl Node for ArrayElementNode { return Ok(( Some(plv!(elemptr)), Some(arrtp.element_type.clone()), - TerminatorEnum::NONE, + TerminatorEnum::None, )); } Err(ctx.add_diag(self.range.new_err(ErrorCode::CANNOT_INDEX_NON_ARRAY))) diff --git a/src/ast/node/program.rs b/src/ast/node/program.rs index 653d0cf32..f914eba8d 100644 --- a/src/ast/node/program.rs +++ b/src/ast/node/program.rs @@ -1,3 +1,4 @@ +#![allow(clippy::too_many_arguments)] use super::function::FuncDefNode; use super::types::StructDefNode; use super::*; @@ -85,7 +86,7 @@ impl Node for ProgramNode { }); self.trait_impls.iter().for_each(|x| { let (struct_name, trait_name) = x; - ctx.plmod.add_impl(&struct_name, &trait_name) + ctx.plmod.add_impl(struct_name, trait_name) }); // init global ctx.set_init_fn(builder); @@ -101,7 +102,7 @@ impl Node for ProgramNode { _ = x.emit(ctx, builder); }); ctx.init_fn_ret(builder); - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } @@ -302,14 +303,14 @@ impl Program { .completions .borrow() .iter() - .map(|x| x.into_completions()) + .map(|x| x.0.clone()) .collect(), ); } let hints = plmod.hints.borrow().clone(); - Hints::push(db, *hints); + Hints::push(db, hints); let docs = plmod.doc_symbols.borrow().clone(); - DocSymbols::push(db, *docs); + DocSymbols::push(db, docs); } match params.action(db) { ActionType::FindReferences => { @@ -340,11 +341,9 @@ impl Program { let range = pos.to(pos); let res = plmod.defs.borrow(); let re = res.range((Unbounded, Included(&range))).last(); - if let Some((range, res)) = re { - if let LSPDef::Scalar(def) = res { - if pos.is_in(*range) { - GotoDef::push(db, GotoDefinitionResponse::Scalar(def.clone())); - } + if let Some((range, LSPDef::Scalar(def))) = re { + if pos.is_in(*range) { + GotoDef::push(db, GotoDefinitionResponse::Scalar(def.clone())); } } } @@ -379,7 +378,6 @@ impl Program { m } } - #[salsa::tracked] pub struct ProgramEmitParam { pub node: ProgramNodeWrapper, @@ -424,7 +422,7 @@ pub fn emit_file(db: &dyn Db, params: ProgramEmitParam) -> ModWrapper { let node = params.node(db); let mut nn = node.node(db); let mut builder = &builder.into(); - let noop = NoOpBuilder::new(); + let noop = NoOpBuilder::default(); let noop = noop.into(); if !params.params(db).is_compile(db) { log::info!("not in compile mode, using no-op builder"); diff --git a/src/ast/node/ret.rs b/src/ast/node/ret.rs index c0369e63f..93b1203a9 100644 --- a/src/ast/node/ret.rs +++ b/src/ast/node/ret.rs @@ -40,7 +40,7 @@ impl Node for RetNode { return Err(err); } if eqres.need_up_cast { - let ptr2v = builder.alloc("tmp_up_cast_ptr", &*value_pltype.borrow(), ctx, None); + let ptr2v = builder.alloc("tmp_up_cast_ptr", &value_pltype.borrow(), ctx, None); builder.build_store(ptr2v, value); value = ctx.up_cast( ret_pltype, @@ -53,7 +53,7 @@ impl Node for RetNode { value = ctx.try_load2var(self.range, plv!(value), builder)?; } builder.build_store(ctx.return_block.unwrap().1.unwrap(), value); - } else if *ret_pltype.borrow() != PLType::VOID { + } else if *ret_pltype.borrow() != PLType::Void { ctx.emit_comment_highlight(&self.comments[0]); return Err(ctx.add_diag( self.range @@ -66,6 +66,6 @@ impl Node for RetNode { .get_first_instruction(ctx.return_block.unwrap().0) .unwrap(), ); - Ok((None, None, TerminatorEnum::RETURN)) + Ok((None, None, TerminatorEnum::Return)) } } diff --git a/src/ast/node/statement.rs b/src/ast/node/statement.rs index 767be89e7..d810c7bd8 100644 --- a/src/ast/node/statement.rs +++ b/src/ast/node/statement.rs @@ -58,7 +58,7 @@ impl Node for DefNode { if value.is_none() { return Err(ctx.add_diag(self.range.new_err(ErrorCode::EXPECT_VALUE))); } - let tp = pltype_opt.clone().unwrap(); + let tp = pltype_opt.unwrap(); if pltype.is_none() { ctx.push_type_hints(self.var.range, tp.clone()); pltype = Some(tp); @@ -83,7 +83,7 @@ impl Node for DefNode { builder.build_dbg_location(self.var.range.start); builder.build_store(ptr2value, ctx.try_load2var(range, exp, builder)?); } - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } #[node] @@ -120,7 +120,7 @@ impl Node for AssignNode { } let load = ctx.try_load2var(exp_range, value.unwrap(), builder)?; builder.build_store(ptr.unwrap().value, load); - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } @@ -142,7 +142,7 @@ impl Node for EmptyNode { _builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { ctx.emit_comment_highlight(&self.comments[0]); - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } @@ -170,7 +170,7 @@ impl Node for StatementsNode { ctx: &'b mut Ctx<'a>, builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { - let mut terminator = TerminatorEnum::NONE; + let mut terminator = TerminatorEnum::None; for m in self.statements.iter_mut() { if let NodeEnum::Empty(_) = **m { continue; diff --git a/src/ast/node/string_literal.rs b/src/ast/node/string_literal.rs index 439275ef5..2dbb2533d 100644 --- a/src/ast/node/string_literal.rs +++ b/src/ast/node/string_literal.rs @@ -58,7 +58,7 @@ impl Node for StringNode { res }), Some(tp), - TerminatorEnum::NONE, + TerminatorEnum::None, )) } } diff --git a/src/ast/node/types.rs b/src/ast/node/types.rs index 2f1c26b17..93eacc2f6 100644 --- a/src/ast/node/types.rs +++ b/src/ast/node/types.rs @@ -56,7 +56,7 @@ impl TypeNameNode { let (_, pltype, _) = self.id.as_ref().unwrap().get_type(ctx)?; ctx.if_completion(self.range, || ctx.get_type_completions()); let pltype = pltype.unwrap(); - if let PLType::STRUCT(sttype) = &*pltype.clone().borrow() { + if let PLType::Struct(sttype) = &*pltype.clone().borrow() { let sttype = sttype.new_pltype(); if let Some(generic_params) = &self.generic_params { let generic_types = generic_params.get_generic_types(ctx, builder)?; @@ -74,7 +74,7 @@ impl TypeNameNode { continue; } if st_generic_type == generic_types[i].as_ref().unwrap() { - if let PLType::GENERIC(g) = &mut *st_generic_type.borrow_mut() { + if let PLType::Generic(g) = &mut *st_generic_type.borrow_mut() { // self ref to avoid emit_struct_def check if g.curpltype.is_none() { g.curpltype = Some(generic_types[i].as_ref().unwrap().clone()); @@ -83,7 +83,7 @@ impl TypeNameNode { i += 1; continue; } - if let PLType::GENERIC(g) = &mut *st_generic_type.borrow_mut() { + if let PLType::Generic(g) = &mut *st_generic_type.borrow_mut() { g.curpltype = None; } if !ctx @@ -100,7 +100,7 @@ impl TypeNameNode { i += 1; } } - Ok(Arc::new(RefCell::new(PLType::STRUCT(sttype)))) + Ok(Arc::new(RefCell::new(PLType::Struct(sttype)))) } else { Ok(pltype) } @@ -122,7 +122,7 @@ impl PrintTrait for TypeNameNode { } impl TypeNode for TypeNameNode { - fn emit_highlight<'a, 'ctx>(&self, ctx: &mut Ctx<'a>) { + fn emit_highlight(&self, ctx: &mut Ctx) { if let Some(id) = &self.id { for ns in id.ns.iter() { ctx.push_semantic_token(ns.range, SemanticTokenType::NAMESPACE, 0); @@ -142,14 +142,14 @@ impl TypeNode for TypeNameNode { let mut pltype = self.get_origin_type_with_infer(ctx, builder)?; if self.generic_params.is_some() { let mut sttype = match &*pltype.borrow() { - PLType::STRUCT(s) => s.clone(), + PLType::Struct(s) => s.clone(), _ => unreachable!(), }; if sttype.need_gen_code() { sttype = ctx.protect_generic_context(&sttype.generic_map, |ctx| { Ok(sttype.gen_code(ctx, builder)) })?; - pltype = Arc::new(RefCell::new(PLType::STRUCT(sttype))); + pltype = Arc::new(RefCell::new(PLType::Struct(sttype))); return Ok(pltype); } else { return Err(ctx.add_diag(self.range.new_err(ErrorCode::GENERIC_CANNOT_BE_INFER))); @@ -175,7 +175,7 @@ impl TypeNode for TypeNameNode { need_up_cast: false, }); } - if let (PLType::STRUCT(left), PLType::STRUCT(right)) = + if let (PLType::Struct(left), PLType::Struct(right)) = (&*left.borrow(), &*right.borrow()) { return ctx.protect_generic_context(&left.generic_map, |ctx| { @@ -198,10 +198,10 @@ impl TypeNode for TypeNameNode { }); } } - return Ok(EqRes { + Ok(EqRes { eq: true, need_up_cast: false, - }); + }) }); } return Err(ctx.add_diag(self.range.new_err(ErrorCode::NOT_GENERIC_TYPE))); @@ -233,13 +233,13 @@ impl TypeNode for ArrayTypeNameNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> TypeNodeResult { if let NodeEnum::Num(num) = *self.size { - if let Num::INT(sz) = num.value { + if let Num::Int(sz) = num.value { let pltype = self.id.get_type(ctx, builder)?; let arrtype = ARRType { element_type: pltype, size: sz as u32, }; - let arrtype = Arc::new(RefCell::new(PLType::ARR(arrtype))); + let arrtype = Arc::new(RefCell::new(PLType::Arr(arrtype))); return Ok(arrtype); } } @@ -257,9 +257,9 @@ impl TypeNode for ArrayTypeNameNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> Result { match &*pltype.borrow() { - PLType::ARR(a) => { + PLType::Arr(a) => { if let NodeEnum::Num(num) = *self.size { - if let Num::INT(size) = num.value { + if let Num::Int(size) = num.value { if a.size as u64 != size { return Ok(EqRes { eq: false, @@ -300,7 +300,7 @@ impl TypeNode for PointerTypeNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> TypeNodeResult { let pltype = self.elm.get_type(ctx, builder)?; - let pltype = Arc::new(RefCell::new(PLType::POINTER(pltype))); + let pltype = Arc::new(RefCell::new(PLType::Pointer(pltype))); Ok(pltype) } @@ -315,7 +315,7 @@ impl TypeNode for PointerTypeNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> Result { match &*pltype.borrow() { - PLType::POINTER(p) => self.elm.eq_or_infer(ctx, p.clone(), builder), + PLType::Pointer(p) => self.elm.eq_or_infer(ctx, p.clone(), builder), _ => Ok(EqRes { eq: false, need_up_cast: false, @@ -350,10 +350,16 @@ pub struct StructDefNode { pub precom: Vec>, pub doc: Vec>, pub id: Box, - pub fields: Vec<(Box, bool, Option<(TokenType, Range)>)>, + pub fields: Vec, pub generics: Option>, pub modifier: Option<(TokenType, Range)>, } +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct StructField { + pub id: Box, + pub has_semi: bool, + pub modifier: Option<(TokenType, Range)>, +} impl PrintTrait for StructDefNode { fn print(&self, tabs: usize, end: bool, mut line: Vec) { @@ -366,9 +372,9 @@ impl PrintTrait for StructDefNode { c.print(tabs + 1, false, line.clone()); } let mut i = self.fields.len(); - for (field, _, _) in &self.fields { + for field in &self.fields { i -= 1; - field.print(tabs + 1, i == 0, line.clone()); + field.id.print(tabs + 1, i == 0, line.clone()); } } } @@ -384,17 +390,17 @@ impl Node for StructDefNode { if let Some(generics) = &mut self.generics { generics.emit_highlight(ctx); } - for (field, has_semi, _) in self.fields.iter() { + for field in self.fields.iter() { ctx.push_semantic_token(field.id.range, SemanticTokenType::PROPERTY, 0); - field.typenode.emit_highlight(ctx); - if !has_semi { - ctx.add_diag(field.range.new_err(ErrorCode::COMPLETION)); + field.id.typenode.emit_highlight(ctx); + if !field.has_semi { + ctx.add_diag(field.id.range.new_err(ErrorCode::COMPLETION)); } - if let Some(doc) = &field.doc { + if let Some(doc) = &field.id.doc { ctx.push_semantic_token(doc.range, SemanticTokenType::COMMENT, 0); } } - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } @@ -408,7 +414,7 @@ impl StructDefNode { .generics .as_ref() .map_or(IndexMap::default(), |generics| generics.gen_generic_type()); - let stu = Arc::new(RefCell::new(PLType::STRUCT(STType { + let stu = Arc::new(RefCell::new(PLType::Struct(STType { name: self.id.name.clone(), path: ctx.plmod.path.clone(), fields: FxHashMap::default(), @@ -449,39 +455,32 @@ impl StructDefNode { let mut field_pltps = vec![]; let pltype = ctx.get_type(self.id.name.as_str(), self.range)?; let clone_map = ctx.plmod.types.clone(); - for (field, has_semi, modifier) in self.fields.iter() { - if !has_semi { - ctx.add_diag(field.range.new_err(ErrorCode::COMPLETION)); + for field in self.fields.iter() { + if !field.has_semi { + ctx.add_diag(field.id.range.new_err(ErrorCode::COMPLETION)); } - let id = field.id.clone(); + let id = field.id.id.clone(); let f = Field { index: i, - typenode: field.typenode.clone(), - name: field.id.name.clone(), - range: field.range, - modifier: *modifier, + typenode: field.id.typenode.clone(), + name: id.name.clone(), + range: field.id.range, + modifier: field.modifier, }; - let tpre = field.typenode.get_type(ctx, builder); + let tpre = field.id.typenode.get_type(ctx, builder); if tpre.is_err() { continue; } let tp = tpre.unwrap(); field_pltps.push(tp.clone()); - match &*tp.borrow() { - PLType::STRUCT(sttp) => { - ctx.send_if_go_to_def( - field.typenode.range(), - sttp.range, - sttp.path.clone(), - ); - } - _ => {} + if let PLType::Struct(sttp) = &*tp.borrow() { + ctx.send_if_go_to_def(field.id.typenode.range(), sttp.range, sttp.path.clone()); }; ctx.set_field_refs(pltype.clone(), &f, f.range); ctx.send_if_go_to_def(f.range, f.range, ctx.plmod.path.clone()); fields.insert(id.name.to_string(), f.clone()); order_fields.push(f); - ctx.set_if_refs_tp(tp.clone(), field.typenode.range()); + ctx.set_if_refs_tp(tp.clone(), field.id.typenode.range()); i += 1; } let newf = order_fields.clone(); @@ -493,7 +492,7 @@ impl StructDefNode { ); } ctx.plmod.types = clone_map; - if let PLType::STRUCT(st) = &mut *pltype.borrow_mut() { + if let PLType::Struct(st) = &mut *pltype.borrow_mut() { builder.gen_st_visit_function(ctx, st, &field_pltps); st.fields = fields; st.ordered_fields = newf; @@ -531,7 +530,7 @@ impl Node for StructInitFieldNode { builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { let (v, tp, _) = self.exp.emit(ctx, builder)?; - Ok((v, tp, TerminatorEnum::NONE)) + Ok((v, tp, TerminatorEnum::None)) } } @@ -564,12 +563,12 @@ impl Node for StructInitNode { ) -> NodeResult { self.typename.emit_highlight(ctx); let mut pltype = match &*self.typename { - TypeNodeEnum::BasicTypeNode(b) => b.get_origin_type_with_infer(ctx, builder)?, + TypeNodeEnum::Basic(b) => b.get_origin_type_with_infer(ctx, builder)?, _ => unreachable!(), }; ctx.set_if_refs_tp(pltype.clone(), self.typename.range()); let mut sttype = match &*pltype.clone().borrow() { - PLType::STRUCT(s) => s.clone(), + PLType::Struct(s) => s.clone(), _ => { return Err(self .range @@ -614,7 +613,7 @@ impl Node for StructInitNode { } if !sttype.generic_map.is_empty() { if sttype.need_gen_code() { - pltype = Arc::new(RefCell::new(PLType::STRUCT( + pltype = Arc::new(RefCell::new(PLType::Struct( ctx.run_in_st_mod_mut(sttype, |ctx, sttype| { Ok(sttype.gen_code(ctx, builder)) })?, @@ -643,7 +642,7 @@ impl Node for StructInitNode { Ok(( Some(plv!(struct_pointer)), Some(pltype.clone()), - TerminatorEnum::NONE, + TerminatorEnum::None, )) }) } @@ -697,7 +696,7 @@ impl Node for ArrayInitNode { let sz = exps.len() as u32; let arr = builder.alloc( "array_alloca", - &PLType::ARR(ARRType { + &PLType::Arr(ARRType { element_type: tp, size: exps.len() as u32, }), @@ -712,11 +711,11 @@ impl Node for ArrayInitNode { } Ok(( Some(plv!(arr)), - Some(Arc::new(RefCell::new(PLType::ARR(ARRType { + Some(Arc::new(RefCell::new(PLType::Arr(ARRType { element_type: tp0.unwrap(), size: sz, })))), - TerminatorEnum::NONE, + TerminatorEnum::None, )) } } @@ -745,16 +744,16 @@ impl Node for GenericDefNode { _ctx: &'b mut Ctx<'a>, _builder: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } impl GenericDefNode { - pub fn emit_highlight<'a, 'ctx, 'b>(&self, ctx: &'b mut Ctx<'a>) { + pub fn emit_highlight(&self, ctx: &mut Ctx) { for g in self.generics.iter() { ctx.push_semantic_token(g.range, SemanticTokenType::TYPE, 0); } } - pub fn gen_generic_type<'a, 'ctx>(&self) -> IndexMap>> { + pub fn gen_generic_type(&self) -> IndexMap>> { let mut res = IndexMap::default(); for g in self.generics.iter() { let range = g.range; @@ -765,7 +764,7 @@ impl GenericDefNode { curpltype: None, trait_impl: None, }; - res.insert(name, Arc::new(RefCell::new(PLType::GENERIC(gentype)))); + res.insert(name, Arc::new(RefCell::new(PLType::Generic(gentype)))); } res } @@ -800,7 +799,7 @@ impl Node for GenericParamNode { _: &'b mut Ctx<'a>, _: &'b BuilderEnum<'a, 'ctx>, ) -> NodeResult { - Ok((None, None, TerminatorEnum::NONE)) + Ok((None, None, TerminatorEnum::None)) } } impl GenericParamNode { @@ -821,7 +820,7 @@ impl GenericParamNode { } Ok(res) } - pub fn emit_highlight<'a, 'ctx>(&self, ctx: &mut Ctx<'a>) { + pub fn emit_highlight(&self, ctx: &mut Ctx) { for g in self.generics.iter() { if g.is_some() { g.as_ref().unwrap().emit_highlight(ctx); diff --git a/src/ast/plmod.rs b/src/ast/plmod.rs index cd65aa9fd..02e1a0686 100644 --- a/src/ast/plmod.rs +++ b/src/ast/plmod.rs @@ -68,8 +68,8 @@ pub struct Mod { pub completions: Arc>>, pub completion_gened: Arc>, pub semantic_tokens_builder: Arc>>, // semantic token builder - pub hints: Arc>>>, - pub doc_symbols: Arc>>>, + pub hints: Arc>>, + pub doc_symbols: Arc>>, pub impls: FxHashMap>, pub macros: FxHashMap>, } @@ -80,12 +80,6 @@ pub type MutVec = RefCell>; pub struct CompletionItemWrapper(pub CompletionItem); impl Eq for CompletionItemWrapper {} - -impl CompletionItemWrapper { - pub fn into_completions(&self) -> CompletionItem { - self.0.clone() - } -} #[derive(Debug, Clone, PartialEq, Eq)] pub struct Gened(bool); @@ -139,8 +133,8 @@ impl Mod { semantic_tokens_builder: Arc::new(RefCell::new(Box::new(SemanticTokensBuilder::new( "builder".to_string(), )))), - hints: Arc::new(RefCell::new(Box::default())), - doc_symbols: Arc::new(RefCell::new(Box::default())), + hints: Arc::new(RefCell::new(vec![])), + doc_symbols: Arc::new(RefCell::new(vec![])), // refcache:Arc::new(RefCell::new(BTreeMap::new())), local_refs: Arc::new(RefCell::new(BTreeMap::new())), glob_refs: Arc::new(RefCell::new(BTreeMap::new())), @@ -223,10 +217,10 @@ impl Mod { return Some(pv.clone()); } if let Some(x) = PriType::try_from_str(name) { - return Some(Arc::new(RefCell::new(PLType::PRIMITIVE(x)))); + return Some(Arc::new(RefCell::new(PLType::Primitive(x)))); } if name == "void" { - return Some(Arc::new(RefCell::new(PLType::VOID))); + return Some(Arc::new(RefCell::new(PLType::Void))); } None } @@ -270,7 +264,7 @@ impl Mod { ..Default::default() }); }; - for (_, m) in &self.submods { + for m in self.submods.values() { if m.methods.get(full_name).is_none() { continue; } @@ -293,7 +287,7 @@ impl Mod { return Some(v.clone()); } } - for (_, m) in &self.submods { + for m in self.submods.values() { if let Some(v) = m.find_method(full_name, mthd) { return Some(v); } @@ -352,23 +346,21 @@ fn get_ns_path_completions_pri(path: &str, vmap: &mut FxHashMap>), - GENERIC(GenericType), - PLACEHOLDER(PlaceHolderType), - TRAIT(STType), + Fn(FNValue), + Struct(STType), + Arr(ARRType), + Primitive(PriType), + Void, + Pointer(Arc>), + Generic(GenericType), + PlaceHolder(PlaceHolderType), + Trait(STType), } /// # PriType /// Primitive type for pivot-lang #[derive(Debug, Clone, PartialEq, Eq)] +#[allow(clippy::upper_case_acronyms)] pub enum PriType { I8, I16, @@ -120,7 +121,7 @@ impl PriType { } } fn new_typename_node(name: &str, range: Range) -> Box { - Box::new(TypeNodeEnum::BasicTypeNode(TypeNameNode { + Box::new(TypeNodeEnum::Basic(TypeNameNode { id: Some(ExternIdNode { ns: vec![], id: Box::new(VarNode { @@ -136,24 +137,24 @@ fn new_typename_node(name: &str, range: Range) -> Box { })) } fn new_arrtype_node(typenode: Box, size: u64) -> Box { - Box::new(TypeNodeEnum::ArrayTypeNode(ArrayTypeNameNode { + Box::new(TypeNodeEnum::Array(ArrayTypeNameNode { id: typenode, size: Box::new(NodeEnum::Num(NumNode { - value: Num::INT(size), + value: Num::Int(size), range: Default::default(), })), range: Default::default(), })) } fn new_ptrtype_node(typenode: Box) -> Box { - Box::new(TypeNodeEnum::PointerTypeNode(PointerTypeNode { + Box::new(TypeNodeEnum::Pointer(PointerTypeNode { elm: typenode, range: Default::default(), })) } pub fn get_type_deep(pltype: Arc>) -> Arc> { match &*pltype.borrow() { - PLType::GENERIC(g) => { + PLType::Generic(g) => { if g.curpltype.is_some() { g.curpltype.as_ref().unwrap().clone() } else { @@ -171,56 +172,55 @@ fn expect_pub_err(err: ErrorCode, ctx: &Ctx, range: Range, name: String) -> Resu ctx.get_file(), format_label!("{} is not public", name), ) - .add_help("try add `pub` modifier before it".into()) + .add_help("try add `pub` modifier before it") .add_to_ctx(ctx)) } impl PLType { pub fn get_immix_type(&self) -> ObjectType { match self { - PLType::STRUCT(_) | PLType::ARR(_) => ObjectType::Complex, - PLType::POINTER(_) => ObjectType::Pointer, - PLType::TRAIT(_) => ObjectType::Trait, + PLType::Struct(_) | PLType::Arr(_) => ObjectType::Complex, + PLType::Pointer(_) => ObjectType::Pointer, + PLType::Trait(_) => ObjectType::Trait, _ => ObjectType::Atomic, } } pub fn get_kind_name(&self) -> String { match self { - PLType::PRIMITIVE(_) | PLType::VOID => "primitive".to_string(), - PLType::POINTER(_) => "pointer".to_string(), - PLType::ARR(_) => "array".to_string(), - PLType::STRUCT(_) => "struct".to_string(), - PLType::FN(_) => "function".to_string(), - PLType::PLACEHOLDER(_) => "placeholder".to_string(), - PLType::GENERIC(_) => "generic".to_string(), - PLType::TRAIT(_) => "trait".to_string(), + PLType::Primitive(_) | PLType::Void => "primitive".to_string(), + PLType::Pointer(_) => "pointer".to_string(), + PLType::Arr(_) => "array".to_string(), + PLType::Struct(_) => "struct".to_string(), + PLType::Fn(_) => "function".to_string(), + PLType::PlaceHolder(_) => "placeholder".to_string(), + PLType::Generic(_) => "generic".to_string(), + PLType::Trait(_) => "trait".to_string(), } } - pub fn get_typenode(&self, ctx: &Ctx) -> Box { + pub fn get_typenode(&self) -> Box { match self { - PLType::STRUCT(st) => new_typename_node(&st.name, st.range), - PLType::ARR(arr) => new_arrtype_node( - arr.get_elem_type().borrow().get_typenode(ctx), - arr.size as u64, - ), - PLType::PRIMITIVE(p) => new_typename_node(&p.get_name(), Default::default()), - PLType::VOID => new_typename_node("void", Default::default()), - PLType::POINTER(p) => new_ptrtype_node(p.borrow().get_typenode(ctx)), - PLType::GENERIC(g) => { + PLType::Struct(st) => new_typename_node(&st.name, st.range), + PLType::Arr(arr) => { + new_arrtype_node(arr.get_elem_type().borrow().get_typenode(), arr.size as u64) + } + PLType::Primitive(p) => new_typename_node(&p.get_name(), Default::default()), + PLType::Void => new_typename_node("void", Default::default()), + PLType::Pointer(p) => new_ptrtype_node(p.borrow().get_typenode()), + PLType::Generic(g) => { if g.curpltype.is_some() { - g.curpltype.as_ref().unwrap().borrow().get_typenode(ctx) + g.curpltype.as_ref().unwrap().borrow().get_typenode() } else { new_typename_node(&g.name, Default::default()) } } - PLType::PLACEHOLDER(p) => { + PLType::PlaceHolder(p) => { new_typename_node(&p.get_place_holder_name(), Default::default()) } _ => unreachable!(), } } pub fn is(&self, pri_type: &PriType) -> bool { - if let PLType::PRIMITIVE(pri) = self { + if let PLType::Primitive(pri) = self { pri == pri_type } else { false @@ -230,89 +230,89 @@ impl PLType { /// if support find refs pub fn if_refs(&self, f: impl FnOnce(&PLType)) { match self { - PLType::FN(_) | PLType::STRUCT(_) | PLType::TRAIT(_) => f(self), - PLType::ARR(_) => (), - PLType::PRIMITIVE(_) => (), - PLType::VOID => (), - PLType::POINTER(_) => (), - PLType::GENERIC(_) => (), - PLType::PLACEHOLDER(_) => (), + PLType::Fn(_) | PLType::Struct(_) | PLType::Trait(_) => f(self), + PLType::Arr(_) => (), + PLType::Primitive(_) => (), + PLType::Void => (), + PLType::Pointer(_) => (), + PLType::Generic(_) => (), + PLType::PlaceHolder(_) => (), } } pub fn get_name(&self) -> String { match self { - PLType::FN(fu) => fu.name.clone(), - PLType::STRUCT(st) => st.name.clone(), - PLType::PRIMITIVE(pri) => pri.get_name(), - PLType::ARR(arr) => { + PLType::Fn(fu) => fu.name.clone(), + PLType::Struct(st) => st.name.clone(), + PLType::Primitive(pri) => pri.get_name(), + PLType::Arr(arr) => { format!("[{} * {}]", arr.element_type.borrow().get_name(), arr.size) } - PLType::VOID => "void".to_string(), - PLType::POINTER(p) => "*".to_string() + &p.borrow().get_name(), - PLType::GENERIC(g) => { + PLType::Void => "void".to_string(), + PLType::Pointer(p) => "*".to_string() + &p.borrow().get_name(), + PLType::Generic(g) => { if g.curpltype.is_some() { g.curpltype.as_ref().unwrap().borrow().get_name() } else { g.name.clone() } } - PLType::PLACEHOLDER(p) => p.name.clone(), - PLType::TRAIT(t) => t.name.clone(), + PLType::PlaceHolder(p) => p.name.clone(), + PLType::Trait(t) => t.name.clone(), } } pub fn get_llvm_name(&self) -> String { match self { - PLType::FN(fu) => fu.name.clone(), - PLType::STRUCT(st) => st.name.clone(), - PLType::TRAIT(t) => t.name.clone(), - PLType::PRIMITIVE(pri) => pri.get_name(), - PLType::ARR(arr) => { + PLType::Fn(fu) => fu.name.clone(), + PLType::Struct(st) => st.name.clone(), + PLType::Trait(t) => t.name.clone(), + PLType::Primitive(pri) => pri.get_name(), + PLType::Arr(arr) => { format!("[{} * {}]", arr.element_type.borrow().get_name(), arr.size) } - PLType::VOID => "void".to_string(), - PLType::POINTER(p) => "*".to_string() + &p.borrow().get_name(), - PLType::GENERIC(g) => { + PLType::Void => "void".to_string(), + PLType::Pointer(p) => "*".to_string() + &p.borrow().get_name(), + PLType::Generic(g) => { if g.curpltype.is_some() { g.curpltype.as_ref().unwrap().borrow().get_name() } else { g.name.clone() } } - PLType::PLACEHOLDER(p) => p.get_place_holder_name(), + PLType::PlaceHolder(p) => p.get_place_holder_name(), } } pub fn get_full_elm_name(&self) -> String { match self { - PLType::GENERIC(g) => g.name.clone(), - PLType::FN(fu) => fu.llvmname.clone(), - PLType::STRUCT(st) => st.get_st_full_name(), - PLType::TRAIT(st) => st.get_st_full_name(), - PLType::PRIMITIVE(pri) => pri.get_name(), - PLType::ARR(arr) => { + PLType::Generic(g) => g.name.clone(), + PLType::Fn(fu) => fu.llvmname.clone(), + PLType::Struct(st) => st.get_st_full_name(), + PLType::Trait(st) => st.get_st_full_name(), + PLType::Primitive(pri) => pri.get_name(), + PLType::Arr(arr) => { format!( "[{} * {}]", arr.element_type.borrow().get_full_elm_name(), arr.size ) } - PLType::VOID => "void".to_string(), - PLType::POINTER(p) => p.borrow().get_full_elm_name(), - PLType::PLACEHOLDER(p) => p.name.clone(), + PLType::Void => "void".to_string(), + PLType::Pointer(p) => p.borrow().get_full_elm_name(), + PLType::PlaceHolder(p) => p.name.clone(), } } pub fn get_ptr_depth(&self) -> usize { match self { - PLType::POINTER(p) => p.borrow().get_ptr_depth() + 1, + PLType::Pointer(p) => p.borrow().get_ptr_depth() + 1, _ => 0, } } pub fn expect_pub(&self, ctx: &Ctx, range: Range) -> Result<(), PLDiag> { match self { - PLType::FN(f) => f.expect_pub(ctx, range), - PLType::STRUCT(s) => { + PLType::Fn(f) => f.expect_pub(ctx, range), + PLType::Struct(s) => { if s.path == ctx.plmod.path { return Ok(()); } @@ -328,7 +328,7 @@ impl PLType { ); Ok(()) } - PLType::TRAIT(st) => { + PLType::Trait(st) => { if st.path == ctx.plmod.path { return Ok(()); } @@ -352,30 +352,26 @@ impl PLType { /// get the defination range of the type pub fn get_range(&self) -> Option { match self { - PLType::GENERIC(g) => Some(g.range), - PLType::FN(f) => Some(f.range), - PLType::STRUCT(s) => Some(s.range), - PLType::ARR(_) => None, - PLType::PRIMITIVE(_) => None, - PLType::VOID => None, - PLType::POINTER(_) => None, - PLType::PLACEHOLDER(p) => Some(p.range), - PLType::TRAIT(t) => Some(t.range), + PLType::Generic(g) => Some(g.range), + PLType::Fn(f) => Some(f.range), + PLType::Struct(s) => Some(s.range), + PLType::Arr(_) => None, + PLType::Primitive(_) => None, + PLType::Void => None, + PLType::Pointer(_) => None, + PLType::PlaceHolder(p) => Some(p.range), + PLType::Trait(t) => Some(t.range), } } pub fn is_void(&self) -> bool { - if let PLType::VOID = self { - true - } else { - false - } + matches!(self, PLType::Void) } } pub enum RetTypeEnum<'ctx> { - VOID(VoidType<'ctx>), - BASIC(BasicTypeEnum<'ctx>), + Void(VoidType<'ctx>), + Basic(BasicTypeEnum<'ctx>), } impl<'ctx> RetTypeEnum<'ctx> { @@ -385,8 +381,8 @@ impl<'ctx> RetTypeEnum<'ctx> { is_var_args: bool, ) -> FunctionType<'ctx> { match self { - RetTypeEnum::VOID(t) => t.fn_type(param_types, is_var_args), - RetTypeEnum::BASIC(t) => t.fn_type(param_types, is_var_args), + RetTypeEnum::Void(t) => t.fn_type(param_types, is_var_args), + RetTypeEnum::Basic(t) => t.fn_type(param_types, is_var_args), } } } @@ -401,7 +397,7 @@ pub struct Field { } impl Field { - pub fn get_doc_symbol<'a, 'ctx>(&self) -> DocumentSymbol { + pub fn get_doc_symbol(&self) -> DocumentSymbol { #[allow(deprecated)] DocumentSymbol { name: self.name.clone(), @@ -416,7 +412,7 @@ impl Field { } } #[derive(Debug, Clone, PartialEq, Eq)] -pub struct FNType { +pub struct FnType { pub param_pltypes: Vec>, pub ret_pltype: Box, pub generic: bool, @@ -425,7 +421,7 @@ pub struct FNType { pub generic_map: IndexMap>>, pub generics_size: usize, // the size of generics except the generics from impl node } -impl FNType {} +impl FnType {} #[derive(Debug, Clone, PartialEq, Eq)] pub struct FNValue { pub name: String, // name for lsp @@ -436,14 +432,14 @@ pub struct FNValue { pub doc: Vec>, pub generic_infer: Arc>>>>, pub node: Option>, - pub fntype: FNType, + pub fntype: FnType, } impl TryFrom for FNValue { type Error = (); fn try_from(value: PLType) -> Result { match value { - PLType::FN(x) => Ok(x), + PLType::Fn(x) => Ok(x), _ => Err(()), } } @@ -506,7 +502,7 @@ impl FNValue { .generic_map .iter() .map(|(_, v)| match &*v.clone().borrow() { - PLType::GENERIC(g) => g.curpltype.as_ref().unwrap().borrow().get_llvm_name(), + PLType::Generic(g) => g.curpltype.as_ref().unwrap().borrow().get_llvm_name(), _ => unreachable!(), }) .collect::>() @@ -523,7 +519,7 @@ impl FNValue { ) -> Result { let name = self.append_name_with_generic(self.name.clone()); if let Some(pltype) = self.generic_infer.borrow().get(&name) { - if let PLType::FN(f) = &*pltype.borrow() { + if let PLType::Fn(f) = &*pltype.borrow() { return Ok(f.clone()); } unreachable!() @@ -539,7 +535,7 @@ impl FNValue { res.generic_infer = Arc::new(RefCell::new(IndexMap::default())); self.generic_infer .borrow_mut() - .insert(name, Arc::new(RefCell::new(PLType::FN(res.clone())))); + .insert(name, Arc::new(RefCell::new(PLType::Fn(res.clone())))); let block = ctx.block; ctx.need_highlight += 1; @@ -559,18 +555,18 @@ impl FNValue { .get_type(ctx, builder) .unwrap() .borrow() - .get_typenode(ctx); + .get_typenode(); res.fntype.param_pltypes = self .fntype .param_pltypes .iter() .map(|p| { - let np = p.get_type(ctx, builder).unwrap().borrow().get_typenode(ctx); + let np = p.get_type(ctx, builder).unwrap().borrow().get_typenode(); np }) .collect::>>(); let pltype = self.generic_infer.borrow().get(&res.name).unwrap().clone(); - pltype.replace(PLType::FN(res.clone())); + pltype.replace(PLType::Fn(res.clone())); Ok(res.clone()) } pub fn gen_snippet(&self) -> String { @@ -642,7 +638,7 @@ pub struct ARRType { } impl ARRType { - pub fn get_elem_type<'a, 'ctx>(&'a self) -> Arc> { + pub fn get_elem_type(&self) -> Arc> { self.element_type.clone() } } @@ -669,11 +665,11 @@ impl STType { .is_some() } pub fn implements_trait(&self, tp: &STType, plmod: &Mod) -> bool { - if self.implements_trait_curr_mod(&tp, plmod) { + if self.implements_trait_curr_mod(tp, plmod) { return true; } - for (_, plmod) in &plmod.submods { - if self.implements_trait(&tp, plmod) { + for plmod in plmod.submods.values() { + if self.implements_trait(tp, plmod) { return true; } } @@ -722,7 +718,7 @@ impl STType { .generic_map .iter() .map(|(_, v)| match &*v.clone().borrow() { - PLType::GENERIC(g) => g.curpltype.as_ref().unwrap().borrow().get_name(), + PLType::Generic(g) => g.curpltype.as_ref().unwrap().borrow().get_name(), _ => unreachable!(), }) .collect::>() @@ -737,7 +733,7 @@ impl STType { let name = self.append_name_with_generic(); if let Ok(pltype) = ctx.get_type(&name, Default::default()) { match &*pltype.borrow() { - PLType::STRUCT(st) => { + PLType::Struct(st) => { return st.clone(); } _ => unreachable!(), @@ -745,7 +741,7 @@ impl STType { } let mut res = self.clone(); res.name = name; - ctx.add_type_without_check(Arc::new(RefCell::new(PLType::STRUCT(res.clone())))); + ctx.add_type_without_check(Arc::new(RefCell::new(PLType::Struct(res.clone())))); res.ordered_fields = self .ordered_fields .iter() @@ -756,7 +752,7 @@ impl STType { .get_type(ctx, builder) .unwrap() .borrow() - .get_typenode(ctx); + .get_typenode(); nf }) .collect::>(); @@ -768,7 +764,7 @@ impl STType { builder.gen_st_visit_function(ctx, &res, &field_pltps); res.generic_map.clear(); let pltype = ctx.get_type(&res.name, Default::default()).unwrap(); - pltype.replace(PLType::STRUCT(res.clone())); + pltype.replace(PLType::Struct(res.clone())); res } pub fn get_field_completions(&self, must_pub: bool) -> Vec { @@ -791,25 +787,25 @@ impl STType { } completions } - pub fn get_mthd_completions<'a, 'ctx>(&self, ctx: &Ctx<'a>) -> Vec { + pub fn get_mthd_completions(&self, ctx: &Ctx) -> Vec { ctx.plmod .get_methods_completions(&self.get_st_full_name(), self.path != ctx.plmod.path) } - pub fn get_completions<'a, 'ctx>(&self, ctx: &Ctx<'a>) -> Vec { + pub fn get_completions(&self, ctx: &Ctx) -> Vec { let mut coms = self.get_field_completions(self.path != ctx.plmod.path); coms.extend(self.get_mthd_completions(ctx)); coms } - pub fn get_trait_completions<'a, 'ctx>(&self, ctx: &Ctx<'a>) -> Vec { + pub fn get_trait_completions(&self, ctx: &Ctx) -> Vec { let mut coms = self.get_trait_field_completions(); coms.extend(self.get_mthd_completions(ctx)); coms } - pub fn get_trait_field_completions<'a, 'ctx>(&self) -> Vec { + pub fn get_trait_field_completions(&self) -> Vec { let mut completions = Vec::new(); for (name, f) in &self.fields { - if let TypeNodeEnum::FuncTypeNode(func) = &*f.typenode { + if let TypeNodeEnum::Func(func) = &*f.typenode { completions.push(CompletionItem { kind: Some(CompletionItemKind::METHOD), label: name.clone(), @@ -827,7 +823,7 @@ impl STType { } completions } - pub fn find_method<'a, 'ctx>(&self, ctx: &Ctx<'a>, method: &str) -> Option { + pub fn find_method(&self, ctx: &Ctx, method: &str) -> Option { ctx.plmod .find_method(&self.get_st_full_name_except_generic(), method) } @@ -838,7 +834,7 @@ impl STType { let full_name = self.get_st_full_name(); full_name.split('<').collect::>()[0].to_string() } - pub fn get_doc_symbol<'a, 'ctx>(&self) -> DocumentSymbol { + pub fn get_doc_symbol(&self) -> DocumentSymbol { let children: Vec = self .ordered_fields .iter() @@ -858,7 +854,7 @@ impl STType { } } -pub fn add_primitive_types<'a, 'ctx>(ctx: &mut Ctx<'a>) { +pub fn add_primitive_types(ctx: &mut Ctx) { add_basic_types!( ctx.plmod.types, i128, @@ -875,7 +871,7 @@ pub fn add_primitive_types<'a, 'ctx>(ctx: &mut Ctx<'a>) { f32, bool ); - let pltype_void = PLType::VOID; + let pltype_void = PLType::Void; ctx.plmod .types .insert("void".to_string(), Arc::new(RefCell::new(pltype_void))); @@ -905,12 +901,12 @@ impl GenericType { range, }; let name_in_map = p.get_place_holder_name(); - let pltype = Arc::new(RefCell::new(PLType::PLACEHOLDER(p))); + let pltype = Arc::new(RefCell::new(PLType::PlaceHolder(p))); self.curpltype = Some(pltype.clone()); ctx.add_type(name_in_map, pltype, range).unwrap(); } } -generic_impl!(FNType, STType); +generic_impl!(FnType, STType); #[derive(Debug, Clone, PartialEq, Eq)] pub struct PlaceHolderType { pub name: String, diff --git a/src/ast/range.rs b/src/ast/range.rs index 3a2d684a5..fe4aec53d 100644 --- a/src/ast/range.rs +++ b/src/ast/range.rs @@ -119,7 +119,7 @@ impl Range { PLDiag::new_warn(*self, warn) } - pub fn to_diag_range(&self) -> lsp_types::Range { + pub fn to_diag_range(self) -> lsp_types::Range { if self.start.line < 1 { return Default::default(); } diff --git a/src/ast/test.rs b/src/ast/test.rs index 686bf5fa0..6eb14b300 100644 --- a/src/ast/test.rs +++ b/src/ast/test.rs @@ -34,7 +34,7 @@ mod test { A: Accumulator, dyn Db + 'db: HasJar<::Jar>, { - let docs = MemDocs::new(); + let docs = MemDocs::default(); let pos = if let Some((pos, _)) = params { Some(pos) } else { @@ -57,7 +57,7 @@ mod test { #[test] fn test_memory_leak() { let db = &mut Database::default(); - let docs = MemDocs::new(); + let docs = MemDocs::default(); let params = Some(( Pos { line: 2, @@ -442,7 +442,7 @@ mod test { use crate::ast::compiler::{compile, Options}; - let docs = MemDocs::new(); + let docs = MemDocs::default(); let mut db = Database::default(); let input = MemDocsInput::new( &db, diff --git a/src/ast/tokens.rs b/src/ast/tokens.rs index c80bef646..7741b4107 100644 --- a/src/ast/tokens.rs +++ b/src/ast/tokens.rs @@ -8,6 +8,7 @@ macro_rules! define_tokens { ),*) => { #[derive(Debug, PartialEq, Clone, Copy, Eq, Hash)] #[allow(non_camel_case_types)] + #[allow(clippy::upper_case_acronyms)] pub enum TokenType { $($ident),* } diff --git a/src/flow/mod.rs b/src/flow/mod.rs index 2c33e2c6b..876efd6c8 100644 --- a/src/flow/mod.rs +++ b/src/flow/mod.rs @@ -7,7 +7,7 @@ use petgraph::EdgeDirection; pub mod display; pub mod test; // ANCHOR: nodeandedge -#[derive(Debug, Clone, PartialEq)] +#[derive(Debug, Clone, PartialEq, Eq)] pub enum GraphNodeType { Dummy, // 虚节点 Begin, // 起点 @@ -67,7 +67,7 @@ impl ProgramNode { let mut graphs = vec![]; for func in &self.fntypes { if let Some(body) = func.body.clone() { - let graph = from_ast(Box::new(NodeEnum::STS(body))); + let graph = from_ast(Box::new(NodeEnum::Sts(body))); graphs.push(GraphWrapper { name: func .id @@ -91,7 +91,7 @@ fn build_graph(ast: Box, context: &mut GraphContext) { let break_target = context.break_target; let continue_target = context.continue_target; match *ast { - NodeEnum::STS(v) => { + NodeEnum::Sts(v) => { let mut sub_source = context.graph.add_node(GraphNodeType::Dummy); let mut sub_sink = context.graph.add_node(GraphNodeType::Dummy); context @@ -175,7 +175,7 @@ fn build_graph(ast: Box, context: &mut GraphContext) { context.local_source = sub_source; context.local_sink = sub_sink; // 调用前构建虚节点作为锚点 - build_graph(Box::new(NodeEnum::STS(*s.then)), context); + build_graph(Box::new(NodeEnum::Sts(*s.then)), context); // 调用后要恢复原来的锚点 context.local_source = local_source; context.local_sink = local_sink; @@ -222,7 +222,7 @@ fn build_graph(ast: Box, context: &mut GraphContext) { context.break_target = local_sink; context.local_source = sub_source; context.local_sink = sub_sink; - build_graph(Box::new(NodeEnum::STS(*s.body)), context); + build_graph(Box::new(NodeEnum::Sts(*s.body)), context); context.continue_target = continue_target; context.break_target = break_target; context.local_source = local_source; @@ -274,7 +274,7 @@ fn build_graph(ast: Box, context: &mut GraphContext) { context.break_target = local_sink; context.local_source = sub_source; context.local_sink = sub_sink; - build_graph(Box::new(NodeEnum::STS(*s.body)), context); + build_graph(Box::new(NodeEnum::Sts(*s.body)), context); context.continue_target = continue_target; context.break_target = break_target; context.local_source = local_source; diff --git a/src/flow/test.rs b/src/flow/test.rs index f9150a172..f27100f9d 100644 --- a/src/flow/test.rs +++ b/src/flow/test.rs @@ -13,7 +13,7 @@ mod test { } "; let (_, node) = statement_block(Span::from(s)).unwrap(); - let graph = from_ast(Box::new(NodeEnum::STS(node))); + let graph = from_ast(Box::new(NodeEnum::Sts(node))); let exp = "digraph test { D0 [shape=box, style=rounded, label=\"begin\", fontname=\"\"]; {rank = sink; D1 [shape=box, style=rounded, label=\"end\", fontname=\"\"];} @@ -37,7 +37,7 @@ mod test { } "; let (_, node) = statement_block(Span::from(s)).unwrap(); - let graph = from_ast(Box::new(NodeEnum::STS(node))); + let graph = from_ast(Box::new(NodeEnum::Sts(node))); let exp = "digraph test{ D0[shape=box,style=rounded,label=\"begin\",fontname=\"\"]; {rank=sink;D1[shape=box,style=rounded,label=\"end\",fontname=\"\"];} @@ -65,7 +65,7 @@ mod test { } "; let (_, node) = statement_block(Span::from(s)).unwrap(); - let graph = from_ast(Box::new(NodeEnum::STS(node))); + let graph = from_ast(Box::new(NodeEnum::Sts(node))); let exp = "digraph test{ D0[shape=box,style=rounded,label=\"begin\",fontname=\"\"]; {rank=sink;D1[shape=box,style=rounded,label=\"end\",fontname=\"\"];} @@ -95,7 +95,7 @@ mod test { } "; let (_, node) = statement_block(Span::from(s)).unwrap(); - let graph = from_ast(Box::new(NodeEnum::STS(node))); + let graph = from_ast(Box::new(NodeEnum::Sts(node))); let exp = "digraph test{ D0[shape=box,style=rounded,label=\"begin\",fontname=\"\"]; {rank=sink;D1[shape=box,style=rounded,label=\"end\",fontname=\"\"];} diff --git a/src/lsp/mem_docs.rs b/src/lsp/mem_docs.rs index ce195e539..2486f0b80 100644 --- a/src/lsp/mem_docs.rs +++ b/src/lsp/mem_docs.rs @@ -20,7 +20,7 @@ use crate::{ use super::helpers::position_to_offset; -#[derive(Debug, Clone)] +#[derive(Debug, Clone, Default)] pub struct MemDocs { docs: FxHashMap, } @@ -176,11 +176,6 @@ impl MemDocsInput { } impl MemDocs { - pub fn new() -> Self { - MemDocs { - docs: FxHashMap::default(), - } - } pub fn change(&mut self, db: &mut dyn Db, range: lsp_types::Range, uri: String, text: String) { let doc = self.docs.get_mut(&uri).unwrap(); let mut txt = doc.text(db).clone(); @@ -235,7 +230,7 @@ mod tests { #[test] fn test_mem_docs() { let db = &mut Database::default(); - let mut mem_docs = MemDocs::new(); + let mut mem_docs = MemDocs::default(); mem_docs.insert( db, "test".to_string(), diff --git a/src/lsp/mod.rs b/src/lsp/mod.rs index 869d40c6f..a7f163d4c 100644 --- a/src/lsp/mod.rs +++ b/src/lsp/mod.rs @@ -159,7 +159,7 @@ fn main_loop( let pool = ThreadPool::new(n_workers); let mut db = db::Database::default(); let _params: InitializeParams = serde_json::from_value(params).unwrap(); - let docs = Arc::new(Mutex::new(RefCell::new(MemDocs::new()))); + let docs = Arc::new(Mutex::new(RefCell::new(MemDocs::default()))); let docin = MemDocsInput::new( &db, docs.clone(), @@ -397,7 +397,7 @@ fn main_loop( docin.set_edit_pos(&mut db).to(Some(pos)); docin.set_docs(&mut db).to(docs.clone()); } - docin.set_file(&mut db).to(f.clone()); + docin.set_file(&mut db).to(f); docin.set_action(&mut db).to(ActionType::Diagnostic); compile_dry(&db, docin); @@ -408,7 +408,7 @@ fn main_loop( debug!("diags: {:#?}", diags); let mut m = FxHashMap::>::default(); for (p, diags) in &diags { - diags.iter().for_each(|x| x.get_diagnostic(&p, &mut m)); + diags.iter().for_each(|x| x.get_diagnostic(p, &mut m)); } for (p, _) in &diags { if m.get(p).is_none() { @@ -423,13 +423,13 @@ fn main_loop( .on_noti::(|params| { let f = url_to_path(params.text_document.uri); docs.lock().unwrap().borrow_mut().insert( - &mut db, + &db, f.clone(), params.text_document.text, f.clone(), ); docin.set_docs(&mut db).to(docs.clone()); - docin.set_file(&mut db).to(f.clone()); + docin.set_file(&mut db).to(f); docin.set_action(&mut db).to(ActionType::Diagnostic); docin.set_params(&mut db).to(None); compile_dry(&db, docin); diff --git a/src/lsp/text.rs b/src/lsp/text.rs index a89de2ac5..1b7d2bd6d 100644 --- a/src/lsp/text.rs +++ b/src/lsp/text.rs @@ -31,7 +31,7 @@ pub fn diff(left: &str, right: &str) -> TextDiff { } builder } -#[derive(Debug, Clone, PartialEq)] +#[derive(Debug, Clone, PartialEq, Eq)] pub struct Indel { pub insert: String, pub delete: TextRange, diff --git a/src/main.rs b/src/main.rs index d3ce918d6..0dc47c38e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -170,10 +170,7 @@ fn main() { .quiet(cli.quiet) .verbosity(cli.verbose as usize); - let fmt = match cli.command { - Some(RunCommand::Fmt) => true, - _ => false, - }; + let fmt = matches!(cli.command, Some(RunCommand::Fmt)); // You can check the value provided by positional arguments, or option arguments if let Some(name) = cli.name.as_deref() { logger.timestamp(stderrlog::Timestamp::Off).init().unwrap(); @@ -198,7 +195,7 @@ fn main() { }; let mem = MemDocsInput::new( &db, - Arc::new(Mutex::new(RefCell::new(mem_docs::MemDocs::new()))), + Arc::new(Mutex::new(RefCell::new(mem_docs::MemDocs::default()))), abs.to_str().unwrap().to_string(), op, action, diff --git a/src/nomparser/array.rs b/src/nomparser/array.rs index 5c2ca2a2a..d9c16e408 100644 --- a/src/nomparser/array.rs +++ b/src/nomparser/array.rs @@ -54,10 +54,10 @@ pub fn array_element_op(input: Span) -> IResult((ComplexOp::IndexOp(idx), com)) + Ok::<_, ()>((ComplexOp::Index(idx), com)) } else { Ok::<_, ()>(( - ComplexOp::IndexOp(Box::new(NodeEnum::Err(ErrorNode { + ComplexOp::Index(Box::new(NodeEnum::Err(ErrorNode { msg: String::from("Nedded index for array element access"), src: String::from("[]"), code: ErrorCode::NEEDED_INDEX_FOR_ARRAY_ELEMENT_ACCESS, diff --git a/src/nomparser/constval.rs b/src/nomparser/constval.rs index 3429b0434..20130b0ce 100644 --- a/src/nomparser/constval.rs +++ b/src/nomparser/constval.rs @@ -23,11 +23,11 @@ pub fn number(input: Span) -> IResult> { let (input, _) = space0(input)?; let (re, value) = alt(( map_res(float, |out| { - Ok::(Num::FLOAT(out.fragment().parse::().unwrap())) + Ok::(Num::Float(out.fragment().parse::().unwrap())) }), map_res(decimal, |out| { // TODO:err tolerate - Ok::(Num::INT( + Ok::(Num::Int( out.fragment().replace('_', "").parse::().unwrap(), )) }), diff --git a/src/nomparser/expression.rs b/src/nomparser/expression.rs index d39ae190e..0a884ccf2 100644 --- a/src/nomparser/expression.rs +++ b/src/nomparser/expression.rs @@ -96,8 +96,8 @@ pub fn pointer_exp(input: Span) -> IResult> { for op in ops.into_iter().rev() { let (op, op_range) = op; let op = match op { - TokenType::TAKE_PTR => PointerOpEnum::ADDR, - TokenType::TAKE_VAL => PointerOpEnum::DEREF, + TokenType::TAKE_PTR => PointerOpEnum::Addr, + TokenType::TAKE_VAL => PointerOpEnum::Deref, _ => unreachable!(), }; let range = op_range.start.to(exp_range.end); @@ -148,7 +148,7 @@ fn complex_exp(input: Span) -> IResult> { let mut res = head; for op in ops { res = match op.0 { - ComplexOp::CallOp((args, params_range, generic_params)) => { + ComplexOp::Call((args, params_range, generic_params)) => { let mut range = res.range(); if !args.is_empty() { range = res.range().start.to(params_range.end); @@ -164,7 +164,7 @@ fn complex_exp(input: Span) -> IResult> { .into(), ) } - ComplexOp::IndexOp(index) => { + ComplexOp::Index(index) => { let range = res.range().start.to(index.range().end); Box::new( ArrayElementNode { @@ -176,16 +176,15 @@ fn complex_exp(input: Span) -> IResult> { .into(), ) } - ComplexOp::FieldOp(field) => { - let range; - if field.is_some() { - range = res.range().start.to(field.clone().unwrap().range().end); + ComplexOp::Field(field) => { + let range = if field.is_some() { + res.range().start.to(field.clone().unwrap().range().end) } else { let mut end = res.range().end; end.column += 1; end.offset += 1; - range = res.range().start.to(end); - } + res.range().start.to(end) + }; Box::new( TakeOpNode { range, @@ -242,7 +241,7 @@ fn take_exp_op(input: Span) -> IResult>)> { tag_token_symbol(TokenType::DOT), pair(opt(identifier), many0(comment)), ), - |(idx, coms)| Ok::<_, ()>((ComplexOp::FieldOp(idx), coms)), + |(idx, coms)| Ok::<_, ()>((ComplexOp::Field(idx), coms)), ))(input) } diff --git a/src/nomparser/function.rs b/src/nomparser/function.rs index f5e5294b0..aaeb931b4 100644 --- a/src/nomparser/function.rs +++ b/src/nomparser/function.rs @@ -141,10 +141,7 @@ pub fn call_function_op(input: Span) -> IResult(( - ComplexOp::CallOp((paras, st.start.to(end.end), generic)), - com, - )) + Ok::<_, ()>((ComplexOp::Call((paras, st.start.to(end.end), generic)), com)) }, ))(input) } diff --git a/src/nomparser/helper.rs b/src/nomparser/helper.rs index c2ae88735..2b8089c99 100644 --- a/src/nomparser/helper.rs +++ b/src/nomparser/helper.rs @@ -130,9 +130,7 @@ pub fn res_box(i: Box) -> Result, ()> { Ok::<_, ()>(i) } -pub fn create_bin( - (mut left, rights): (Box, Vec<((TokenType, Range), Box)>), -) -> Result, ()> { +pub fn create_bin((mut left, rights): PLBin) -> Result, ()> { for ((op, orange), right) in rights { let range = left.range().start.to(right.range().end); left = Box::new( @@ -147,3 +145,4 @@ pub fn create_bin( } res_box(left) } +type PLBin = (Box, Vec<((TokenType, Range), Box)>); diff --git a/src/nomparser/identifier.rs b/src/nomparser/identifier.rs index 3900163f9..6283eba96 100644 --- a/src/nomparser/identifier.rs +++ b/src/nomparser/identifier.rs @@ -47,11 +47,11 @@ pub fn extern_identifier(input: Span) -> IResult> { |(mut ns, opt, opt2)| { let id = ns.pop().unwrap(); let mut range = id.range(); - if opt.is_some() { - range = range.start.to(opt.unwrap().1.end); + if let Some(opt) = opt { + range = range.start.to(opt.1.end); } - if opt2.is_some() { - range = range.start.to(opt2.unwrap().1.end); + if let Some(opt2) = opt2 { + range = range.start.to(opt2.1.end); } res_enum( ExternIdNode { @@ -100,7 +100,7 @@ pub fn typed_identifier(input: Span) -> IResult> let mut tprange = range; tprange.end.column += 1; tprange.start = tprange.end; - let mut typenode = Box::new(TypeNodeEnum::BasicTypeNode(TypeNameNode { + let mut typenode = Box::new(TypeNodeEnum::Basic(TypeNameNode { id: None, range: tprange, generic_params: None, diff --git a/src/nomparser/mod.rs b/src/nomparser/mod.rs index e1bd405e6..33b480202 100644 --- a/src/nomparser/mod.rs +++ b/src/nomparser/mod.rs @@ -73,9 +73,9 @@ pub enum TopLevel { #[derive(Clone)] pub enum ComplexOp { - CallOp((Vec>, Range, Option>)), - IndexOp(Box), - FieldOp(Option>), + Call((Vec>, Range, Option>)), + Index(Box), + Field(Option>), } #[salsa::input] diff --git a/src/nomparser/pkg.rs b/src/nomparser/pkg.rs index cbc9ecbb3..df8133762 100644 --- a/src/nomparser/pkg.rs +++ b/src/nomparser/pkg.rs @@ -37,11 +37,11 @@ pub fn use_statement(input: Span) -> IResult> { .range() .start .to(ns.last().unwrap().range().end); - if opt.is_some() { - range = range.start.to(opt.unwrap().1.end); + if let Some(opt) = opt { + range = range.start.to(opt.1.end); } - if opt2.is_some() { - range = range.start.to(opt2.unwrap().1.end); + if let Some(opt2) = opt2 { + range = range.start.to(opt2.1.end); } res_enum(NodeEnum::UseNode(UseNode { ids: ns, diff --git a/src/nomparser/program.rs b/src/nomparser/program.rs index 2e18dec52..878cc2d3a 100644 --- a/src/nomparser/program.rs +++ b/src/nomparser/program.rs @@ -62,7 +62,7 @@ pub fn program(input: Span) -> IResult> { let imname = FmtBuilder::generate_node(&im.target); let target = *im.target.clone(); if let Some((t, _)) = &im.impl_trait { - let trait_name = FmtBuilder::generate_node(&t); + let trait_name = FmtBuilder::generate_node(t); trait_impls.push((imname.clone(), trait_name)); } for mth in im.methods.iter_mut() { @@ -79,12 +79,10 @@ pub fn program(input: Span) -> IResult> { name: "self".to_string(), range: Default::default(), }, - typenode: Box::new(TypeNodeEnum::PointerTypeNode( - PointerTypeNode { - elm: Box::new(target.clone()), - range: Default::default(), - }, - )), + typenode: Box::new(TypeNodeEnum::Pointer(PointerTypeNode { + elm: Box::new(target.clone()), + range: Default::default(), + })), doc: None, range: Default::default(), }), diff --git a/src/nomparser/string_literal.rs b/src/nomparser/string_literal.rs index 802c33f99..48b5f65dd 100644 --- a/src/nomparser/string_literal.rs +++ b/src/nomparser/string_literal.rs @@ -108,7 +108,7 @@ fn parse_literal<'a, E: ParseError>>(input: Span<'a>) -> IResult { Literal(Span<'a>), EscapedChar(char), - EscapedWS, + EscapedWs, } /// Combine parse_literal, parse_escaped_whitespace, and parse_escaped_char @@ -122,7 +122,7 @@ where // of that parser. map(parse_literal, StringFragment::Literal), map(parse_escaped_char, StringFragment::EscapedChar), - value(StringFragment::EscapedWS, parse_escaped_whitespace), + value(StringFragment::EscapedWs, parse_escaped_whitespace), ))(input) } @@ -145,7 +145,7 @@ where match fragment { StringFragment::Literal(s) => string.push_str(&s), StringFragment::EscapedChar(c) => string.push(c), - StringFragment::EscapedWS => {} + StringFragment::EscapedWs => {} } string }, diff --git a/src/nomparser/structure.rs b/src/nomparser/structure.rs index 1ea492d20..b8d3b4b7e 100644 --- a/src/nomparser/structure.rs +++ b/src/nomparser/structure.rs @@ -1,3 +1,4 @@ +use crate::ast::node::types::StructField; use crate::nomparser::Span; use crate::{ ast::node::types::StructDefNode, @@ -65,7 +66,11 @@ pub fn struct_def(input: Span) -> IResult> { f.0 .1.doc = Some(c); } } - fieldlist.push((f.0 .1.clone(), f.1.is_some(), f.0 .0)); + fieldlist.push(StructField { + id: f.0 .1.clone(), + has_semi: f.1.is_some(), + modifier: f.0 .0, + }); } let mut docs = vec![]; let mut precoms = vec![]; diff --git a/src/nomparser/types.rs b/src/nomparser/types.rs index 528e3ad3e..55482ecd4 100644 --- a/src/nomparser/types.rs +++ b/src/nomparser/types.rs @@ -31,10 +31,7 @@ pub fn type_name(input: Span) -> IResult> { let mut node = n; for _ in pts { let range = node.range(); - node = Box::new(TypeNodeEnum::PointerTypeNode(PointerTypeNode { - elm: node, - range, - })); + node = Box::new(TypeNodeEnum::Pointer(PointerTypeNode { elm: node, range })); } res_box(node) }, @@ -52,7 +49,7 @@ pub fn basic_type(input: Span) -> IResult> { _ => unreachable!(), }; let range = exid.range; - Ok::<_, ()>(Box::new(TypeNodeEnum::BasicTypeNode(TypeNameNode { + Ok::<_, ()>(Box::new(TypeNodeEnum::Basic(TypeNameNode { generic_params, id: Some(exid), range, @@ -73,7 +70,7 @@ fn array_type(input: Span) -> IResult> { |(_, tp, _, size, _)| { let range = size.range().start.to(tp.range().end); - Ok::<_, ()>(Box::new(TypeNodeEnum::ArrayTypeNode(ArrayTypeNameNode { + Ok::<_, ()>(Box::new(TypeNodeEnum::Array(ArrayTypeNameNode { id: tp, size, range, diff --git a/src/utils/plc_new.rs b/src/utils/plc_new.rs index 1cbeb89d6..d6a97ee5d 100644 --- a/src/utils/plc_new.rs +++ b/src/utils/plc_new.rs @@ -92,7 +92,7 @@ pub mod tests { let input = MemDocsInput::new( &db, - Arc::new(Mutex::new(RefCell::new(mem_docs::MemDocs::new()))), + Arc::new(Mutex::new(RefCell::new(mem_docs::MemDocs::default()))), "plc_new_testfile/main.pi".to_string(), Default::default(), ActionType::Compile, diff --git a/src/utils/read_config.rs b/src/utils/read_config.rs index ae8ed9190..cb4069494 100644 --- a/src/utils/read_config.rs +++ b/src/utils/read_config.rs @@ -16,15 +16,13 @@ pub fn get_config_path(current: String) -> Result { return Err("找不到配置文件～"); } let dir = dir.unwrap(); - for x in dir { - if let Ok(path) = x { - if path.file_name().eq("Kagari.toml") { - if let Some(p) = cur_path.to_str() { - let res = p.to_string(); - return Ok(res + "/Kagari.toml"); - } else { - return Err("找不到配置文件～"); - } + for path in dir.flatten() { + if path.file_name().eq("Kagari.toml") { + if let Some(p) = cur_path.to_str() { + let res = p.to_string(); + return Ok(res + "/Kagari.toml"); + } else { + return Err("找不到配置文件～"); } } } @@ -38,7 +36,7 @@ pub fn get_config_path(current: String) -> Result { } else { return Err("找不到配置文件～"); } - return get_config_path(next_path); + get_config_path(next_path) } #[derive(Deserialize, Clone, Debug, PartialEq, Eq, Default, Hash)] @@ -94,17 +92,17 @@ pub fn get_config(db: &dyn Db, entry: SourceProgram) -> Result { return Err("KAGARI_LIB_ROOT没有指向合法的目录，无法找到系统库".to_string()); } let libroot = libroot.unwrap(); - for x in libroot { - if let Ok(path) = x { - if path.path().is_dir() && !path.file_name().eq("thirdparty") { - let mut dep = Dependency::default(); - dep.path = dunce::canonicalize(path.path()) + for path in libroot.flatten() { + if path.path().is_dir() && !path.file_name().eq("thirdparty") { + let dep = Dependency { + path: dunce::canonicalize(path.path()) .unwrap() .to_str() .unwrap() - .to_string(); - deps.insert(path.file_name().to_str().unwrap().to_string(), dep); - } + .to_string(), + ..Default::default() + }; + deps.insert(path.file_name().to_str().unwrap().to_string(), dep); } } let binding = lib_path.join("thirdparty"); @@ -149,8 +147,8 @@ pub fn get_config(db: &dyn Db, entry: SourceProgram) -> Result { .map(|mut b| { let (child, target) = kagari::download_repo(&git, third_party); pb.set_message(format!("正在下载依赖{}", k)); - if child.is_some() { - child.unwrap().unwrap(); + if let Some(child) = child { + child.unwrap(); } if let Some(sum) = sums.get(k) { b = sum.git.clone().unwrap().commit; @@ -173,8 +171,10 @@ pub fn get_config(db: &dyn Db, entry: SourceProgram) -> Result { }), }, ); - let mut dep = Dependency::default(); - dep.path = target.to_string_lossy().to_string(); + let dep = Dependency { + path: target.to_string_lossy().to_string(), + ..Default::default() + }; deps.insert(k.clone(), dep); }) }) @@ -210,8 +210,8 @@ pub fn get_config(db: &dyn Db, entry: SourceProgram) -> Result { }); pb.inc(1); }); - if err.is_some() { - return Err(err.unwrap()); + if let Some(err) = err { + return Err(err); } config.deps = Some(deps); } From bb452d9f0d0fca4565f4f11091b6001cd0c0b716 Mon Sep 17 00:00:00 2001 From: kamome <2038975825@qq.com> Date: Tue, 28 Mar 2023 16:09:37 +0800 Subject: [PATCH 2/2] fix:test --- .github/workflows/test.yml | 2 -- src/ast/ctx.rs | 64 +++++++++++--------------------------- src/ast/node/implement.rs | 47 +++++++++++++++------------- 3 files changed, 44 insertions(+), 69 deletions(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index eb244e83a..05ed4fa28 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -170,8 +170,6 @@ jobs: - name: Run cargo clippy uses: actions-rs/clippy-check@v1 - env: - RUSTFLAGS: "" with: token: ${{ secrets.GITHUB_TOKEN }} args: --all-features \ No newline at end of file diff --git a/src/ast/ctx.rs b/src/ast/ctx.rs index 3aa13197f..f06586015 100644 --- a/src/ast/ctx.rs +++ b/src/ast/ctx.rs @@ -435,17 +435,6 @@ impl<'a, 'ctx> Ctx<'a> { pltype: Arc>, range: Range, ) -> Result<(), PLDiag> { - if let PLType::Generic(g) = &*pltype.borrow() { - if g.curpltype.is_some() { - let cur = g.curpltype.as_ref().unwrap(); - return self.add_type( - cur.borrow().get_name(), - cur.clone(), - cur.borrow().get_range().unwrap(), - ); - } - unreachable!() - } if self.plmod.types.contains_key(&name) { return Err(self.add_diag(range.new_err(ErrorCode::REDEFINE_TYPE))); } @@ -801,15 +790,12 @@ impl<'a, 'ctx> Ctx<'a> { fn get_tp_completions(&self, m: &mut FxHashMap) { for (k, f) in self.plmod.types.iter() { let tp = match &*f.borrow() { - PLType::Fn(_) => continue, - PLType::Arr(_) => continue, PLType::PlaceHolder(_) => CompletionItemKind::STRUCT, PLType::Generic(_) => CompletionItemKind::TYPE_PARAMETER, PLType::Struct(_) => CompletionItemKind::STRUCT, PLType::Trait(_) => CompletionItemKind::INTERFACE, - PLType::Primitive(_) => CompletionItemKind::KEYWORD, - PLType::Void => CompletionItemKind::KEYWORD, - PLType::Pointer(_) => todo!(), + PLType::Primitive(_) | PLType::Void => CompletionItemKind::KEYWORD, + _ => continue, }; m.insert( k.to_string(), @@ -1083,36 +1069,24 @@ impl<'a, 'ctx> Ctx<'a> { need_up_cast: false, }; } + if l != r { + let trait_pltype = l; + let st_pltype = self.auto_deref_tp(r); + if let (PLType::Trait(t), PLType::Struct(st)) = + (&*trait_pltype.borrow(), &*st_pltype.borrow()) + { + return EqRes { + eq: st.implements_trait(t, &self.plmod), + need_up_cast: true, + }; + }; + return EqRes { + eq: false, + need_up_cast: false, + }; + } EqRes { - eq: match (&*l.borrow(), &*r.borrow()) { - (PLType::Primitive(l), PLType::Primitive(r)) => l == r, - (PLType::Void, PLType::Void) => true, - (PLType::Pointer(l), PLType::Pointer(r)) => self.eq(l.clone(), r.clone()).eq, - (PLType::Arr(l), PLType::Arr(r)) => { - self.eq(l.get_elem_type(), r.get_elem_type()).eq && l.size == r.size - } - (PLType::Struct(l), PLType::Struct(r)) => l.name == r.name && l.path == r.path, - (PLType::Fn(l), PLType::Fn(r)) => l == r, - (PLType::PlaceHolder(l), PLType::PlaceHolder(r)) => l == r, - _ => { - if l != r { - let trait_pltype = l.clone(); - let st_pltype = r.clone(); - let st_pltype = self.auto_deref_tp(st_pltype); - if let (PLType::Trait(t), PLType::Struct(st)) = - (&*trait_pltype.borrow(), &*st_pltype.borrow()) - { - return EqRes { - eq: st.implements_trait(t, &self.plmod), - need_up_cast: true, - }; - }; - false - } else { - true - } - } - }, + eq: true, need_up_cast: false, } } diff --git a/src/ast/node/implement.rs b/src/ast/node/implement.rs index 96683d012..4654a4791 100644 --- a/src/ast/node/implement.rs +++ b/src/ast/node/implement.rs @@ -53,29 +53,32 @@ impl Node for ImplNode { } self.target.emit_highlight(ctx); let mut method_docsymbols = vec![]; - if let TypeNodeEnum::Pointer(pt) = &*self.target { - if let TypeNodeEnum::Basic(bt) = &*pt.elm { - let st_pltype = bt.get_origin_type_with_infer(ctx, builder)?; - if let PLType::Struct(sttp) = &*st_pltype.borrow() { - if let Some((t, _)) = &self.impl_trait { - let trait_tp = t.get_type(ctx, builder)?; - let name = trait_tp.borrow().get_kind_name(); - if let PLType::Trait(st) = &*trait_tp.borrow_mut() { - ctx.send_if_go_to_def(t.range(), st.range, st.path.clone()); - } else { - t.range() - .new_err(ErrorCode::EXPECT_TRAIT_TYPE) - .add_label( - t.range(), - ctx.get_file(), - format_label!("type {}", name), - ) //Some(("type {}".to_string(), vec![name]))) - .add_to_ctx(ctx); - }; - } - ctx.send_if_go_to_def(self.target.range(), sttp.range, sttp.path.clone()); - }; + if let TypeNodeEnum::Basic(bt) = &*self.target { + if bt.id.is_none() { + ctx.if_completion(bt.range, || ctx.get_type_completions()); + return Err(ctx.add_diag(bt.range.new_err(ErrorCode::EXPECT_TYPE))); } + let (_, pltype, _) = bt.id.as_ref().unwrap().get_type(ctx)?; + let st_pltype = pltype.unwrap(); + if let PLType::Struct(sttp) = &*st_pltype.borrow() { + ctx.send_if_go_to_def(self.target.range(), sttp.range, sttp.path.clone()); + }; + } + if let Some((typename, _)) = &self.impl_trait { + let trait_tp = typename.get_type(ctx, builder)?; + if let PLType::Trait(st) = &*trait_tp.borrow_mut() { + ctx.send_if_go_to_def(typename.range(), st.range, st.path.clone()); + } else { + typename + .range() + .new_err(ErrorCode::EXPECT_TRAIT_TYPE) + .add_label( + typename.range(), + ctx.get_file(), + format_label!("type {}", trait_tp.borrow().get_kind_name()), + ) + .add_to_ctx(ctx); + }; } for method in &mut self.methods { let res = method.emit(ctx, builder);