frontend: Initial implementation of TraitObjectIgnore

dora-bytecode/src/program.rs

@@ -41,6 +41,7 @@ pub struct FunctionData {
     pub is_variadic: bool,
     pub is_force_inline: bool,
     pub is_never_inline: bool,
+    pub is_trait_object_ignore: bool,
     pub bytecode: Option<BytecodeFunction>,
     pub trait_method_impl: Option<FunctionId>,
 }

dora-frontend/src/parsety.rs

@@ -3,7 +3,7 @@ use std::collections::{HashMap, HashSet};
 
 use crate::access::{sym_accessible_from, trait_accessible_from};
 use crate::sema::{
-    implements_trait, is_object_safe, parent_element_or_self, AliasDefinitionId, Element,
+    implements_trait, is_trait_object_safe, parent_element_or_self, AliasDefinitionId, Element,
     SourceFileId, TraitDefinition, TraitDefinitionId, TypeParamDefinition,
 };
 use crate::sym::{ModuleSymTable, SymbolKind};
@@ -867,7 +867,7 @@ fn check_type_trait_object(
         sa.report(ctxt_element.file_id(), parsed_ty.span, msg);
     }
 
-    if !is_object_safe(sa, trait_id) {
+    if !is_trait_object_safe(sa, trait_id) {
         sa.report(
             ctxt_element.file_id(),
             parsed_ty.span,

dora-frontend/src/program_emitter.rs

@@ -211,6 +211,7 @@ fn create_functions(sa: &Sema, e: &mut Emitter) -> Vec<FunctionData> {
             is_variadic: fct.params.is_variadic(),
             is_force_inline: fct.is_force_inline,
             is_never_inline: fct.is_never_inline,
+            is_trait_object_ignore: fct.is_trait_object_ignore,
             bytecode: fct.bytecode.get().cloned(),
             trait_method_impl: fct
                 .trait_method_impl
@@ -245,6 +246,7 @@ fn create_functions(sa: &Sema, e: &mut Emitter) -> Vec<FunctionData> {
             is_variadic: false,
             is_force_inline: false,
             is_never_inline: false,
+            is_trait_object_ignore: false,
             bytecode: Some(global.bytecode().clone()),
             trait_method_impl: None,
         });

dora-frontend/src/program_parser.rs

@@ -701,7 +701,7 @@ impl<'x> visit::Visitor for TopLevelDeclaration<'x> {
             &node.modifiers,
             &[
                 Annotation::Internal,
-                Annotation::OptimizeImmediately,
+                Annotation::Optimize,
                 Annotation::Test,
                 Annotation::Pub,
                 Annotation::ForceInline,
@@ -919,7 +919,11 @@ fn find_elements_in_trait(
                     sa,
                     trait_.file_id,
                     &method_node.modifiers,
-                    &[Annotation::Static, Annotation::OptimizeImmediately],
+                    &[
+                        Annotation::Static,
+                        Annotation::Optimize,
+                        Annotation::TraitObjectIgnore,
+                    ],
                 );
 
                 let container_type_param_definition = trait_.type_param_definition().clone();
@@ -1226,7 +1230,7 @@ fn find_elements_in_extension(
                         Annotation::Internal,
                         Annotation::Static,
                         Annotation::Pub,
-                        Annotation::OptimizeImmediately,
+                        Annotation::Optimize,
                     ],
                 );
 
@@ -1296,6 +1300,7 @@ pub struct ParsedModifierList {
     pub is_internal: bool,
     pub is_force_inline: bool,
     pub is_never_inline: bool,
+    pub is_trait_object_ignore: bool,
 }
 
 impl ParsedModifierList {
@@ -1314,10 +1319,11 @@ enum Annotation {
     Pub,
     Static,
     Test,
-    OptimizeImmediately,
+    Optimize,
     ForceInline,
     NeverInline,
     Error,
+    TraitObjectIgnore,
 }
 
 impl Annotation {
@@ -1331,9 +1337,10 @@ impl Annotation {
             Annotation::Pub => "pub",
             Annotation::Static => "static",
             Annotation::Test => "test",
-            Annotation::OptimizeImmediately => "Optimize",
+            Annotation::Optimize => "Optimize",
             Annotation::ForceInline => "ForceInline",
             Annotation::NeverInline => "NeverInline",
+            Annotation::TraitObjectIgnore => "TraitObjectIgnore",
             Annotation::Error => "<error>",
         }
     }
@@ -1398,7 +1405,7 @@ fn check_modifier(
 
                 "Optimize" => {
                     parsed_modifiers.is_optimize_immediately = true;
-                    Annotation::OptimizeImmediately
+                    Annotation::Optimize
                 }
 
                 "internal" => {
@@ -1416,6 +1423,11 @@ fn check_modifier(
                     Annotation::NeverInline
                 }
 
+                "TraitObjectIgnore" => {
+                    parsed_modifiers.is_trait_object_ignore = true;
+                    Annotation::TraitObjectIgnore
+                }
+
                 _ => {
                     sa.report(
                         file_id,

dora-frontend/src/sema.rs

@@ -44,7 +44,7 @@ pub use self::src::{
 pub use self::structs::{
     StructDefinition, StructDefinitionField, StructDefinitionFieldId, StructDefinitionId,
 };
-pub use self::traits::{is_object_safe, TraitDefinition, TraitDefinitionId};
+pub use self::traits::{is_trait_object_safe, TraitDefinition, TraitDefinitionId};
 pub use self::tuples::create_tuple;
 pub use self::type_params::{new_identity_type_params, Bound, TypeParamDefinition, TypeParamId};
 pub use self::uses::{UseDefinition, UseDefinitionId};

dora-frontend/src/sema/functions.rs

@@ -37,6 +37,7 @@ pub struct FctDefinition {
     pub is_internal: bool,
     pub is_force_inline: bool,
     pub is_never_inline: bool,
+    pub is_trait_object_ignore: bool,
     pub params: Params,
     pub return_type: ParsedType,
 
@@ -86,6 +87,7 @@ impl FctDefinition {
             is_internal: modifiers.is_internal,
             is_force_inline: modifiers.is_force_inline,
             is_never_inline: modifiers.is_never_inline,
+            is_trait_object_ignore: modifiers.is_trait_object_ignore,
             analysis: OnceCell::new(),
             type_param_definition: type_params,
             container_type_params: OnceCell::new(),
@@ -128,6 +130,7 @@ impl FctDefinition {
             is_internal: modifiers.is_internal,
             is_force_inline: modifiers.is_force_inline,
             is_never_inline: modifiers.is_never_inline,
+            is_trait_object_ignore: modifiers.is_trait_object_ignore,
             analysis: OnceCell::new(),
             type_param_definition: type_params,
             container_type_params: OnceCell::new(),

dora-frontend/src/sema/traits.rs

@@ -170,7 +170,7 @@ impl ElementAccess for TraitDefinition {
     }
 }
 
-pub fn is_object_safe(sa: &Sema, trait_id: TraitDefinitionId) -> bool {
+pub fn is_trait_object_safe(sa: &Sema, trait_id: TraitDefinitionId) -> bool {
     let trait_ = sa.trait_(trait_id);
 
     for &alias_id in trait_.aliases() {
@@ -183,6 +183,10 @@ pub fn is_object_safe(sa: &Sema, trait_id: TraitDefinitionId) -> bool {
     for method_id in trait_.methods() {
         let method = sa.fct(*method_id);
 
+        if method.is_trait_object_ignore {
+            continue;
+        }
+
         if method.type_param_definition().has_own_type_params() {
             return false;
         }
@@ -204,7 +208,7 @@ pub fn is_object_safe(sa: &Sema, trait_id: TraitDefinitionId) -> bool {
 
     let type_param_definition = trait_.type_param_definition();
     for bound in type_param_definition.bounds_for_self() {
-        if !is_object_safe(sa, bound.trait_id) {
+        if !is_trait_object_safe(sa, bound.trait_id) {
             return false;
         }
     }

dora-frontend/src/typeck/lookup.rs

@@ -20,12 +20,16 @@ pub fn find_method_call_candidates(
     if let SourceType::TraitObject(trait_id, trait_type_params, _bindings) = object_type.clone() {
         let trait_ = sa.trait_(trait_id);
         if let Some(fct_id) = trait_.get_method(name, false) {
-            candidates.push(Candidate {
-                object_type: object_type.clone(),
-                container_type_params: trait_type_params,
-                fct_id,
-            });
-            return candidates;
+            let method = sa.fct(fct_id);
+
+            if !method.is_trait_object_ignore {
+                candidates.push(Candidate {
+                    object_type: object_type.clone(),
+                    container_type_params: trait_type_params,
+                    fct_id,
+                });
+                return candidates;
+            }
         }
 
         find_super_trait_methods_on_trait_object(

dora-frontend/src/typeck/tests.rs

@@ -3548,6 +3548,20 @@ fn trait_object_method_call() {
     ");
 }
 
+#[test]
+fn trait_object_method_call_with_ignore() {
+    err(
+        "
+        trait Foo { @TraitObjectIgnore fn bar(): Int32; }
+        fn f(x: Foo): Int32 {
+            x.bar()
+        }
+    ",
+        (4, 13),
+        ErrorMessage::UnknownMethod("Foo".into(), "bar".into()),
+    );
+}
+
 #[test]
 fn trait_object_cast() {
     ok("

dora-runtime/src/vm/specialize.rs

@@ -13,7 +13,7 @@ use crate::vm::{
 use crate::{Shape, SpecializeSelf};
 use dora_bytecode::{
     BytecodeType, BytecodeTypeArray, ClassData, ClassId, EnumData, EnumId, FunctionId, Program,
-    StructData, StructId, TraitId, TypeParamData,
+    StructData, StructId, TraitData, TraitId, TypeParamData,
 };
 
 pub fn create_struct_instance(
@@ -467,6 +467,10 @@ pub fn compute_vtable_index(vm: &VM, trait_id: TraitId, trait_fct_id: FunctionId
     let vtable_index = trait_
         .methods
         .iter()
+        .filter(|id| {
+            let method = vm.fct(**id);
+            !method.is_trait_object_ignore
+        })
         .position(|m| *m == trait_fct_id)
         .expect("missing trait function");
     vtable_index.try_into().expect("overflow")
@@ -542,6 +546,20 @@ fn create_shape_for_trait_object(
     shape
 }
 
+fn count_virtual_methods(vm: &VM, trait_: TraitData) -> usize {
+    let mut count = 0;
+
+    for method_id in &trait_.methods {
+        let method = vm.program.fct(*method_id);
+
+        if !method.is_trait_object_ignore {
+            count += 1;
+        }
+    }
+
+    count
+}
+
 pub fn specialize_bty_array(
     types: &BytecodeTypeArray,
     type_params: &BytecodeTypeArray,

tests/trait/trait-default-count.dora

@@ -34,4 +34,10 @@ impl MyIterator for Range {
 fn main() {
     assert(Range(2).count() == 2);
     assert(Range(7).count() == 7);
+
+    let it = Range(3) as MyIterator[Item = Int];
+    assert(it.count() == 3);
+
+    let it = Range(7) as MyIterator[Item = Int];
+    assert(it.count() == 7);
 }

tests/trait/trait-default-enumerate.dora

@@ -2,6 +2,7 @@ trait MyIterator {
     type Item;
     fn next(): Option[Self::Item];
 
+    @TraitObjectIgnore
     fn enumerate(): Enumerate[Self] {
         Enumerate[Self](it = self, idx = 0)
     }
@@ -50,4 +51,9 @@ fn main() {
     assert(Some[(Int, Int)]((0, 2)) == r.next());
     assert(Some[(Int, Int)]((1, 1)) == r.next());
     assert(r.next().isNone());
+
+    let it = Range(2) as MyIterator[Item = Int];
+    assert(Some[Int](2) == it.next());
+    assert(Some[Int](1) == it.next());
+    assert(it.next().isNone());
 }

tests/trait/trait-object-ignore1.dora

@@ -0,0 +1,16 @@
+//= ignore
+
+trait Foo {
+    fn one(): Int { 1 }
+    @TraitObjectIgnore
+    fn two(): Int { 2 }
+    fn three(): Int { 3 }
+}
+
+impl Foo for Int {}
+
+fn main() {
+    let x = 1 as Foo;
+    assert(x.one() == 1);
+    assert(x.three() == 3);
+}