M-Labs/nac3
M-Labs
/
nac3
8
0
Fork 10
Code Issues 98 Pull Requests 20 Releases Wiki Activity

fix clippy warnings

This commit is contained in:
pca006132 2021-11-06 23:00:18 +08:00
parent 34cf303e6c
commit ffa89e9308
5 changed files with 62 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
nac3artiq/src/timeline.rs
View File

@ -18,12 +18,11 @@ impl TimeFns for NowPinningTimeFns {
.unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now")); .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
let now_raw = ctx.builder.build_load(now.as_pointer_value(), "now"); let now_raw = ctx.builder.build_load(now.as_pointer_value(), "now");
if let BasicValueEnum::IntValue(now_raw) = now_raw { if let BasicValueEnum::IntValue(now_raw) = now_raw {
let i64_32 = i64_type.const_int(32, false).into(); let i64_32 = i64_type.const_int(32, false);
let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now_shl"); let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now_shl");
let now_hi = ctx let now_hi = ctx
.builder .builder
.build_right_shift(now_raw, i64_32, false, "now_lshr") .build_right_shift(now_raw, i64_32, false, "now_lshr");
.into();
ctx.builder.build_or(now_lo, now_hi, "now_or").into() ctx.builder.build_or(now_lo, now_hi, "now_or").into()
} else { } else {
unreachable!(); unreachable!();
@ -33,7 +32,7 @@ impl TimeFns for NowPinningTimeFns {
fn emit_at_mu<'ctx, 'a>(&self, ctx: &mut CodeGenContext<'ctx, 'a>, t: BasicValueEnum<'ctx>) { fn emit_at_mu<'ctx, 'a>(&self, ctx: &mut CodeGenContext<'ctx, 'a>, t: BasicValueEnum<'ctx>) {
let i32_type = ctx.ctx.i32_type(); let i32_type = ctx.ctx.i32_type();
let i64_type = ctx.ctx.i64_type(); let i64_type = ctx.ctx.i64_type();
let i64_32 = i64_type.const_int(32, false).into(); let i64_32 = i64_type.const_int(32, false);
if let BasicValueEnum::IntValue(time) = t { if let BasicValueEnum::IntValue(time) = t {
let time_hi = ctx.builder.build_int_truncate( let time_hi = ctx.builder.build_int_truncate(
ctx.builder ctx.builder
@ -55,7 +54,7 @@ impl TimeFns for NowPinningTimeFns {
let now_loptr = unsafe { let now_loptr = unsafe {
ctx.builder.build_gep( ctx.builder.build_gep(
now_hiptr, now_hiptr,
&[i32_type.const_int(1, false).into()], &[i32_type.const_int(1, false)],
"now_gep", "now_gep",
) )
}; };
@ -78,7 +77,7 @@ impl TimeFns for NowPinningTimeFns {
fn emit_delay_mu<'ctx, 'a>(&self, ctx: &mut CodeGenContext<'ctx, 'a>, dt: BasicValueEnum<'ctx>) { fn emit_delay_mu<'ctx, 'a>(&self, ctx: &mut CodeGenContext<'ctx, 'a>, dt: BasicValueEnum<'ctx>) {
let i32_type = ctx.ctx.i32_type(); let i32_type = ctx.ctx.i32_type();
let i64_type = ctx.ctx.i64_type(); let i64_type = ctx.ctx.i64_type();
let i64_32 = i64_type.const_int(32, false).into(); let i64_32 = i64_type.const_int(32, false);
let now = ctx let now = ctx
.module .module
.get_global("now") .get_global("now")
@ -90,8 +89,7 @@ impl TimeFns for NowPinningTimeFns {
let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now_shl"); let now_lo = ctx.builder.build_left_shift(now_raw, i64_32, "now_shl");
let now_hi = ctx let now_hi = ctx
.builder .builder
.build_right_shift(now_raw, i64_32, false, "now_lshr") .build_right_shift(now_raw, i64_32, false, "now_lshr");
.into();
let now_val = ctx.builder.build_or(now_lo, now_hi, "now_or"); let now_val = ctx.builder.build_or(now_lo, now_hi, "now_or");
let time = ctx.builder.build_int_add(now_val, dt, "now_add"); let time = ctx.builder.build_int_add(now_val, dt, "now_add");
let time_hi = ctx.builder.build_int_truncate( let time_hi = ctx.builder.build_int_truncate(
@ -110,7 +108,7 @@ impl TimeFns for NowPinningTimeFns {
let now_loptr = unsafe { let now_loptr = unsafe {
ctx.builder.build_gep( ctx.builder.build_gep(
now_hiptr, now_hiptr,
&[i32_type.const_int(1, false).into()], &[i32_type.const_int(1, false)],
"now_gep", "now_gep",
) )
}; };

2
nac3ast/src/ast_gen.rs
View File

@ -46,7 +46,7 @@ impl From<&str> for StrRef {
LOCAL_INTERNER.with(|local| { LOCAL_INTERNER.with(|local| {
let mut local = local.borrow_mut(); let mut local = local.borrow_mut();
local.get(s).copied().unwrap_or_else(|| { local.get(s).copied().unwrap_or_else(|| {
let r = get_str_ref(&mut get_str_ref_lock(), &s); let r = get_str_ref(&mut get_str_ref_lock(), s);
local.insert(s.to_string(), r); local.insert(s.to_string(), r);
r r
}) })

16
nac3core/src/toplevel/composer.rs
View File

@ -884,7 +884,7 @@ impl TopLevelComposer {
vec![(*class_def_id, class_type_vars.clone())].into_iter().collect(), vec![(*class_def_id, class_type_vars.clone())].into_iter().collect(),
)?; )?;
if let TypeAnnotation::CustomClassKind { .. } = &base_ty { if let TypeAnnotation::CustomClass { .. } = &base_ty {
class_ancestors.push(base_ty); class_ancestors.push(base_ty);
} else { } else {
return Err("class base declaration can only be custom class".into()); return Err("class base declaration can only be custom class".into());
@ -1096,7 +1096,7 @@ impl TopLevelComposer {
get_type_var_contained_in_type_annotation(&type_annotation) get_type_var_contained_in_type_annotation(&type_annotation)
.into_iter() .into_iter()
.map(|x| -> Result<(u32, Type), String> { .map(|x| -> Result<(u32, Type), String> {
if let TypeAnnotation::TypeVarKind(ty) = x { if let TypeAnnotation::TypeVar(ty) = x {
Ok((Self::get_var_id(ty, unifier)?, ty)) Ok((Self::get_var_id(ty, unifier)?, ty))
} else { } else {
unreachable!("must be type var annotation kind") unreachable!("must be type var annotation kind")
@ -1146,7 +1146,7 @@ impl TopLevelComposer {
get_type_var_contained_in_type_annotation(&return_ty_annotation) get_type_var_contained_in_type_annotation(&return_ty_annotation)
.into_iter() .into_iter()
.map(|x| -> Result<(u32, Type), String> { .map(|x| -> Result<(u32, Type), String> {
if let TypeAnnotation::TypeVarKind(ty) = x { if let TypeAnnotation::TypeVar(ty) = x {
Ok((Self::get_var_id(ty, unifier)?, ty)) Ok((Self::get_var_id(ty, unifier)?, ty))
} else { } else {
unreachable!("must be type var here") unreachable!("must be type var here")
@ -1303,7 +1303,7 @@ impl TopLevelComposer {
get_type_var_contained_in_type_annotation(&type_ann); get_type_var_contained_in_type_annotation(&type_ann);
// handle the class type var and the method type var // handle the class type var and the method type var
for type_var_within in type_vars_within { for type_var_within in type_vars_within {
if let TypeAnnotation::TypeVarKind(ty) = type_var_within { if let TypeAnnotation::TypeVar(ty) = type_var_within {
let id = Self::get_var_id(ty, unifier)?; let id = Self::get_var_id(ty, unifier)?;
if let Some(prev_ty) = method_var_map.insert(id, ty) { if let Some(prev_ty) = method_var_map.insert(id, ty) {
// if already in the list, make sure they are the same? // if already in the list, make sure they are the same?
@ -1346,7 +1346,7 @@ impl TopLevelComposer {
get_type_var_contained_in_type_annotation(&annotation); get_type_var_contained_in_type_annotation(&annotation);
// handle the class type var and the method type var // handle the class type var and the method type var
for type_var_within in type_vars_within { for type_var_within in type_vars_within {
if let TypeAnnotation::TypeVarKind(ty) = type_var_within { if let TypeAnnotation::TypeVar(ty) = type_var_within {
let id = Self::get_var_id(ty, unifier)?; let id = Self::get_var_id(ty, unifier)?;
if let Some(prev_ty) = method_var_map.insert(id, ty) { if let Some(prev_ty) = method_var_map.insert(id, ty) {
// if already in the list, make sure they are the same? // if already in the list, make sure they are the same?
@ -1365,7 +1365,7 @@ impl TopLevelComposer {
let dummy_return_type = unifier.get_fresh_var().0; let dummy_return_type = unifier.get_fresh_var().0;
type_var_to_concrete_def.insert( type_var_to_concrete_def.insert(
dummy_return_type, dummy_return_type,
TypeAnnotation::PrimitiveKind(primitives.none), TypeAnnotation::Primitive(primitives.none),
); );
dummy_return_type dummy_return_type
} }
@ -1423,7 +1423,7 @@ impl TopLevelComposer {
get_type_var_contained_in_type_annotation(&annotation); get_type_var_contained_in_type_annotation(&annotation);
// handle the class type var and the method type var // handle the class type var and the method type var
for type_var_within in type_vars_within { for type_var_within in type_vars_within {
if let TypeAnnotation::TypeVarKind(t) = type_var_within { if let TypeAnnotation::TypeVar(t) = type_var_within {
if !class_type_vars_def.contains(&t) { if !class_type_vars_def.contains(&t) {
return Err("class fields can only use type \ return Err("class fields can only use type \
vars declared as class generic type vars" vars declared as class generic type vars"
@ -1481,7 +1481,7 @@ impl TopLevelComposer {
// since when this function is called, the ancestors of the direct parent // since when this function is called, the ancestors of the direct parent
// are supposed to be already handled, so we only need to deal with the direct parent // are supposed to be already handled, so we only need to deal with the direct parent
let base = class_ancestor_def.get(1).unwrap(); let base = class_ancestor_def.get(1).unwrap();
if let TypeAnnotation::CustomClassKind { id, params: _ } = base { if let TypeAnnotation::CustomClass { id, params: _ } = base {
let base = temp_def_list.get(id.0).unwrap(); let base = temp_def_list.get(id.0).unwrap();
let base = base.read(); let base = base.read();
if let TopLevelDef::Class { methods, fields, .. } = &*base { if let TopLevelDef::Class { methods, fields, .. } = &*base {

6
nac3core/src/toplevel/helper.rs
View File

@ -160,14 +160,14 @@ impl TopLevelComposer {
let mut parent = Self::get_parent(child, temp_def_list); let mut parent = Self::get_parent(child, temp_def_list);
while let Some(p) = parent { while let Some(p) = parent {
parent = Self::get_parent(&p, temp_def_list); parent = Self::get_parent(&p, temp_def_list);
let p_id = if let TypeAnnotation::CustomClassKind { id, .. } = &p { let p_id = if let TypeAnnotation::CustomClass { id, .. } = &p {
*id *id
} else { } else {
unreachable!("must be class kind annotation") unreachable!("must be class kind annotation")
}; };
// check cycle // check cycle
let no_cycle = result.iter().all(|x| { let no_cycle = result.iter().all(|x| {
if let TypeAnnotation::CustomClassKind { id, .. } = x { if let TypeAnnotation::CustomClass { id, .. } = x {
id.0 != p_id.0 id.0 != p_id.0
} else { } else {
unreachable!("must be class kind annotation") unreachable!("must be class kind annotation")
@ -187,7 +187,7 @@ impl TopLevelComposer {
child: &TypeAnnotation, child: &TypeAnnotation,
temp_def_list: &[Arc<RwLock<TopLevelDef>>], temp_def_list: &[Arc<RwLock<TopLevelDef>>],
) -> Option<TypeAnnotation> { ) -> Option<TypeAnnotation> {
let child_id = if let TypeAnnotation::CustomClassKind { id, .. } = child { let child_id = if let TypeAnnotation::CustomClass { id, .. } = child {
*id *id
} else { } else {
unreachable!("should be class type annotation") unreachable!("should be class type annotation")

86
nac3core/src/toplevel/type_annotation.rs
View File

@ -6,26 +6,26 @@ use super::*;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub enum TypeAnnotation { pub enum TypeAnnotation {
PrimitiveKind(Type), Primitive(Type),
// we use type vars kind at params to represent self type // we use type vars kind at params to represent self type
CustomClassKind { CustomClass {
id: DefinitionId, id: DefinitionId,
// params can also be type var // params can also be type var
params: Vec<TypeAnnotation>, params: Vec<TypeAnnotation>,
}, },
// can only be CustomClassKind // can only be CustomClassKind
VirtualKind(Box<TypeAnnotation>), Virtual(Box<TypeAnnotation>),
TypeVarKind(Type), TypeVar(Type),
ListKind(Box<TypeAnnotation>), List(Box<TypeAnnotation>),
TupleKind(Vec<TypeAnnotation>), Tuple(Vec<TypeAnnotation>),
} }
impl TypeAnnotation { impl TypeAnnotation {
pub fn stringify(&self, unifier: &mut Unifier) -> String { pub fn stringify(&self, unifier: &mut Unifier) -> String {
use TypeAnnotation::*; use TypeAnnotation::*;
match self { match self {
PrimitiveKind(ty) | TypeVarKind(ty) => unifier.default_stringify(*ty), Primitive(ty) | TypeVar(ty) => unifier.default_stringify(*ty),
CustomClassKind { id, params } => { CustomClass { id, params } => {
let class_name = match unifier.top_level { let class_name = match unifier.top_level {
Some(ref top) => if let TopLevelDef::Class { name, .. } = &*top.definitions.read()[id.0].read() { Some(ref top) => if let TopLevelDef::Class { name, .. } = &*top.definitions.read()[id.0].read() {
(*name).into() (*name).into()
@ -36,8 +36,8 @@ impl TypeAnnotation {
}; };
format!("{{class: {}, params: {:?}}}", class_name, params.iter().map(|p| p.stringify(unifier)).collect_vec()) format!("{{class: {}, params: {:?}}}", class_name, params.iter().map(|p| p.stringify(unifier)).collect_vec())
} }
VirtualKind(ty) | ListKind(ty) => ty.stringify(unifier), Virtual(ty) | List(ty) => ty.stringify(unifier),
TupleKind(types) => format!("({:?})", types.iter().map(|p| p.stringify(unifier)).collect_vec()), Tuple(types) => format!("({:?})", types.iter().map(|p| p.stringify(unifier)).collect_vec()),
} }
} }
} }
@ -54,17 +54,17 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
match &expr.node { match &expr.node {
ast::ExprKind::Name { id, .. } => { ast::ExprKind::Name { id, .. } => {
if id == &"int32".into() { if id == &"int32".into() {
Ok(TypeAnnotation::PrimitiveKind(primitives.int32)) Ok(TypeAnnotation::Primitive(primitives.int32))
} else if id == &"int64".into() { } else if id == &"int64".into() {
Ok(TypeAnnotation::PrimitiveKind(primitives.int64)) Ok(TypeAnnotation::Primitive(primitives.int64))
} else if id == &"float".into() { } else if id == &"float".into() {
Ok(TypeAnnotation::PrimitiveKind(primitives.float)) Ok(TypeAnnotation::Primitive(primitives.float))
} else if id == &"bool".into() { } else if id == &"bool".into() {
Ok(TypeAnnotation::PrimitiveKind(primitives.bool)) Ok(TypeAnnotation::Primitive(primitives.bool))
} else if id == &"None".into() { } else if id == &"None".into() {
Ok(TypeAnnotation::PrimitiveKind(primitives.none)) Ok(TypeAnnotation::Primitive(primitives.none))
} else if id == &"str".into() { } else if id == &"str".into() {
Ok(TypeAnnotation::PrimitiveKind(primitives.str)) Ok(TypeAnnotation::Primitive(primitives.str))
} else if let Some(obj_id) = resolver.get_identifier_def(*id) { } else if let Some(obj_id) = resolver.get_identifier_def(*id) {
let type_vars = { let type_vars = {
let def_read = top_level_defs[obj_id.0].try_read(); let def_read = top_level_defs[obj_id.0].try_read();
@ -85,10 +85,10 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
type_vars.len() type_vars.len()
)); ));
} }
Ok(TypeAnnotation::CustomClassKind { id: obj_id, params: vec![] }) Ok(TypeAnnotation::CustomClass { id: obj_id, params: vec![] })
} else if let Some(ty) = resolver.get_symbol_type(unifier, top_level_defs, primitives, *id) { } else if let Some(ty) = resolver.get_symbol_type(unifier, top_level_defs, primitives, *id) {
if let TypeEnum::TVar { .. } = unifier.get_ty(ty).as_ref() { if let TypeEnum::TVar { .. } = unifier.get_ty(ty).as_ref() {
Ok(TypeAnnotation::TypeVarKind(ty)) Ok(TypeAnnotation::TypeVar(ty))
} else { } else {
Err("not a type variable identifier".into()) Err("not a type variable identifier".into())
} }
@ -111,10 +111,10 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
slice.as_ref(), slice.as_ref(),
locked, locked,
)?; )?;
if !matches!(def, TypeAnnotation::CustomClassKind { .. }) { if !matches!(def, TypeAnnotation::CustomClass { .. }) {
unreachable!("must be concretized custom class kind in the virtual") unreachable!("must be concretized custom class kind in the virtual")
} }
Ok(TypeAnnotation::VirtualKind(def.into())) Ok(TypeAnnotation::Virtual(def.into()))
} }
// list // list
@ -131,7 +131,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
slice.as_ref(), slice.as_ref(),
locked, locked,
)?; )?;
Ok(TypeAnnotation::ListKind(def_ann.into())) Ok(TypeAnnotation::List(def_ann.into()))
} }
// tuple // tuple
@ -154,7 +154,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
) )
}) })
.collect::<Result<Vec<_>, _>>()?; .collect::<Result<Vec<_>, _>>()?;
Ok(TypeAnnotation::TupleKind(type_annotations)) Ok(TypeAnnotation::Tuple(type_annotations))
} else { } else {
Err("Expect multiple elements for tuple".into()) Err("Expect multiple elements for tuple".into())
} }
@ -227,7 +227,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
} }
}; };
Ok(TypeAnnotation::CustomClassKind { id: obj_id, params: param_type_infos }) Ok(TypeAnnotation::CustomClass { id: obj_id, params: param_type_infos })
} else { } else {
Err("unsupported expression type for class name".into()) Err("unsupported expression type for class name".into())
} }
@ -247,7 +247,7 @@ pub fn get_type_from_type_annotation_kinds(
ann: &TypeAnnotation, ann: &TypeAnnotation,
) -> Result<Type, String> { ) -> Result<Type, String> {
match ann { match ann {
TypeAnnotation::CustomClassKind { id: obj_id, params } => { TypeAnnotation::CustomClass { id: obj_id, params } => {
let def_read = top_level_defs[obj_id.0].read(); let def_read = top_level_defs[obj_id.0].read();
let class_def: &TopLevelDef = def_read.deref(); let class_def: &TopLevelDef = def_read.deref();
if let TopLevelDef::Class { fields, methods, type_vars, .. } = class_def { if let TopLevelDef::Class { fields, methods, type_vars, .. } = class_def {
@ -326,8 +326,8 @@ pub fn get_type_from_type_annotation_kinds(
unreachable!("should be class def here") unreachable!("should be class def here")
} }
} }
TypeAnnotation::PrimitiveKind(ty) | TypeAnnotation::TypeVarKind(ty) => Ok(*ty), TypeAnnotation::Primitive(ty) | TypeAnnotation::TypeVar(ty) => Ok(*ty),
TypeAnnotation::VirtualKind(ty) => { TypeAnnotation::Virtual(ty) => {
let ty = get_type_from_type_annotation_kinds( let ty = get_type_from_type_annotation_kinds(
top_level_defs, top_level_defs,
unifier, unifier,
@ -336,7 +336,7 @@ pub fn get_type_from_type_annotation_kinds(
)?; )?;
Ok(unifier.add_ty(TypeEnum::TVirtual { ty })) Ok(unifier.add_ty(TypeEnum::TVirtual { ty }))
} }
TypeAnnotation::ListKind(ty) => { TypeAnnotation::List(ty) => {
let ty = get_type_from_type_annotation_kinds( let ty = get_type_from_type_annotation_kinds(
top_level_defs, top_level_defs,
unifier, unifier,
@ -345,7 +345,7 @@ pub fn get_type_from_type_annotation_kinds(
)?; )?;
Ok(unifier.add_ty(TypeEnum::TList { ty })) Ok(unifier.add_ty(TypeEnum::TList { ty }))
} }
TypeAnnotation::TupleKind(tys) => { TypeAnnotation::Tuple(tys) => {
let tys = tys let tys = tys
.iter() .iter()
.map(|x| { .map(|x| {
@ -376,9 +376,9 @@ pub fn get_type_from_type_annotation_kinds(
/// create copies of `T` and `V`, we will find them out as occured type vars in the analyze_class() /// create copies of `T` and `V`, we will find them out as occured type vars in the analyze_class()
/// and unify them with the class generic `T`, `V` /// and unify them with the class generic `T`, `V`
pub fn make_self_type_annotation(type_vars: &[Type], object_id: DefinitionId) -> TypeAnnotation { pub fn make_self_type_annotation(type_vars: &[Type], object_id: DefinitionId) -> TypeAnnotation {
TypeAnnotation::CustomClassKind { TypeAnnotation::CustomClass {
id: object_id, id: object_id,
params: type_vars.iter().map(|ty| TypeAnnotation::TypeVarKind(*ty)).collect_vec(), params: type_vars.iter().map(|ty| TypeAnnotation::TypeVar(*ty)).collect_vec(),
} }
} }
@ -388,24 +388,24 @@ pub fn make_self_type_annotation(type_vars: &[Type], object_id: DefinitionId) ->
pub fn get_type_var_contained_in_type_annotation(ann: &TypeAnnotation) -> Vec<TypeAnnotation> { pub fn get_type_var_contained_in_type_annotation(ann: &TypeAnnotation) -> Vec<TypeAnnotation> {
let mut result: Vec<TypeAnnotation> = Vec::new(); let mut result: Vec<TypeAnnotation> = Vec::new();
match ann { match ann {
TypeAnnotation::TypeVarKind(..) => result.push(ann.clone()), TypeAnnotation::TypeVar(..) => result.push(ann.clone()),
TypeAnnotation::VirtualKind(ann) => { TypeAnnotation::Virtual(ann) => {
result.extend(get_type_var_contained_in_type_annotation(ann.as_ref())) result.extend(get_type_var_contained_in_type_annotation(ann.as_ref()))
} }
TypeAnnotation::CustomClassKind { params, .. } => { TypeAnnotation::CustomClass { params, .. } => {
for p in params { for p in params {
result.extend(get_type_var_contained_in_type_annotation(p)); result.extend(get_type_var_contained_in_type_annotation(p));
} }
} }
TypeAnnotation::ListKind(ann) => { TypeAnnotation::List(ann) => {
result.extend(get_type_var_contained_in_type_annotation(ann.as_ref())) result.extend(get_type_var_contained_in_type_annotation(ann.as_ref()))
} }
TypeAnnotation::TupleKind(anns) => { TypeAnnotation::Tuple(anns) => {
for a in anns { for a in anns {
result.extend(get_type_var_contained_in_type_annotation(a)); result.extend(get_type_var_contained_in_type_annotation(a));
} }
} }
TypeAnnotation::PrimitiveKind(..) => {} TypeAnnotation::Primitive(..) => {}
} }
result result
} }
@ -417,8 +417,8 @@ pub fn check_overload_type_annotation_compatible(
unifier: &mut Unifier, unifier: &mut Unifier,
) -> bool { ) -> bool {
match (this, other) { match (this, other) {
(TypeAnnotation::PrimitiveKind(a), TypeAnnotation::PrimitiveKind(b)) => a == b, (TypeAnnotation::Primitive(a), TypeAnnotation::Primitive(b)) => a == b,
(TypeAnnotation::TypeVarKind(a), TypeAnnotation::TypeVarKind(b)) => { (TypeAnnotation::TypeVar(a), TypeAnnotation::TypeVar(b)) => {
let a = unifier.get_ty(*a); let a = unifier.get_ty(*a);
let a = a.deref(); let a = a.deref();
let b = unifier.get_ty(*b); let b = unifier.get_ty(*b);
@ -433,12 +433,12 @@ pub fn check_overload_type_annotation_compatible(
unreachable!("must be type var") unreachable!("must be type var")
} }
} }
(TypeAnnotation::VirtualKind(a), TypeAnnotation::VirtualKind(b)) (TypeAnnotation::Virtual(a), TypeAnnotation::Virtual(b))
| (TypeAnnotation::ListKind(a), TypeAnnotation::ListKind(b)) => { | (TypeAnnotation::List(a), TypeAnnotation::List(b)) => {
check_overload_type_annotation_compatible(a.as_ref(), b.as_ref(), unifier) check_overload_type_annotation_compatible(a.as_ref(), b.as_ref(), unifier)
} }
(TypeAnnotation::TupleKind(a), TypeAnnotation::TupleKind(b)) => { (TypeAnnotation::Tuple(a), TypeAnnotation::Tuple(b)) => {
a.len() == b.len() && { a.len() == b.len() && {
a.iter() a.iter()
.zip(b) .zip(b)
@ -447,8 +447,8 @@ pub fn check_overload_type_annotation_compatible(
} }
( (
TypeAnnotation::CustomClassKind { id: a, params: a_p }, TypeAnnotation::CustomClass { id: a, params: a_p },
TypeAnnotation::CustomClassKind { id: b, params: b_p }, TypeAnnotation::CustomClass { id: b, params: b_p },
) => { ) => {
a.0 == b.0 && { a.0 == b.0 && {
a_p.len() == b_p.len() && { a_p.len() == b_p.len() && {