जंग में "अनुक्रम बिंदु"/"अनुक्रमित-पहले" नियम क्या हैं?

Question

सी ++ के लिए http://en.cppreference.com/w/cpp/language/eval_order यहां वर्णित नियमों के समान, जंग में नियम क्या हैं?

अभी के लिए मैं अनुभव पाया गया कि
1) कार्यों का तर्क सीधा आदेश
2) सभी में निर्मित दुष्प्रभावों के साथ परिचालन (में मूल्यांकन किया जाता =, + =, - =, आदि) वापसी इकाई, तो यह अभिव्यक्ति लिखने के लिए कठिन (लेकिन संभव) है, जो सी ++ में यूबी दिखाएगा।
एक उदाहरण:

let mut a = 1i; 
let b = 2i; 
let c = 3i; 
let d = (a = b) == (a = c); // What is a? (a is actually 3) 

3) यह फ़ंक्शन कॉल की तरह लगता है C++
4 के रूप में अनुक्रम कर रहे हैं) इसमें अंतर्निहित संचालन की तरह लगता है अनुक्रम कर रहे हैं जैसे कि वे समारोह (विधि) कहता है, यानी के आदेश थे मूल्यांकन ऑपरेटर प्राथमिकता

से जुड़ा हुआ है क्या मेरे निष्कर्ष सही हैं? सटीक मूल्यांकन मॉडल क्या है?

Answer 1

मुझे विश्वास नहीं है कि इसे स्पष्ट रूप से परिभाषित किया गया है, the manual के मेरे grepping कुछ भी चालू नहीं किया था। हालांकि, मैं गारंटी दे सकता हूं कि ये चीजें अपरिभाषित व्यवहार नहीं होंगी (जंग स्पष्ट रूप से unsafe कोड के बाहर यूबी से बचाती है), और मुझे आश्चर्य होगा कि अगर यह कुछ भी था, लेकिन "बाएं से दाएं", यानी, आपके द्वारा निकाला गया आदेश है। हालांकि, #6268 पर संकल्प परिणामस्वरूप रिसीवर का मूल्यांकन करने के तरीकों का परिणाम हो सकता है (या शायद नहीं, यह केवल एक संभावना है)।

मैंने #15300 खोला।

---

Btw, अगर आप इस जांच कर रहे हैं, तो आप संकलक सटीक मूल्यांकन के आदेश (नायब साथ बाहर विभाजित सुंदर नियंत्रण प्रवाह रेखांकन कर सकते हैं। यह सब आंतरिक एपीआई है, और इतने पर भरोसा नहीं किया जा सकता है, कंपाइलर क्रैश बनाने के लिए सामान्य से अधिक संभावना है, और कंपाइलर कार्यान्वयन विवरण छुपा नहीं है: यह मुख्य रूप से rustc पर काम करने वाले लोगों के लिए डिज़ाइन किया गया है)।

@pnkfelix बताते हैं, संकलक कोड जनरेशन (2014-07-02 के रूप में) के लिए सीएफजी का उपयोग नहीं कर रहा है, जिसका अर्थ है कि सीएफजी बिल्कुल सटीक होने की गारंटी नहीं है।

उदा। @ ChrisMorgan के उदाहरणों में से एक का एक नीचे छीन संस्करण लेने:

fn foo(_:(), x: int) -> int { 
    x 
} 

fn main() { 
    let mut a = 1; 
    { // A 
     a * foo(a = 3, a) 
    }; 
} 

हम संकलक कुछ ब्लॉक (यानी { ... }), --pretty flowgraph=<nodeid> के माध्यम से किया जा सकता है, जिसके भीतर बयान/अभिव्यक्ति का नियंत्रण प्रवाह ग्राफ बाहर विभाजित करना चाहते हैं संकलक के लिए विकल्प, लेकिन इसके लिए हमें अपने ब्याज के ब्लॉक की आईडी होना चाहिए। इस मामले में, हम चाहते हैं कि ब्लॉक A है। प्राप्त करने के लिए आईडी rustc --pretty expanded,identified साथ संकलन (: आईडी अब केवल मैक्रो विस्तार के बाद असाइन किए जाएंगे टिप्पणी है कि बस identified का उपयोग कर एक व्यर्थ अवशेष है):

#![feature(phase)] 
#![no_std] 
#![feature(globs)] 
#[phase(plugin, link)] 
extern crate std = "std#0.11.0-pre"; 
extern crate native = "native#0.11.0-pre"; 
use std::prelude::*; 
fn foo(_ /* pat 7 */:(), x /* pat 11 */: int) -> int { (x /* 15 */) } /* 
block 14 */ /* 4 */ 

fn main() { 
    let mut a /* pat 22 */ = (1 /* 23 */); 
    ({ 
     ((a /* 28 */) * 
      ((foo /* 30 
        */)(((a /* 32 */) = (3 /* 33 */) /* 31 */), (a /* 34 */)) /* 
       29 */) /* 27 */) 
    } /* block 26 */ /* 25 */); 
} /* block 18 */ /* 16 */ 

को भावुक internals कबाड़ बहुत सारे हैं, लेकिन बात हम की जरूरत है नहीं है एक टिप्पणी /* block 26 */। rustc --pretty flowgraph=26 एक डॉट फ़ाइल देता है, जो निम्न को प्रस्तुत करता है।आप उपरोक्त पहचानकर्ता एनोटेट स्रोत से परामर्श काम करने के लिए वास्तव में क्या प्रत्येक अभिव्यक्ति (id = .. बिट) है कर सकते हैं:

(लंबाई के लिए खेद है, जाहिर है इस कोड को कोई शाखाओं था और तो बस संचालन की एक लंबी श्रृंखला है ।)

Fwiw, कि अभिव्यक्ति 9 करने, मूल्यांकन करता है, जबकि मैं 3 उम्मीद कर रहा था (और नियंत्रण प्रवाह ग्राफ पुष्टि की है कि अलग a एलएचएस पर वहाँ a = 3 सहित) आरएचएस के बाद मूल्यांकन किया जा रहा है। मैंने इसे # 15300 (ई: और अब isolated it to a strange difference in evaluation order पर उठाया है)।