---

yaml
---
r: 226074
b: refs/heads/stable
c: feba393
h: refs/heads/master
v: v3

Author: geofft

[refs]

@@ -29,6 +29,6 @@ refs/heads/tmp: e5d90d98402475b6e154ce216f9efcb80da1a747
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 1fe32ca12c51afcd761d9962f51a74ff0d07a591
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 2287b4b628cb6f4d66578e1298cd9f34e9ef77db
+refs/heads/stable: feba393b8ed60efe79f9f5207fde904d085949f5
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b

branches/stable/src/doc/footer.inc

@@ -5,4 +5,5 @@ or the <a href="http://opensource.org/licenses/MIT">MIT license</a>, at your opt
 </p><p>
 This file may not be copied, modified, or distributed except according to those terms.
 </p></footer>
+<script type="text/javascript" src="jquery.js"></script>
 <script type="text/javascript" src="playpen.js"></script>

branches/stable/src/librustc/middle/ty.rs

@@ -20,6 +20,7 @@ pub use self::Variance::*;
 pub use self::AutoAdjustment::*;
 pub use self::Representability::*;
 pub use self::AutoRef::*;
+pub use self::ExprKind::*;
 pub use self::DtorKind::*;
 pub use self::ExplicitSelfCategory::*;
 pub use self::FnOutput::*;
@@ -86,7 +87,7 @@ use syntax::abi;
 use syntax::ast::{CrateNum, DefId, ItemImpl, ItemTrait, LOCAL_CRATE};
 use syntax::ast::{MutImmutable, MutMutable, Name, NamedField, NodeId};
 use syntax::ast::{StmtExpr, StmtSemi, StructField, UnnamedField, Visibility};
-use syntax::ast_util::{self, is_local, local_def};
+use syntax::ast_util::{self, is_local, lit_is_str, local_def};
 use syntax::attr::{self, AttrMetaMethods, SignedInt, UnsignedInt};
 use syntax::codemap::Span;
 use syntax::parse::token::{self, InternedString, special_idents};
@@ -5105,35 +5106,104 @@ pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> def::Def {
     }
 }
 
-pub fn expr_is_lval(tcx: &ctxt, expr: &ast::Expr) -> bool {
-     match expr.node {
+pub fn expr_is_lval(tcx: &ctxt, e: &ast::Expr) -> bool {
+    match expr_kind(tcx, e) {
+        LvalueExpr => true,
+        RvalueDpsExpr | RvalueDatumExpr | RvalueStmtExpr => false
+    }
+}
+
+/// We categorize expressions into three kinds.  The distinction between
+/// lvalue/rvalue is fundamental to the language.  The distinction between the
+/// two kinds of rvalues is an artifact of trans which reflects how we will
+/// generate code for that kind of expression.  See trans/expr.rs for more
+/// information.
+#[derive(Copy, Clone)]
+pub enum ExprKind {
+    LvalueExpr,
+    RvalueDpsExpr,
+    RvalueDatumExpr,
+    RvalueStmtExpr
+}
+
+pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
+    if tcx.method_map.borrow().contains_key(&MethodCall::expr(expr.id)) {
+        // Overloaded operations are generally calls, and hence they are
+        // generated via DPS, but there are a few exceptions:
+        return match expr.node {
+            // `a += b` has a unit result.
+            ast::ExprAssignOp(..) => RvalueStmtExpr,
+
+            // the deref method invoked for `*a` always yields an `&T`
+            ast::ExprUnary(ast::UnDeref, _) => LvalueExpr,
+
+            // the index method invoked for `a[i]` always yields an `&T`
+            ast::ExprIndex(..) => LvalueExpr,
+
+            // in the general case, result could be any type, use DPS
+            _ => RvalueDpsExpr
+        };
+    }
+
+    match expr.node {
         ast::ExprPath(..) => {
-            // We can't use resolve_expr here, as this needs to run on broken
-            // programs. We don't need to through - associated items are all
-            // rvalues.
-            match tcx.def_map.borrow().get(&expr.id) {
-                Some(&def::PathResolution {
-                    base_def: def::DefStatic(..), ..
-                }) | Some(&def::PathResolution {
-                    base_def: def::DefUpvar(..), ..
-                }) | Some(&def::PathResolution {
-                    base_def: def::DefLocal(..), ..
-                }) => {
-                    true
+            match resolve_expr(tcx, expr) {
+                def::DefVariant(tid, vid, _) => {
+                    let variant_info = enum_variant_with_id(tcx, tid, vid);
+                    if !variant_info.args.is_empty() {
+                        // N-ary variant.
+                        RvalueDatumExpr
+                    } else {
+                        // Nullary variant.
+                        RvalueDpsExpr
+                    }
                 }
 
-                Some(..) => false,
+                def::DefStruct(_) => {
+                    match tcx.node_types.borrow().get(&expr.id) {
+                        Some(ty) => match ty.sty {
+                            TyBareFn(..) => RvalueDatumExpr,
+                            _ => RvalueDpsExpr
+                        },
+                        // See ExprCast below for why types might be missing.
+                        None => RvalueDatumExpr
+                     }
+                }
 
-                None => tcx.sess.span_bug(expr.span, &format!(
-                    "no def for path {}", expr.id))
+                // Special case: A unit like struct's constructor must be called without () at the
+                // end (like `UnitStruct`) which means this is an ExprPath to a DefFn. But in case
+                // of unit structs this is should not be interpreted as function pointer but as
+                // call to the constructor.
+                def::DefFn(_, true) => RvalueDpsExpr,
+
+                // Fn pointers are just scalar values.
+                def::DefFn(..) | def::DefMethod(..) => RvalueDatumExpr,
+
+                // Note: there is actually a good case to be made that
+                // DefArg's, particularly those of immediate type, ought to
+                // considered rvalues.
+                def::DefStatic(..) |
+                def::DefUpvar(..) |
+                def::DefLocal(..) => LvalueExpr,
+
+                def::DefConst(..) |
+                def::DefAssociatedConst(..) => RvalueDatumExpr,
+
+                def => {
+                    tcx.sess.span_bug(
+                        expr.span,
+                        &format!("uncategorized def for expr {}: {:?}",
+                                expr.id,
+                                def));
+                }
             }
         }
 
         ast::ExprUnary(ast::UnDeref, _) |
         ast::ExprField(..) |
         ast::ExprTupField(..) |
         ast::ExprIndex(..) => {
-            true
+            LvalueExpr
         }
 
         ast::ExprCall(..) |
@@ -5146,29 +5216,60 @@ pub fn expr_is_lval(tcx: &ctxt, expr: &ast::Expr) -> bool {
         ast::ExprClosure(..) |
         ast::ExprBlock(..) |
         ast::ExprRepeat(..) |
-        ast::ExprVec(..) |
+        ast::ExprVec(..) => {
+            RvalueDpsExpr
+        }
+
+        ast::ExprIfLet(..) => {
+            tcx.sess.span_bug(expr.span, "non-desugared ExprIfLet");
+        }
+        ast::ExprWhileLet(..) => {
+            tcx.sess.span_bug(expr.span, "non-desugared ExprWhileLet");
+        }
+
+        ast::ExprForLoop(..) => {
+            tcx.sess.span_bug(expr.span, "non-desugared ExprForLoop");
+        }
+
+        ast::ExprLit(ref lit) if lit_is_str(&**lit) => {
+            RvalueDpsExpr
+        }
+
         ast::ExprBreak(..) |
         ast::ExprAgain(..) |
         ast::ExprRet(..) |
         ast::ExprWhile(..) |
         ast::ExprLoop(..) |
         ast::ExprAssign(..) |
         ast::ExprInlineAsm(..) |
-        ast::ExprAssignOp(..) |
-        ast::ExprLit(_) |
+        ast::ExprAssignOp(..) => {
+            RvalueStmtExpr
+        }
+
+        ast::ExprLit(_) | // Note: LitStr is carved out above
         ast::ExprUnary(..) |
-        ast::ExprBox(..) |
+        ast::ExprBox(None, _) |
         ast::ExprAddrOf(..) |
         ast::ExprBinary(..) |
         ast::ExprCast(..) => {
-            false
+            RvalueDatumExpr
+        }
+
+        ast::ExprBox(Some(ref place), _) => {
+            // Special case `Box<T>` for now:
+            let def_id = match tcx.def_map.borrow().get(&place.id) {
+                Some(def) => def.def_id(),
+                None => panic!("no def for place"),
+            };
+            if tcx.lang_items.exchange_heap() == Some(def_id) {
+                RvalueDatumExpr
+            } else {
+                RvalueDpsExpr
+            }
         }
 
-        ast::ExprParen(ref e) => expr_is_lval(tcx, e),
+        ast::ExprParen(ref e) => expr_kind(tcx, &**e),
 
-        ast::ExprIfLet(..) |
-        ast::ExprWhileLet(..) |
-        ast::ExprForLoop(..) |
         ast::ExprMac(..) => {
             tcx.sess.span_bug(
                 expr.span,