rustc_mir: use Local instead of Lvalue in Storage{Live,Dead}.

eddyb · eddyb · commit e74f96e43fc1 · 2017-09-04T08:01:46.000+03:00
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
@@ -901,10 +901,10 @@ pub enum StatementKind<'tcx> {
     SetDiscriminant { lvalue: Lvalue<'tcx>, variant_index: usize },
 
     /// Start a live range for the storage of the local.
-    StorageLive(Lvalue<'tcx>),
+    StorageLive(Local),
 
     /// End the current live range for the storage of the local.
-    StorageDead(Lvalue<'tcx>),
+    StorageDead(Local),
 
     /// Execute a piece of inline Assembly.
     InlineAsm {
@@ -1701,8 +1701,8 @@ impl<'tcx> TypeFoldable<'tcx> for Statement<'tcx> {
                 lvalue: lvalue.fold_with(folder),
                 variant_index,
             },
-            StorageLive(ref lval) => StorageLive(lval.fold_with(folder)),
-            StorageDead(ref lval) => StorageDead(lval.fold_with(folder)),
+            StorageLive(ref local) => StorageLive(local.fold_with(folder)),
+            StorageDead(ref local) => StorageDead(local.fold_with(folder)),
             InlineAsm { ref asm, ref outputs, ref inputs } => InlineAsm {
                 asm: asm.clone(),
                 outputs: outputs.fold_with(folder),
@@ -1732,9 +1732,9 @@ impl<'tcx> TypeFoldable<'tcx> for Statement<'tcx> {
 
         match self.kind {
             Assign(ref lval, ref rval) => { lval.visit_with(visitor) || rval.visit_with(visitor) }
-            SetDiscriminant { ref lvalue, .. } |
-            StorageLive(ref lvalue) |
-            StorageDead(ref lvalue) => lvalue.visit_with(visitor),
+            SetDiscriminant { ref lvalue, .. } => lvalue.visit_with(visitor),
+            StorageLive(ref local) |
+            StorageDead(ref local) => local.visit_with(visitor),
             InlineAsm { ref outputs, ref inputs, .. } =>
                 outputs.visit_with(visitor) || inputs.visit_with(visitor),
 
diff --git a/src/librustc/mir/visit.rs b/src/librustc/mir/visit.rs
@@ -360,11 +360,11 @@ macro_rules! make_mir_visitor {
                     StatementKind::SetDiscriminant{ ref $($mutability)* lvalue, .. } => {
                         self.visit_lvalue(lvalue, LvalueContext::Store, location);
                     }
-                    StatementKind::StorageLive(ref $($mutability)* lvalue) => {
-                        self.visit_lvalue(lvalue, LvalueContext::StorageLive, location);
+                    StatementKind::StorageLive(ref $($mutability)* local) => {
+                        self.visit_local(local, LvalueContext::StorageLive, location);
                     }
-                    StatementKind::StorageDead(ref $($mutability)* lvalue) => {
-                        self.visit_lvalue(lvalue, LvalueContext::StorageDead, location);
+                    StatementKind::StorageDead(ref $($mutability)* local) => {
+                        self.visit_local(local, LvalueContext::StorageDead, location);
                     }
                     StatementKind::InlineAsm { ref $($mutability)* outputs,
                                                ref $($mutability)* inputs,
diff --git a/src/librustc_mir/borrow_check.rs b/src/librustc_mir/borrow_check.rs
@@ -212,11 +212,11 @@ impl<'c, 'b, 'a: 'b+'c, 'gcx, 'tcx: 'a> DataflowResultsConsumer<'b, 'gcx>
                 // ignored by borrowck
             }
 
-            StatementKind::StorageDead(ref lvalue) => {
+            StatementKind::StorageDead(local) => {
                 // causes non-drop values to be dropped.
                 self.consume_lvalue(ContextKind::StorageDead.new(location),
                                     ConsumeKind::Consume,
-                                    (lvalue, span),
+                                    (&Lvalue::Local(local), span),
                                     flow_state)
             }
         }
diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs
@@ -96,23 +96,23 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             }
             ExprKind::Box { value } => {
                 let value = this.hir.mirror(value);
-                let result = this.temp(expr.ty, expr_span);
+                let result = this.local_decls.push(LocalDecl::new_temp(expr.ty, expr_span));
                 this.cfg.push(block, Statement {
                     source_info,
-                    kind: StatementKind::StorageLive(result.clone())
+                    kind: StatementKind::StorageLive(result)
                 });
                 if let Some(scope) = scope {
                     // schedule a shallow free of that memory, lest we unwind:
-                    this.schedule_drop(expr_span, scope, &result, value.ty);
+                    this.schedule_drop(expr_span, scope, &Lvalue::Local(result), value.ty);
                 }
 
                 // malloc some memory of suitable type (thus far, uninitialized):
                 let box_ = Rvalue::NullaryOp(NullOp::Box, value.ty);
-                this.cfg.push_assign(block, source_info, &result, box_);
+                this.cfg.push_assign(block, source_info, &Lvalue::Local(result), box_);
 
                 // initialize the box contents:
-                unpack!(block = this.into(&result.clone().deref(), block, value));
-                block.and(Rvalue::Use(Operand::Consume(result)))
+                unpack!(block = this.into(&Lvalue::Local(result).deref(), block, value));
+                block.and(Rvalue::Use(Operand::Consume(Lvalue::Local(result))))
             }
             ExprKind::Cast { source } => {
                 let source = this.hir.mirror(source);
diff --git a/src/librustc_mir/build/expr/as_temp.rs b/src/librustc_mir/build/expr/as_temp.rs
@@ -53,7 +53,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         if !expr_ty.is_never() {
             this.cfg.push(block, Statement {
                 source_info,
-                kind: StatementKind::StorageLive(Lvalue::Local(temp))
+                kind: StatementKind::StorageLive(temp)
             });
         }
 
diff --git a/src/librustc_mir/build/matches/mod.rs b/src/librustc_mir/build/matches/mod.rs
@@ -194,7 +194,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         let source_info = self.source_info(span);
         self.cfg.push(block, Statement {
             source_info,
-            kind: StatementKind::StorageLive(Lvalue::Local(local_id))
+            kind: StatementKind::StorageLive(local_id)
         });
         Lvalue::Local(local_id)
     }
diff --git a/src/librustc_mir/build/scope.rs b/src/librustc_mir/build/scope.rs
@@ -822,7 +822,7 @@ fn build_scope_drops<'tcx>(cfg: &mut CFG<'tcx>,
             Lvalue::Local(index) if index.index() > arg_count => {
                 cfg.push(block, Statement {
                     source_info,
-                    kind: StatementKind::StorageDead(drop_data.location.clone())
+                    kind: StatementKind::StorageDead(index)
                 });
             }
             _ => continue
diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs
@@ -213,12 +213,8 @@ impl<'a, 'tcx> MutVisitor<'tcx> for TransformVisitor<'a, 'tcx> {
         // Remove StorageLive and StorageDead statements for remapped locals
         data.retain_statements(|s| {
             match s.kind {
-                StatementKind::StorageLive(ref l) | StatementKind::StorageDead(ref l) => {
-                    if let Lvalue::Local(l) = *l {
-                        !self.remap.contains_key(&l)
-                    } else {
-                        true
-                    }
+                StatementKind::StorageLive(l) | StatementKind::StorageDead(l) => {
+                    !self.remap.contains_key(&l)
                 }
                 _ => true
             }
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
@@ -406,8 +406,8 @@ pub fn promote_candidates<'a, 'tcx>(mir: &mut Mir<'tcx>,
         block.statements.retain(|statement| {
             match statement.kind {
                 StatementKind::Assign(Lvalue::Local(index), _) |
-                StatementKind::StorageLive(Lvalue::Local(index)) |
-                StatementKind::StorageDead(Lvalue::Local(index)) => {
+                StatementKind::StorageLive(index) |
+                StatementKind::StorageDead(index) => {
                     !promoted(index)
                 }
                 _ => true
diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
@@ -1108,7 +1108,7 @@ impl MirPass for QualifyAndPromoteConstants {
             for block in mir.basic_blocks_mut() {
                 block.statements.retain(|statement| {
                     match statement.kind {
-                        StatementKind::StorageDead(Lvalue::Local(index)) => {
+                        StatementKind::StorageDead(index) => {
                             !promoted_temps.contains(&index)
                         }
                         _ => true
diff --git a/src/librustc_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs
@@ -369,11 +369,8 @@ impl<'tcx> MutVisitor<'tcx> for LocalUpdater {
         // Remove unnecessary StorageLive and StorageDead annotations.
         data.statements.retain(|stmt| {
             match stmt.kind {
-                StatementKind::StorageLive(ref lval) | StatementKind::StorageDead(ref lval) => {
-                    match *lval {
-                        Lvalue::Local(l) => self.map[l.index()] != !0,
-                        _ => true
-                    }
+                StatementKind::StorageLive(l) | StatementKind::StorageDead(l) => {
+                    self.map[l.index()] != !0
                 }
                 _ => true
             }
diff --git a/src/librustc_mir/transform/type_check.rs b/src/librustc_mir/transform/type_check.rs
@@ -420,15 +420,8 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                                variant_index);
                 };
             }
-            StatementKind::StorageLive(ref lv) |
-            StatementKind::StorageDead(ref lv) => {
-                match *lv {
-                    Lvalue::Local(_) => {}
-                    _ => {
-                        span_mirbug!(self, stmt, "bad lvalue: expected local");
-                    }
-                }
-            }
+            StatementKind::StorageLive(_) |
+            StatementKind::StorageDead(_) |
             StatementKind::InlineAsm { .. } |
             StatementKind::EndRegion(_) |
             StatementKind::Validate(..) |
diff --git a/src/librustc_trans/mir/statement.rs b/src/librustc_trans/mir/statement.rs
@@ -67,11 +67,11 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                     variant_index as u64);
                 bcx
             }
-            mir::StatementKind::StorageLive(ref lvalue) => {
-                self.trans_storage_liveness(bcx, lvalue, base::Lifetime::Start)
+            mir::StatementKind::StorageLive(local) => {
+                self.trans_storage_liveness(bcx, local, base::Lifetime::Start)
             }
-            mir::StatementKind::StorageDead(ref lvalue) => {
-                self.trans_storage_liveness(bcx, lvalue, base::Lifetime::End)
+            mir::StatementKind::StorageDead(local) => {
+                self.trans_storage_liveness(bcx, local, base::Lifetime::End)
             }
             mir::StatementKind::InlineAsm { ref asm, ref outputs, ref inputs } => {
                 let outputs = outputs.iter().map(|output| {
@@ -94,13 +94,11 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
 
     fn trans_storage_liveness(&self,
                               bcx: Builder<'a, 'tcx>,
-                              lvalue: &mir::Lvalue<'tcx>,
+                              index: mir::Local,
                               intrinsic: base::Lifetime)
                               -> Builder<'a, 'tcx> {
-        if let mir::Lvalue::Local(index) = *lvalue {
-            if let LocalRef::Lvalue(tr_lval) = self.locals[index] {
-                intrinsic.call(&bcx, tr_lval.llval);
-            }
+        if let LocalRef::Lvalue(tr_lval) = self.locals[index] {
+            intrinsic.call(&bcx, tr_lval.llval);
         }
         bcx
     }

Original file line number	Diff line number	Diff line change
`@@ -360,11 +360,11 @@ macro_rules! make_mir_visitor {`
`360`	`360`	`StatementKind::SetDiscriminant{ ref $($mutability)* lvalue, .. } => {`
`361`	`361`	`self.visit_lvalue(lvalue, LvalueContext::Store, location);`
`362`	`362`	`}`
`363`		`- StatementKind::StorageLive(ref $($mutability)* lvalue) => {`
`364`		`- self.visit_lvalue(lvalue, LvalueContext::StorageLive, location);`
	`363`	`+ StatementKind::StorageLive(ref $($mutability)* local) => {`
	`364`	`+ self.visit_local(local, LvalueContext::StorageLive, location);`
`365`	`365`	`}`
`366`		`- StatementKind::StorageDead(ref $($mutability)* lvalue) => {`
`367`		`- self.visit_lvalue(lvalue, LvalueContext::StorageDead, location);`
	`366`	`+ StatementKind::StorageDead(ref $($mutability)* local) => {`
	`367`	`+ self.visit_local(local, LvalueContext::StorageDead, location);`
`368`	`368`	`}`
`369`	`369`	`StatementKind::InlineAsm { ref $($mutability)* outputs,`
`370`	`370`	`ref $($mutability)* inputs,`
Original file line number	Diff line number	Diff line change
`@@ -212,11 +212,11 @@ impl<'c, 'b, 'a: 'b+'c, 'gcx, 'tcx: 'a> DataflowResultsConsumer<'b, 'gcx>`
`212`	`212`	`// ignored by borrowck`
`213`	`213`	`}`
`214`	`214`
`215`		`- StatementKind::StorageDead(ref lvalue) => {`
	`215`	`+ StatementKind::StorageDead(local) => {`
`216`	`216`	`// causes non-drop values to be dropped.`
`217`	`217`	`self.consume_lvalue(ContextKind::StorageDead.new(location),`
`218`	`218`	`ConsumeKind::Consume,`
`219`		`- (lvalue, span),`
	`219`	`+ (&Lvalue::Local(local), span),`
`220`	`220`	`flow_state)`
`221`	`221`	`}`
`222`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {`
`53`	`53`	`if !expr_ty.is_never() {`
`54`	`54`	`this.cfg.push(block, Statement {`
`55`	`55`	`source_info,`
`56`		`- kind: StatementKind::StorageLive(Lvalue::Local(temp))`
	`56`	`+ kind: StatementKind::StorageLive(temp)`
`57`	`57`	`});`
`58`	`58`	`}`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {`
`194`	`194`	`let source_info = self.source_info(span);`
`195`	`195`	`self.cfg.push(block, Statement {`
`196`	`196`	`source_info,`
`197`		`- kind: StatementKind::StorageLive(Lvalue::Local(local_id))`
	`197`	`+ kind: StatementKind::StorageLive(local_id)`
`198`	`198`	`});`
`199`	`199`	`Lvalue::Local(local_id)`
`200`	`200`	`}`
Original file line number	Diff line number	Diff line change
`@@ -822,7 +822,7 @@ fn build_scope_drops<'tcx>(cfg: &mut CFG<'tcx>,`
`822`	`822`	`Lvalue::Local(index) if index.index() > arg_count => {`
`823`	`823`	`cfg.push(block, Statement {`
`824`	`824`	`source_info,`
`825`		`- kind: StatementKind::StorageDead(drop_data.location.clone())`
	`825`	`+ kind: StatementKind::StorageDead(index)`
`826`	`826`	`});`
`827`	`827`	`}`
`828`	`828`	`_ => continue`
Original file line number	Diff line number	Diff line change
`@@ -1108,7 +1108,7 @@ impl MirPass for QualifyAndPromoteConstants {`
`1108`	`1108`	`for block in mir.basic_blocks_mut() {`
`1109`	`1109`	`block.statements.retain(\|statement\| {`
`1110`	`1110`	`match statement.kind {`
`1111`		`- StatementKind::StorageDead(Lvalue::Local(index)) => {`
	`1111`	`+ StatementKind::StorageDead(index) => {`
`1112`	`1112`	`!promoted_temps.contains(&index)`
`1113`	`1113`	`}`
`1114`	`1114`	`_ => true`