feat(mir): add Path expression kind

Author: andogq

src/ir/hir.rs

@@ -183,6 +183,7 @@ mod expression {
         Unreachable,
         Aggregate(Aggregate),
         Field(Field),
+        Path(Path),
     }
 
     #[derive(Clone, Debug)]
@@ -247,6 +248,18 @@ mod expression {
         pub field: usize,
     }
 
+    /// A qualified path to a trait with an item.
+    ///
+    /// ```
+    /// <Ty as TargetTrait>::item
+    /// ```
+    #[derive(Clone, Debug)]
+    pub struct Path {
+        pub ty: TypeId,
+        pub target_trait: TraitId,
+        pub item: TraitMethodId,
+    }
+
     enum_conversion! {
         [Expression]
         Assign: Assign,
@@ -260,6 +273,7 @@ mod expression {
         Variable: Variable,
         Aggregate: Aggregate,
         Field: Field,
+        Path: Path,
     }
 }
 

src/passes/hir_gen.rs

@@ -435,8 +435,34 @@ impl<'ctx, 'ast> HirGen<'ctx, 'ast> {
                 },
             }
             .into(),
-            ast::Expression::QualifiedPath(ast::QualifiedPath { .. }) => {
-                todo!()
+            ast::Expression::QualifiedPath(ast::QualifiedPath { ty, name, item }) => {
+                let trait_name = self.ctx.scopes.resolve_global(*name);
+                let (trait_id, target_trait) = self
+                    .hir
+                    .traits
+                    .iter_pairs()
+                    .find(|&(_, t)| t.name == trait_name)
+                    .expect("trait must exist");
+                let item_binding = self.ctx.scopes.resolve(target_trait.method_scope, *item);
+                let item = *target_trait
+                    .method_bindings
+                    .get(&item_binding)
+                    .expect("valid method on trait");
+
+                Path {
+                    ty: {
+                        let ty = self.lower_ast_type(*ty);
+                        match ctx.current_self() {
+                            Some(current_self) => ty.with_self(current_self),
+                            None => ty
+                                .without_self()
+                                .expect("`Self` cannot be used in this context"),
+                        }
+                    },
+                    target_trait: trait_id,
+                    item,
+                }
+                .into()
             }
         };
 

src/passes/mir_gen.rs

@@ -1,4 +1,4 @@
-use crate::prelude::*;
+use crate::{ir::hir::TraitImplementationKey, prelude::*};
 
 use mir::{UnaryOperation, *};
 use thir::Thir;
@@ -596,6 +596,34 @@ impl<'ctx, 'hir, 'thir> MirGen<'ctx, 'hir, 'thir> {
                 let place = self.mir.places.insert(lhs);
                 Some(self.mir.operands.insert(Operand::Place(place)))
             }
+            hir::Expression::Path(hir::Path {
+                ty,
+                target_trait,
+                item,
+            }) => {
+                // Look up the trait implementation.
+                let trait_implementation = &self.thir[&TraitImplementationKey {
+                    trait_id: *target_trait,
+                    ty: *ty,
+                }];
+
+                // Look up the function ID corresponding with the method ID.
+                let thir_function_id = trait_implementation.methods[*item];
+
+                // Map from THIR function to MIR function.
+                let (function_id, _) = self
+                    .function_ids
+                    .iter_pairs()
+                    .find(|(_, id)| **id == thir_function_id)
+                    .expect("function to exist");
+
+                // Insert constant resolving to the function.
+                Some(
+                    self.mir
+                        .operands
+                        .insert(Operand::Constant(Constant::Function(function_id))),
+                )
+            }
         }
     }