frontend: Preparing for using Assoc type

dora-boots/bytecode/opcode.dora

@@ -81,6 +81,7 @@ pub const BC_TYPE_CLASS: Int32 = 13;
 pub const BC_TYPE_TRAIT_OBJECT: Int32 = 14;
 pub const BC_TYPE_LAMBDA: Int32 = 15;
 pub const BC_TYPE_TYPE_ALIAS: Int32 = 16;
+pub const BC_TYPE_ASSOC: Int32 = 17;
 
 pub const CONSTPOOL_OPCODE_STRING: Int32 = 0;
 pub const CONSTPOOL_OPCODE_FLOAT32: Int32 = 1;
@@ -341,6 +342,7 @@ pub fn bytecodeTypeName(code: Int32): String {
   if code == BC_TYPE_TRAIT_OBJECT { return "TraitObject"; }
   if code == BC_TYPE_LAMBDA { return "Lambda"; }
   if code == BC_TYPE_TYPE_ALIAS { return "TypeAlias"; }
+  if code == BC_TYPE_ASSOC { return "Assoc"; }
   unreachable[String]()
 }
 

dora-bytecode/src/data.rs

@@ -40,6 +40,7 @@ pub enum BytecodeTypeKind {
     TraitObject,
     Lambda,
     TypeAlias,
+    Assoc,
 }
 
 #[derive(IntoPrimitive, TryFromPrimitive, Copy, Clone, PartialEq, Eq)]

dora-bytecode/src/dumper.rs

@@ -310,7 +310,7 @@ impl<'a> Display for BytecodeTypePrinter<'a> {
                     fmt_ty(self.prog, return_ty)
                 )
             }
-            BytecodeType::TypeAlias(alias_id) => {
+            BytecodeType::TypeAlias(alias_id) | BytecodeType::Assoc(alias_id, ..) => {
                 let alias = &self.prog.aliases[alias_id.0 as usize];
                 write!(f, "{}", alias.name)?;
                 if let Some(ref ty) = alias.ty {

dora-bytecode/src/ty.rs

@@ -24,6 +24,7 @@ pub enum BytecodeType {
     TraitObject(TraitId, BytecodeTypeArray),
     Lambda(BytecodeTypeArray, Box<BytecodeType>),
     TypeAlias(AliasId),
+    Assoc(AliasId, BytecodeTypeArray),
 }
 
 impl BytecodeType {
@@ -46,6 +47,7 @@ impl BytecodeType {
             BytecodeType::TraitObject(..) => BytecodeTypeKind::TraitObject,
             BytecodeType::Lambda(..) => BytecodeTypeKind::Lambda,
             BytecodeType::TypeAlias(..) => BytecodeTypeKind::TypeAlias,
+            BytecodeType::Assoc(..) => BytecodeTypeKind::Assoc,
             BytecodeType::This => unreachable!(),
         }
     }
@@ -170,7 +172,9 @@ impl BytecodeType {
                 return_type.is_concrete_type()
             }
             BytecodeType::TypeParam(_) => false,
-            BytecodeType::TypeAlias(..) | BytecodeType::This => unreachable!(),
+            BytecodeType::TypeAlias(..) | BytecodeType::Assoc(..) | BytecodeType::This => {
+                unreachable!()
+            }
         }
     }
 

dora-frontend/src/aliasck.rs

@@ -109,7 +109,7 @@ fn expand_type(
             SourceType::Tuple(expand_sta(sa, subtypes, visited, visiting, context))
         }
 
-        SourceType::Alias(id, _type_params) => {
+        SourceType::Alias(id, _type_params) | SourceType::Assoc(id, _type_params) => {
             let alias = sa.alias(*id);
             let found_cycle = detect_cycles_for_alias(sa, visited, visiting, context, alias);
 
@@ -132,7 +132,7 @@ fn expand_type(
         | SourceType::This
         | SourceType::TypeParam(..) => ty,
 
-        SourceType::Assoc(..) | SourceType::Any | SourceType::Ptr => {
+        SourceType::GenericAssoc(..) | SourceType::Any | SourceType::Ptr => {
             panic!("unexpected type = {:?}", ty);
         }
     }

dora-frontend/src/extensiondefck.rs

@@ -77,7 +77,7 @@ pub fn package_for_type(sa: &Sema, ty: SourceType) -> Option<PackageDefinitionId
         SourceType::Enum(id, ..) => Some(sa.enum_(id).package_id),
         SourceType::TraitObject(id, ..) => Some(sa.trait_(id).package_id),
         SourceType::Alias(id, ..) => Some(sa.alias(id).package_id),
-        SourceType::Assoc(..) => unimplemented!(),
+        SourceType::Assoc(..) | SourceType::GenericAssoc(..) => unimplemented!(),
     }
 }
 
@@ -101,7 +101,11 @@ impl<'x> ExtensionCheck<'x> {
                 );
             }
             SourceType::Alias(..) => unimplemented!(),
-            SourceType::Any | SourceType::Ptr | SourceType::This | SourceType::Assoc(..) => {
+            SourceType::Any
+            | SourceType::Ptr
+            | SourceType::This
+            | SourceType::Assoc(..)
+            | SourceType::GenericAssoc(..) => {
                 unreachable!()
             }
             SourceType::Error
@@ -238,7 +242,9 @@ fn discover_type_params(sa: &Sema, ty: SourceType, used_type_params: &mut FixedB
         SourceType::TypeParam(tp_id) => {
             used_type_params.insert(tp_id.index());
         }
-        SourceType::Alias(..) | SourceType::Assoc(..) => unreachable!(),
+        SourceType::Alias(..) | SourceType::Assoc(..) | SourceType::GenericAssoc(..) => {
+            unreachable!()
+        }
     }
 }
 

dora-frontend/src/generator.rs

@@ -3246,6 +3246,13 @@ pub fn bty_from_ty(ty: SourceType) -> BytecodeType {
             assert!(type_params.is_empty());
             BytecodeType::TypeAlias(AliasId(id.index().try_into().expect("overflow")))
         }
+        SourceType::Assoc(id, type_params) => {
+            assert!(type_params.is_empty());
+            BytecodeType::Assoc(
+                AliasId(id.index().try_into().expect("overflow")),
+                bty_array_from_ty(&type_params),
+            )
+        }
         _ => panic!("SourceType {:?} cannot be converted to BytecodeType", ty),
     }
 }

dora-frontend/src/impldefck.rs

@@ -16,7 +16,11 @@ pub fn check_definition(sa: &Sema) {
 fn check_impl_definition(sa: &Sema, impl_: &ImplDefinition) {
     match impl_.extended_ty() {
         SourceType::Alias(..) => unimplemented!(),
-        SourceType::Any | SourceType::Ptr | SourceType::This | SourceType::Assoc(..) => {
+        SourceType::Any
+        | SourceType::Ptr
+        | SourceType::This
+        | SourceType::Assoc(..)
+        | SourceType::GenericAssoc(..) => {
             unreachable!()
         }
         SourceType::Error
@@ -312,6 +316,12 @@ fn trait_and_impl_arg_ty_compatible(
             ty == &impl_arg_ty
         }
 
+        SourceType::Assoc(id, type_params) => {
+            assert!(type_params.is_empty());
+            let ty = trait_alias_map.get(&id).expect("missing alias");
+            ty == &impl_arg_ty
+        }
+
         SourceType::TypeParam(id) => trait_type_params[id.index()] == impl_arg_ty,
 
         SourceType::This => self_ty == impl_arg_ty,
@@ -326,7 +336,7 @@ fn trait_and_impl_arg_ty_compatible(
         | SourceType::Float64
         | SourceType::Error => trait_arg_ty == impl_arg_ty,
 
-        SourceType::Any | SourceType::Ptr | SourceType::Assoc(..) => unreachable!(),
+        SourceType::Any | SourceType::Ptr | SourceType::GenericAssoc(..) => unreachable!(),
     }
 }
 

dora-frontend/src/parsety.rs

@@ -520,7 +520,15 @@ fn ty_for_sym(sa: &Sema, sym: SymbolKind, type_params: SourceTypeArray) -> Sourc
             }
         }
         SymbolKind::Enum(id) => SourceType::Enum(id, type_params),
-        SymbolKind::Alias(id) => SourceType::Alias(id, type_params),
+        SymbolKind::Alias(id) => {
+            let alias = sa.alias(id);
+
+            if alias.parent.is_none() {
+                SourceType::Alias(id, type_params)
+            } else {
+                SourceType::Alias(id, type_params)
+            }
+        }
         _ => unimplemented!(),
     }
 }
@@ -661,7 +669,7 @@ fn check_type_inner(
     parsed_ty: &ParsedTypeAst,
 ) -> SourceType {
     match ty.clone() {
-        SourceType::Any | SourceType::Ptr | SourceType::Assoc(..) => {
+        SourceType::Any | SourceType::Ptr | SourceType::GenericAssoc(..) => {
             unreachable!()
         }
         SourceType::This => SourceType::This,
@@ -737,6 +745,49 @@ fn check_type_inner(
         | SourceType::Enum(_, type_params) => {
             check_type_record(sa, element, ctxt, parsed_ty, type_params)
         }
+        SourceType::Assoc(id, type_params) => {
+            let alias = sa.alias(id);
+            assert!(alias.parent.is_impl() || alias.parent.is_trait());
+
+            let parsed_type_params = match parsed_ty.kind {
+                ParsedTypeKind::Regular {
+                    type_arguments: ref type_params,
+                    ..
+                } => type_params,
+                _ => unreachable!(),
+            };
+
+            assert_eq!(type_params.len(), parsed_type_params.len());
+            let mut new_type_params = Vec::with_capacity(parsed_type_params.len());
+
+            for idx in 0..type_params.len() {
+                let parsed_type_arg = &parsed_type_params[idx];
+                assert!(parsed_type_arg.name.is_none());
+                let ty = check_type_inner(
+                    sa,
+                    element,
+                    ctxt,
+                    type_params[idx].clone(),
+                    &parsed_type_arg.ty,
+                );
+                new_type_params.push(ty);
+            }
+
+            let new_type_params: SourceTypeArray = new_type_params.into();
+
+            if check_type_params(
+                sa,
+                alias.type_param_definition(),
+                new_type_params.types(),
+                ctxt.file_id,
+                parsed_ty.span,
+                ctxt.type_param_definition,
+            ) {
+                SourceType::Assoc(id, new_type_params)
+            } else {
+                SourceType::Error
+            }
+        }
         SourceType::TraitObject(trait_id, type_params, bindings) => check_type_trait_object(
             sa,
             element,
@@ -1160,6 +1211,36 @@ fn expand_st(
             }
         }
 
+        SourceType::Assoc(id, type_params) => {
+            let alias = sa.alias(*id);
+
+            match alias.parent {
+                AliasParent::Trait(trait_id) => {
+                    let element = parent_element_or_self(sa, element);
+                    if let Some(impl_) = element.to_impl() {
+                        let impl_alias_id = impl_.trait_alias_map().get(&id).cloned();
+                        if let Some(impl_alias_id) = impl_alias_id {
+                            let impl_alias = sa.alias(impl_alias_id);
+                            impl_alias.ty()
+                        } else {
+                            SourceType::Error
+                        }
+                    } else if let Some(trait_) = element.to_trait() {
+                        assert_eq!(trait_id, trait_.id());
+                        ty
+                    } else {
+                        ty
+                    }
+                }
+
+                AliasParent::Impl(..) => unreachable!(),
+                AliasParent::None => {
+                    let alias_ty = replace_type(sa, alias.ty(), Some(type_params), None);
+                    expand_st(sa, element, alias_ty, replace_self)
+                }
+            }
+        }
+
         SourceType::Unit
         | SourceType::UInt8
         | SourceType::Bool
@@ -1172,7 +1253,7 @@ fn expand_st(
         | SourceType::TypeParam(..) => ty,
         SourceType::This => replace_self.expect("self expected"),
 
-        SourceType::Any | SourceType::Ptr | SourceType::Assoc(..) => {
+        SourceType::Any | SourceType::Ptr | SourceType::GenericAssoc(..) => {
             panic!("unexpected type = {:?}", ty);
             // unreachable!()
         }

dora-frontend/src/sema/aliases.rs

@@ -38,6 +38,13 @@ impl AliasParent {
             _ => false,
         }
     }
+
+    pub fn is_none(&self) -> bool {
+        match self {
+            AliasParent::None => true,
+            _ => false,
+        }
+    }
 }
 
 pub struct AliasDefinition {

dora-frontend/src/sema/impl_matching.rs

@@ -61,7 +61,9 @@ pub fn implements_trait(
 
         SourceType::TypeParam(tp_id) => check_type_param_defs.implements_trait(tp_id, trait_ty),
 
-        SourceType::Alias(..) | SourceType::Assoc(..) => unreachable!(),
+        SourceType::Alias(..) | SourceType::Assoc(..) | SourceType::GenericAssoc(..) => {
+            unreachable!()
+        }
 
         SourceType::Error => false,
 
@@ -70,13 +72,17 @@ pub fn implements_trait(
 }
 
 pub fn maybe_alias_ty(sa: &Sema, mut ty: SourceType) -> SourceType {
-    while let SourceType::Alias(id, type_params) = ty {
-        assert!(type_params.is_empty());
-        let alias = sa.alias(id);
-        ty = alias.ty();
-    }
+    loop {
+        match ty {
+            SourceType::Alias(id, type_params) => {
+                assert!(type_params.is_empty());
+                let alias = sa.alias(id);
+                ty = alias.ty();
+            }
 
-    ty
+            _ => return ty,
+        }
+    }
 }
 
 pub struct ImplMatch {

dora-frontend/src/sema/matching.rs

@@ -223,7 +223,7 @@ fn match_concrete_types(
             _ => false,
         },
 
-        SourceType::Alias(..) | SourceType::Assoc(..) => {
+        SourceType::Alias(..) | SourceType::Assoc(..) | SourceType::GenericAssoc(..) => {
             unimplemented!()
         }
 

dora-frontend/src/specialize.rs

@@ -51,6 +51,11 @@ pub fn replace_type(
             replace_sta(sa, alias_type_params, type_params, self_ty),
         ),
 
+        SourceType::Assoc(alias_id, alias_type_params) => SourceType::Assoc(
+            alias_id,
+            replace_sta(sa, alias_type_params, type_params, self_ty),
+        ),
+
         SourceType::Lambda(params, return_type) => SourceType::Lambda(
             replace_sta(sa, params, type_params, self_ty.clone()),
             Box::new(replace_type(sa, *return_type, type_params, self_ty)),
@@ -86,7 +91,7 @@ pub fn replace_type(
         | SourceType::Float64
         | SourceType::Error => ty,
 
-        SourceType::Any | SourceType::Ptr | SourceType::Assoc(..) => unreachable!(),
+        SourceType::Any | SourceType::Ptr | SourceType::GenericAssoc(..) => unreachable!(),
     }
 }
 
@@ -170,7 +175,10 @@ pub fn specialize_for_element(
         | SourceType::Float64
         | SourceType::Error => ty,
 
-        SourceType::Any | SourceType::Ptr | SourceType::Assoc(..) => unreachable!(),
+        SourceType::Any
+        | SourceType::Ptr
+        | SourceType::Assoc(..)
+        | SourceType::GenericAssoc(..) => unreachable!(),
     }
 }
 
@@ -253,7 +261,10 @@ pub fn specialize_for_trait_object(sa: &Sema, ty: SourceType, trait_ty: SourceTy
         | SourceType::Float64
         | SourceType::Error => ty,
 
-        SourceType::Any | SourceType::Ptr | SourceType::Assoc(..) => unreachable!(),
+        SourceType::Any
+        | SourceType::Ptr
+        | SourceType::Assoc(..)
+        | SourceType::GenericAssoc(..) => unreachable!(),
     }
 }