Merge pull request #22 from FractalFir/type_caching

Complete rewrite of the type handling system

Author: FractalFir

Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 ar = "0.9.0"
 colored = "2.0.4"
+either = "1.9.0"
 lazy_static = "1.4.0"
 postcard = { version = "1.0.6", features = ["use-std"] }
 serde = { version = "1.0.183", features = ["derive"] }

README.md

@@ -55,7 +55,7 @@ The project is still very early in development, but it has made significant prog
 
 ## Milestones
 - [X] Draft version of the `mycorrhiza` interop layer, capable of creating managed objects, and calling methods. 
-- [ ] Compiling the `core` Rust crate - *Substantial chunk of core now compiles,  with many  methods still having trouble compiling. The compilation still gets terminated early due to errors* 
+- [X] Compiling the `core` Rust crate - *Core now compiles, but is not fully functional. Around ~100 function instances don't compile at all, and a couple more compile with errors.
 - [ ] Compiling the `alloc` Rust crate 
 - [ ] Compiling the `std` Rust crate 
 - [ ] Stack unwinding 

cargo_tests/build_alloc/.cargo/config.toml

@@ -1,5 +1,5 @@
 [build]
 target = "wasm64-unknown-unknown"
 [unstable]
-build-std = ["panic_abort","alloc"]
+build-std = ["panic_abort","core","alloc"]
 

cargo_tests/build_alloc/src/main.rs

@@ -1,9 +1,10 @@
 #![allow(internal_features,unused_imports,incomplete_features,unused_variables,dead_code,improper_ctypes_definitions)]
 #![feature(lang_items,adt_const_params,associated_type_defaults,core_intrinsics,start)]
 #![no_std]
-//use mycorrhiza::{start,panic_handler};
-//panic_handler!{}
-//start!{}
+
+use mycorrhiza::{start,panic_handler};
+panic_handler!{}
+start!{}
 //#[lang = "eh_personality"]
 //fn rust_eh_personality() {}
 fn main() {

cargo_tests/build_core/Cargo.toml

@@ -7,4 +7,6 @@ edition = "2021"
 
 [dependencies]
 mycorrhiza = {path="../../mycorrhiza"}
-[workspace]
+[workspace]
+
+codegen-units = 1

cargo_tests/build_core/src/main.rs

@@ -1,9 +1,10 @@
 #![allow(internal_features,unused_imports,incomplete_features,unused_variables,dead_code,improper_ctypes_definitions)]
 #![feature(lang_items,adt_const_params,associated_type_defaults,core_intrinsics,start)]
 #![no_std]
-//use mycorrhiza::{start,panic_handler};
-//panic_handler!{}
-//start!{}
+
+use mycorrhiza::{start,panic_handler};
+panic_handler!{}
+start!{}
 //#[lang = "eh_personality"]
 //fn rust_eh_personality() {}
 fn main() {

cargo_tests/build_std/.cargo/config.toml

@@ -1,5 +1,5 @@
 [build]
 target = "wasm64-unknown-unknown"
 [unstable]
-build-std = ["panic_abort","std"]
+build-std = ["core","alloc","std","panic_abort"]
 

cargo_tests/build_std/Cargo.toml

@@ -7,4 +7,6 @@ edition = "2021"
 
 [dependencies]
 mycorrhiza = {path="../../mycorrhiza"}
-[workspace]
+[workspace]
+[profile.release.build-override]
+codegen-units = 1

cargo_tests/build_std/src/main.rs

@@ -1,6 +1,7 @@
 #![allow(internal_features,unused_imports,incomplete_features,unused_variables,dead_code,improper_ctypes_definitions)]
 #![feature(lang_items,adt_const_params,associated_type_defaults,core_intrinsics,start)]
-#![no_std]
+//#![no_std]
+
 //use mycorrhiza::{start,panic_handler};
 //panic_handler!{}
 //start!{}

cargo_tests/fastrand_test/src/main.rs

@@ -1,6 +1,6 @@
 #![no_std]
 #![feature(start,core_intrinsics,lang_items)]
-//use glam::*;
+use fastrand::*;
 use mycorrhiza::{start,panic_handler};
 use core::hint::black_box;
 panic_handler!{}
@@ -10,5 +10,9 @@ fn rust_eh_personality() {}
 fn main() {
     let tuple = (2,black_box(8));
     black_box(tuple);
-    mycorrhiza::system::runtime::Console;
+    let mut rng = black_box(fastrand::Rng::with_seed(0xDEAD_BEEF));
+//let mut bytes: Vec<u8> = repeat_with(|| ).take(10_000).collect();
+
+
+    mycorrhiza::system::console::Console::writeln_u64(black_box(rng.u64(..)));
 }

src/aggregate.rs

@@ -1,9 +1,11 @@
 use crate::cil_op::{CILOp, FieldDescriptor};
-use crate::r#type::{DotnetTypeRef, Type};
+use crate::r#type::{DotnetTypeRef, TyCache, Type};
 use crate::utilis::{field_name, monomorphize};
 use rustc_index::IndexVec;
 use rustc_middle::mir::{AggregateKind, Operand, Place};
-use rustc_middle::ty::{AdtDef, AdtKind, GenericArg, Instance, List, ParamEnv, Ty, TyCtxt, TyKind};
+use rustc_middle::ty::{
+    AdtDef, AdtKind, EarlyBinder, GenericArg, Instance, List, ParamEnv, Ty, TyCtxt, TyKind,
+};
 use rustc_target::abi::FieldIdx;
 /// Returns the CIL ops to create the aggreagate value specifed by `aggregate_kind` at `target_location`. Uses indivlidual values specifed by `value_index`
 pub fn handle_aggregate<'tyctx>(
@@ -13,6 +15,7 @@ pub fn handle_aggregate<'tyctx>(
     aggregate_kind: &AggregateKind<'tyctx>,
     value_index: &IndexVec<FieldIdx, Operand<'tyctx>>,
     method_instance: Instance<'tyctx>,
+    tycache: &mut TyCache,
 ) -> Vec<CILOp> {
     // Get CIL ops for each value
     let values: Vec<_> = value_index
@@ -21,14 +24,18 @@ pub fn handle_aggregate<'tyctx>(
         .map(|operand| {
             (
                 operand.0 as u32,
-                crate::operand::handle_operand(operand.1, tyctx, method, method_instance),
+                crate::operand::handle_operand(operand.1, tyctx, method, method_instance, tycache),
             )
         })
         .collect();
     match aggregate_kind {
         AggregateKind::Adt(adt_def, variant_idx, subst, _utai, active_field) => {
-            let penv = ParamEnv::empty();
-            let adt_type = Instance::resolve(tyctx, penv, *adt_def, subst)
+            let penv = ParamEnv::reveal_all();
+            let subst = crate::utilis::monomorphize(&method_instance, *subst, tyctx);
+            //eprintln!("Preparing to resolve {adt_def:?} {subst:?}");
+            let adt_type = Instance::resolve(tyctx, penv, *adt_def, subst);
+
+            let adt_type = adt_type
                 .expect("Could not resolve instance")
                 .expect("Could not resolve instance")
                 .ty(tyctx, penv);
@@ -48,15 +55,22 @@ pub fn handle_aggregate<'tyctx>(
                 variant_idx.as_u32(),
                 values,
                 method_instance,
-                active_field,
+                &active_field,
+                tycache,
             )
         }
         AggregateKind::Array(element) => {
-            let element = Type::from_ty(*element, tyctx, &method_instance);
+            let element = crate::utilis::monomorphize(&method_instance, *element, tyctx);
+            let element = tycache.type_from_cache(element, tyctx, Some(method_instance));
             let array_type = DotnetTypeRef::array(element.clone(), value_index.len());
             let mut ops: Vec<CILOp> = Vec::with_capacity(values.len() * 2);
-            let array_getter =
-                super::place::place_adress(target_location, tyctx, method, method_instance);
+            let array_getter = super::place::place_adress(
+                target_location,
+                tyctx,
+                method,
+                method_instance,
+                tycache,
+            );
             let sig = crate::function_sig::FnSig::new(
                 &[array_type.clone().into(), Type::USize, Type::GenericArg(0)],
                 &Type::Void,
@@ -75,19 +89,30 @@ pub fn handle_aggregate<'tyctx>(
                 tyctx,
                 method,
                 method_instance,
+                tycache,
             ));
             ops
         }
         AggregateKind::Tuple => {
             if values.len() > 8 {
                 todo!("Tuples with more than 8 fields are not supported yet.");
             } else {
-                let tuple_getter =
-                    super::place::place_adress(target_location, tyctx, method, method_instance);
+                let tuple_getter = super::place::place_adress(
+                    target_location,
+                    tyctx,
+                    method,
+                    method_instance,
+                    tycache,
+                );
                 let types: Vec<_> = value_index
                     .iter()
                     .map(|operand| {
-                        Type::from_ty(operand.ty(method, tyctx), tyctx, &method_instance)
+                        let operand_ty = crate::utilis::monomorphize(
+                            &method_instance,
+                            operand.ty(method, tyctx),
+                            tyctx,
+                        );
+                        tycache.type_from_cache(operand_ty, tyctx, Some(method_instance))
                     })
                     .collect();
                 let dotnet_tpe = crate::r#type::tuple_type(&types);
@@ -107,6 +132,7 @@ pub fn handle_aggregate<'tyctx>(
                     tyctx,
                     method,
                     method_instance,
+                    tycache,
                 ));
                 ops
             }
@@ -126,56 +152,54 @@ fn aggregate_adt<'tyctx>(
     fields: Vec<(u32, Vec<CILOp>)>,
     method_instance: Instance<'tyctx>,
     _active_field: &Option<FieldIdx>,
+    type_cache: &mut crate::r#type::TyCache,
 ) -> Vec<CILOp> {
     let adt_type = crate::utilis::monomorphize(&method_instance, adt_type, tyctx);
-    let adt_type_ref = Type::from_ty(adt_type, tyctx, &method_instance);
+    let adt_type_ref = type_cache.type_from_cache(adt_type, tyctx, Some(method_instance));
     let adt_type_ref = if let Type::DotnetType(type_ref) = adt_type_ref {
         type_ref.as_ref().clone()
     } else {
         panic!("Can't get fields of type {adt_type:?}");
     };
     match adt.adt_kind() {
         AdtKind::Struct => {
-            let obj_getter =
-                crate::place::place_adress(target_location, tyctx, method, method_instance);
+            let obj_getter = crate::place::place_adress(
+                target_location,
+                tyctx,
+                method,
+                method_instance,
+                type_cache,
+            );
             let mut ops: Vec<CILOp> = Vec::with_capacity(fields.len() * 2);
             for field in fields {
                 ops.extend(obj_getter.iter().cloned());
                 ops.extend(field.1);
-                let field_def = adt
-                    .all_fields()
-                    .nth(field.0 as usize)
-                    .expect("Could not find field!");
-                let field_type = field_def.ty(tyctx, subst);
-
-                let field_type = if crate::utilis::is_ty_alias(field_type) {
-                    Type::from_ty(
-                        crate::utilis::monomorphize(&method_instance, field_type, tyctx),
-                        tyctx,
-                        &method_instance,
-                    )
-                } else {
-                    crate::utilis::generic_field_ty(adt_type, field.0, tyctx, method_instance)
-                };
-                let field_name = field_name(adt_type, field.0);
-                let field_desc = crate::cil_op::FieldDescriptor::boxed(
-                    adt_type_ref.clone(),
-                    field_type,
-                    field_name,
+                let field_desc = crate::utilis::field_descrptor(
+                    adt_type,
+                    field.0,
+                    tyctx,
+                    method_instance,
+                    type_cache,
                 );
-                ops.push(CILOp::STField(field_desc));
+                ops.push(CILOp::STField(field_desc.into()));
             }
             ops.extend(crate::place::place_get(
                 target_location,
                 tyctx,
                 method,
                 method_instance,
+                type_cache,
             ));
             ops
         }
         AdtKind::Enum => {
-            let adt_adress_ops =
-                crate::place::place_adress(target_location, tyctx, method, method_instance);
+            let adt_adress_ops = crate::place::place_adress(
+                target_location,
+                tyctx,
+                method,
+                method_instance,
+                type_cache,
+            );
 
             let mut variant_type = adt_type_ref.clone(); //adt_type.variant_type(variant).expect("Can't get variant index");
             let variant_name = crate::utilis::variant_name(adt_type, variant_idx);
@@ -203,16 +227,15 @@ fn aggregate_adt<'tyctx>(
                 ops.extend(variant_address.clone());
                 ops.extend(field_value.1.clone());
                 let field_name = field.name.to_string();
-                let field_name = crate::type_def::escape_field_name(&field_name);
-                let field = crate::utilis::generic_field_ty(
-                    adt_type,
-                    field_idx as u32,
+                let field_name = crate::r#type::escape_field_name(&field_name);
+                let field_type = type_cache.type_from_cache(
+                    field.ty(tyctx, subst),
                     tyctx,
-                    method_instance,
+                    Some(method_instance),
                 );
                 ops.push(CILOp::STField(Box::new(FieldDescriptor::new(
                     variant_type.clone(),
-                    field,
+                    field_type,
                     field_name,
                 ))));
             }
@@ -233,12 +256,18 @@ fn aggregate_adt<'tyctx>(
                 tyctx,
                 method,
                 method_instance,
+                type_cache,
             ));
             ops
         }
         AdtKind::Union => {
-            let obj_getter =
-                crate::place::place_adress(target_location, tyctx, method, method_instance);
+            let obj_getter = crate::place::place_adress(
+                target_location,
+                tyctx,
+                method,
+                method_instance,
+                type_cache,
+            );
             let mut ops: Vec<CILOp> = Vec::with_capacity(fields.len() * 2);
             for field in fields {
                 ops.extend(obj_getter.iter().cloned());
@@ -247,23 +276,25 @@ fn aggregate_adt<'tyctx>(
                     .all_fields()
                     .nth(field.0 as usize)
                     .expect("Could not find field!");
-                let _field_type = field_def.ty(tyctx, subst);
-
+                let field_type = field_def.ty(tyctx, subst);
+                let field_type = crate::utilis::monomorphize(&method_instance, field_type, tyctx);
                 let field_type =
-                    crate::utilis::generic_field_ty(adt_type, field.0, tyctx, method_instance);
+                    type_cache.type_from_cache(field_type, tyctx, Some(method_instance));
                 let field_name = field_name(adt_type, field.0);
                 let field_desc = crate::cil_op::FieldDescriptor::boxed(
                     adt_type_ref.clone(),
                     field_type,
                     field_name,
                 );
-                ops.push(CILOp::STField(field_desc));
+
+                ops.push(CILOp::STField(field_desc.into()));
             }
             ops.extend(crate::place::place_get(
                 target_location,
                 tyctx,
                 method,
                 method_instance,
+                type_cache,
             ));
             ops
         }