تجربة تحويل كود C # إلى كود الصدأ

صياغة المشكلة

يجب ترجمة كود C # إلى كود Rust. بتعبير أدق ، فإن إجراء الترجمة هذا مطلوب (يستمر التطوير في C #) بحيث يمكنك في أي وقت الحصول على رمز عمل في Rust. لقد قمت بحل هذه المشكلة للغات Java و Python و JavaScript و PHP عن طريق كتابة محول من C # إلى هذه اللغات. تم توضيح مفهوم هذا التحويل في مقالة UniSharping منذ عامين. كنت أقوم بتطوير هذا المحول لترجمة كود مشروع Pullenti SDK (تحليل النص اللغوي). وفكرت: لماذا لا تجرب الصدأ؟ نعم ، سمعت ردودًا مختلفة بأن اللغة غير معتادة ، وما إلى ذلك ، لكن هذه ليست محاولة تعذيب ... علاوة على ذلك ، لدى أحد العملاء مجموعة من المبرمجين الذين يكتبون فيها بحماس.

يجب أن أقول على الفور أنه لم يكن من الممكن القيام بذلك بالكامل ، كما هو الحال بالنسبة للغات الأخرى - لم تكن هناك قوة كافية. ربما سأعود إلى هذه المشكلة. قضينا شهرًا ونصف الشهر في القتال مع نفسي واللغة ، وتمكنا من إحضار المحول إلى النقطة التي بدأت فيها الكتلة الصرفية في الترجمة وحتى الترجمة (وبالتالي العمل) في Rust. بالطبع ، خلال هذا الوقت ، يمكن كتابة وحدة التشكل من الصفر ، ولكن خلفها كان هناك حوالي 500 فئة أخرى من C # ، تم إنشاؤها وتصحيحها لمدة 10 سنوات تقريبًا ، وليس من السهل إعادة كتابتها. في هذه المقالة ، أود مشاركة انطباعاتي عن لغة Rust ، وكذلك وصف التقنيات التي استخدمتها للتحويل.

انطباع لغة الصدأ

يقولون أن السيد لا يبحث عن طرق سهلة. ينطبق هذا تمامًا على Rust ، نظرًا لأن الكثير مما هو بسيط ومألوف في اللغات الأخرى يصبح معقدًا ، في حين أن المعقد لا يصبح بسيطًا. يبدو أنك تجد نفسك في عالم آخر للوهلة الأولى بمنطق سخيف ، والذي يصبح بعيدًا عن الفهم على الفور بعد إتقان المفاهيم الأساسية. لا يهم ما كتبته حتى الآن: C ++ ، و Java ، و Python ، وما إلى ذلك ، ولكن عندما يتبين أنه بعد إضافة كائن إلى القائمة ، لا يمكنك استخدام: ، it = new ...(); list.add(it); it.val = ...ولكن يمكنك it = new ...(); it.val = ...; list.add(it);القيام بذلك على النحو التالي : ، إنه أمر محبط. أو ، لتنفيذ المراجع التبادلية بين كائنات فئة Foo ، تحتاج إلى استخدام الإنشاء Option<Rc<RefCell<Foo>>>، والوصول إلى حقل val الخاص بهذه الفئة ، اتصل foo.unwrap().borrow().val.

: , , . Rust , . ( Rust 20-). ? .

Rust — C# 2 . , , ( ). , , Rust C/C++ . . , Rust /C++, , ...

Rust , "" 50 , - , . 80- ( ), , . . - , trait- ( interface Java C#), - , . , , ? , Rust , .

Rust — (heap). — new/delete. \++, , . , delete . , . , , new. : Java, C#, Python, JavaScritp, PHP .

Rust , , , . , { ... let x = Foo {... }; ... }, . — - . , , (mut) , , . , , C# buf stream.Read(buf, 0, buf.Length) , buf mut-, buf . : int len = buf.Length; stream.Read(buf, 0, len);.

, C# Rust. , — .

C#

, SDK C# Java. , , . , , — C# , . . UniSharping. , . , C#, . , Java yield, C# — !

C# . Java DLL, Java . Python , , . JavaScript long ( byte, short, int, float, double, long- ), SDK C# long int, . PHP string utf-8 i- . , mb_, - . Rust , -.

C#, - : #if JAVA || PYTHON… #else… #endif — .

— . , , ? . Rust , .

, .

C#, , , — Rust , . for(...; ...; ...) while — . byte, int, float . , . .

T C# Rust : T ( ), &T ( ) &mut T ( ). , C# — C# , Rust , .

var obj = new T(); //    T
FuncNotModif(obj); //    
FuncModif(obj); //   
list.Add(obj); //    List<T>
var obj2 = obj; //      
var obj3 = obj; //      

Rust:

let obj = T { }; //    T (   )
func_not_modif(&obj); //   ,   obj   
func_modif(&mut obj); //    
list.push(&obj); //       Vec<&T>,   obj 
let obj2 : &T = &obj; //    
let obj3 : T = obj; //      obj3,  obj  obj2   

, Rust , : =, return &. , .

C# , : T, &T &mut T? , :

&T &mut T , ( ), , property { get; set; } &T, — T. C# /*&*/ /*&mut*/ . , List<T/*&*/>, , List<T/*&*/>/*&*/.

: , , , . , . — , . , .

Rust utf-8 ( PHP). , 2 . C#, Java . char 16 ( 8 , ++ 8 16), Rust. Unicode 32-, 64-? . — , 7- ASCII.

str[i]. ?

— (struct Rust), , string.

#[derive(Clone)]
pub struct NString {
    pub chars : Vec<char>,
    pub string : String,
    _is_null : bool
}
impl NString {
    pub fn from_string(s : &String) -> NString {
        NString { chars : s.chars().collect(), string : s.clone(), _is_null : false }
    }
    pub fn from_str(s : &str) -> NString {
        NString { chars : s.chars().collect(), string : s.to_string(), _is_null : false }
    }
    pub fn from_chars(s : &Vec<char>) -> NString {
        NString { chars : s.clone(), string : s.into_iter().collect(), _is_null : false }
    }
...
}

, chars, — String. C# , Rust. , Substring(int start, int len) :

    pub fn substring(&self, pos : i32, len : i32) -> NString {
        let length : i32 = if len <= 0 { self.chars.len() as i32 - pos } else { len };
        let sub = self.chars[pos as usize .. (pos + length) as usize].to_vec();
        NString::from_chars(&sub)
    }

- , &STR_HELLO STR_HELLO.clone() :

static STR_HELLO : Lazy<NString> = Lazy::new(|| { NString::from_str("Hello!") }); 
use once_cell::sync::Lazy;

, Rust , . , , C# , Vec HashMap . 3 : , &T T. array[] Rust , List.

Object

Rust null object, . , C# "" object "" — Rust . , .

object, object. , , , /*=*/ object.

            object/*=ObjValue*/ obj = "Hello";
            Console.WriteLine(obj);
            obj = 10;
            if (obj is int)
            {
                int ii = (int)obj;
                Console.WriteLine(ii);
            }
            obj = cnt.First; //   Item
            if(obj is Item)
                Console.WriteLine((obj as Item).Str);

#if RUST  //  C#   
        //RUST object_class
        class ObjValue
        {
            public string Str;
            public int Int;
            public Item/*&*/ Item;
        }
#endif

, object int, string Item, , Item — .

ObjValue, C#, .

        let mut obj : ObjValue = ObjValue::from_str_(STR_HELLO.clone());
        println!("{}", &obj.to_nstring());
        obj = ObjValue::from_int(10);
        if obj.is_class("i32") {
            let mut ii : i32 = obj.int;
            println!("{}", &NString::from_string(&ii.to_string()));
        }
        obj = ObjValue::from_item(Some(Rc::clone(cnt.borrow().get_first().as_ref().unwrap())));
        if obj.is_class("Item") {
            println!("{}", obj.item.as_ref().unwrap().borrow().get_str());
        }

pub struct ObjValue {
    pub str_ : NString, 
    pub int : i32, 
    pub item : Option<Rc<RefCell<dyn IItem>>>, 
    _typ : &'static str
}

impl ObjValue {
    pub fn from_str_(val : NString) -> ObjValue {
        ObjValue { str_ : val, int : 0, item : None, _typ : "NString" }
    }
    pub fn from_int(val : i32) -> ObjValue {
        ObjValue { str_ : NString::null(), int : val, item : None, _typ : "i32" }
    }
    pub fn from_item(val : Option<Rc<RefCell<dyn IItem>>>) -> ObjValue {
        ObjValue { str_ : NString::null(), int : 0, item : val, _typ : "Item" }
    }
    pub fn null() -> ObjValue {
        ObjValue { str_ : NString::null(), int : 0, item : None, _typ : "" }
    }
    pub fn is_null(&self) -> bool { self._typ.len() == 0 }
    pub fn is_class(&self, typ : &str) -> bool { self._typ == typ }
    pub fn to_nstring(&self) -> NString {
        if self._typ == "NString" { return self.str_.clone(); }
        if self._typ == "i32" { return NString::from_string(&self.int.to_string()); }
        if self._typ == "Item" { return NString::from_str("Option<Rc<RefCell<dyn IItem>>>"); }
        NString::null()
    }
}

, . ! , .

: obj = cnt.First Rust obj = ObjValue::from_item(Some(Rc::clone(cnt.borrow().get_first().as_ref().unwrap()))). , ? , ! , , .

C# Rust struct, — trait. , — . . C# , : . .

- - , .

. A, , trait, , get set ( property). struct B A (struct B { base : A, }), B trait A. A, self.base.x.

.

    //RUST RefCell
    class Item
    {
        public Item(int val) { Val = val; }
        public int Val { get; set; }
        public string Str;
        public Item/*&*/ Prev { get; set; }
        public Item/*&*/ Next { get; set; }
        public virtual void Inc() { Val += 1; }
    }
    //RUST RefCell
    class ItemChild : Item
    {
        public ItemChild(int val) : base(val) { }
        public override void Inc() { Val *= 2; }
    }

( ). trait.

pub trait IItem {
    fn get_val(&self) -> i32;
    fn set_val(&mut self, value : i32) -> i32;
    fn get_str(&self) -> &NString;
    fn set_str(&mut self, value : NString) -> &NString;
    fn get_prev(&self) -> &Option<Rc<RefCell<dyn IItem>>>;
    fn set_prev(&mut self, value : Option<Rc<RefCell<dyn IItem>>>) -> &Option<Rc<RefCell<dyn IItem>>>;
    fn get_next(&self) -> &Option<Rc<RefCell<dyn IItem>>>;
    fn set_next(&mut self, value : Option<Rc<RefCell<dyn IItem>>>) -> &Option<Rc<RefCell<dyn IItem>>>;
    fn inc(&mut self);
    fn get_base_class(&self) -> &dyn IItem;
    fn is_class(&self, name : &str) -> bool;
    fn as_item(&self) -> &dyn IItem;
    fn as_mut_item(&mut self) -> &mut dyn IItem;
}

.

pub struct Item {
    pub _val : i32, 
    pub m_str : NString, 
    pub _prev : Option<Rc<RefCell<dyn IItem>>>, 
    pub _next : Option<Rc<RefCell<dyn IItem>>>, 
}

impl IItem for Item {
    fn get_val(&self) -> i32 {
        return self._val;
    }
    fn set_val(&mut self, mut value : i32) -> i32 {
        self._val = value;
        return self._val;
    }
    fn get_prev(&self) -> &Option<Rc<RefCell<dyn IItem>>> {
        return &self._prev;
    }
    fn set_prev(&mut self, mut value : Option<Rc<RefCell<dyn IItem>>>) -> &Option<Rc<RefCell<dyn IItem>>> {
        self._prev = utils::clone_opt_ref(&value);
        return &self._prev;
    }
...
    fn inc(&mut self) {
        self.set_val(self.get_val() + 1);
    }
    fn as_item(&self) -> &dyn IItem { self }
    fn as_mut_item(&mut self) -> &mut dyn IItem { self }
    fn get_base_class(&self) -> &dyn IItem { self }
    fn is_class(&self, name : &str) -> bool { name == "Item" }
}

impl Item {
    pub fn new(mut __val : i32) -> Item {
        let mut self_result = Item {  _val : 0,  _prev : None,  _next : None,  m_str : NString::null() };
        self_result.set_val(__val);
        self_result
    }
}

:

pub struct ItemChild {
    pub base : Item, //   
}
impl IItem for ItemChild {
    fn get_val(&self) -> i32 {
        self.base.get_val()  //      base
    }
    fn set_val(&mut self, value : i32) -> i32 {
        self.base.set_val(value)
    }
    //   -     
    fn inc(&mut self) {
        self.base.set_val(self.get_val() * 2);
    }
    ....
}

impl ItemChild {
    pub fn new(mut __val : i32) -> ItemChild {
        ItemChild {  base : Item::new(__val) };
    }
}

Item ItemChild ITrait, inc() , trait — ! .

&T (lifetime), , , . , : struct A<'a> { ref : &'a Item, ... }. , 'a. . , , lifetime-hell, . , Rust !

: Option<Rc<RefCell<T>>>. . — , . , Option<Weak<RefCell<T>>>. " , , ! — , ..."

, , . SDK , 10% . , , . " " , , C# — Rust . .

, Rust , … , . Rust — , , , - ! !