rustc_typeck: force users of RegionScope to get anon_region's one by one.

diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index 1af8b59cdfa7d7ab6dc3db7b722d395fe89320d9..166178d6c29c1ef9c66258ffcda0d97b9b7e67ff 100644 (file)
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -306,9 +306,8 @@ pub fn opt_ast_region_to_region(&self,
                 ast_region_to_region(self.tcx(), lifetime)
             }
 
                 ast_region_to_region(self.tcx(), lifetime)
             }
 

-            None => self.tcx().mk_region(match rscope.anon_regions(default_span, 1) {
-                Ok(rs) => rs[0],
-                Err(params) => {
+            None => {
+                self.tcx().mk_region(rscope.anon_region(default_span).unwrap_or_else(|params| {

                     let ampersand_span = Span { hi: default_span.lo, ..default_span};
 
                     let mut err = struct_span_err!(self.tcx().sess, ampersand_span, E0106,
                     let ampersand_span = Span { hi: default_span.lo, ..default_span};
 
                     let mut err = struct_span_err!(self.tcx().sess, ampersand_span, E0106,


@@ -320,8 +319,8 @@ pub fn opt_ast_region_to_region(&self,
                     }
                     err.emit();
                     ty::ReStatic
                     }
                     err.emit();
                     ty::ReStatic

-                }
-            })
+                }))
+            }

         };
 
         debug!("opt_ast_region_to_region(opt_lifetime={:?}) yields {:?}",
         };
 
         debug!("opt_ast_region_to_region(opt_lifetime={:?}) yields {:?}",


@@ -412,8 +411,9 @@ fn create_substs_for_ast_path(&self,
         let regions = if expected_num_region_params == supplied_num_region_params {
             lifetimes.iter().map(|l| *ast_region_to_region(tcx, l)).collect()
         } else {
         let regions = if expected_num_region_params == supplied_num_region_params {
             lifetimes.iter().map(|l| *ast_region_to_region(tcx, l)).collect()
         } else {

-            let anon_regions =
-                rscope.anon_regions(span, expected_num_region_params);
+            let anon_regions = (0..expected_num_region_params).map(|_| {
+                rscope.anon_region(span)
+            }).collect::<Result<Vec<_>, _>>();

 
             if supplied_num_region_params != 0 || anon_regions.is_err() {
                 report_lifetime_number_error(tcx, span,
 
             if supplied_num_region_params != 0 || anon_regions.is_err() {
                 report_lifetime_number_error(tcx, span,

diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 20c4f8f95224d1328baccd522949a04267a9abaf..1e76267f32c3811148aaf565f690da082bc5276b 100644 (file)
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -1466,11 +1466,9 @@ fn base_object_lifetime_default(&self, span: Span) -> ty::Region {
         *self.next_region_var(infer::MiscVariable(span))
     }
 
         *self.next_region_var(infer::MiscVariable(span))
     }
 

-    fn anon_regions(&self, span: Span, count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>> {
-        Ok((0..count).map(|_| {
-            *self.next_region_var(infer::MiscVariable(span))
-        }).collect())
+    fn anon_region(&self, span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>> {
+        Ok(*self.next_region_var(infer::MiscVariable(span)))

     }
 }
 
     }
 }
 

diff --git a/src/librustc_typeck/rscope.rs b/src/librustc_typeck/rscope.rs
index 3f5e443a20a6854b575a7a57fdf197102483da43..839eb8be9ace8c093ccaa115e4a174acab0e0fc4 100644 (file)
--- a/src/librustc_typeck/rscope.rs
+++ b/src/librustc_typeck/rscope.rs
@@ -33,18 +33,16 @@ pub struct ElisionFailureInfo {
 /// Defines strategies for handling regions that are omitted.  For
 /// example, if one writes the type `&Foo`, then the lifetime of
 /// this reference has been omitted. When converting this
 /// Defines strategies for handling regions that are omitted.  For
 /// example, if one writes the type `&Foo`, then the lifetime of
 /// this reference has been omitted. When converting this

-/// type, the generic functions in astconv will invoke `anon_regions`
+/// type, the generic functions in astconv will invoke `anon_region`

 /// on the provided region-scope to decide how to translate this
 /// omitted region.
 ///
 /// on the provided region-scope to decide how to translate this
 /// omitted region.
 ///

-/// It is not always legal to omit regions, therefore `anon_regions`
+/// It is not always legal to omit regions, therefore `anon_region`

 /// can return `Err(())` to indicate that this is not a scope in which
 /// regions can legally be omitted.
 pub trait RegionScope {
 /// can return `Err(())` to indicate that this is not a scope in which
 /// regions can legally be omitted.
 pub trait RegionScope {

-    fn anon_regions(&self,
-                    span: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>>;
+    fn anon_region(&self, span: Span)
+                    -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>>;

 
     /// If an object omits any explicit lifetime bound, and none can
     /// be derived from the object traits, what should we use? If
 
     /// If an object omits any explicit lifetime bound, and none can
     /// be derived from the object traits, what should we use? If


@@ -117,11 +115,9 @@ fn object_lifetime_default(&self, span: Span) -> Option<ty::Region> {
         self.base_scope.object_lifetime_default(span)
     }
 
         self.base_scope.object_lifetime_default(span)
     }
 

-    fn anon_regions(&self,
-                    span: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>> {
-        self.base_scope.anon_regions(span, count)
+    fn anon_region(&self, span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>> {
+        self.base_scope.anon_region(span)

     }
 
     fn base_object_lifetime_default(&self, span: Span) -> ty::Region {
     }
 
     fn base_object_lifetime_default(&self, span: Span) -> ty::Region {


@@ -139,10 +135,8 @@ fn anon_type_scope(&self) -> Option<AnonTypeScope> {
 pub struct ExplicitRscope;
 
 impl RegionScope for ExplicitRscope {
 pub struct ExplicitRscope;
 
 impl RegionScope for ExplicitRscope {

-    fn anon_regions(&self,
-                    _span: Span,
-                    _count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>> {
+    fn anon_region(&self, _span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>> {

         Err(None)
     }
 
         Err(None)
     }
 


@@ -165,12 +159,9 @@ pub fn new(v: Option<Vec<ElisionFailureInfo>>) -> UnelidableRscope {
 }
 
 impl RegionScope for UnelidableRscope {
 }
 
 impl RegionScope for UnelidableRscope {

-    fn anon_regions(&self,
-                    _span: Span,
-                    _count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>> {
-        let UnelidableRscope(ref v) = *self;
-        Err(v.clone())
+    fn anon_region(&self, _span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>> {
+        Err(self.0.clone())

     }
 
     fn object_lifetime_default(&self, span: Span) -> Option<ty::Region> {
     }
 
     fn object_lifetime_default(&self, span: Span) -> Option<ty::Region> {


@@ -208,12 +199,10 @@ fn base_object_lifetime_default(&self, _span: Span) -> ty::Region {
         ty::ReStatic
     }
 
         ty::ReStatic
     }
 

-    fn anon_regions(&self,
-                    _span: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>>
+    fn anon_region(&self, _span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>>

     {
     {

-        Ok(vec![self.default; count])
+        Ok(self.default)

     }
 }
 
     }
 }
 


@@ -232,10 +221,8 @@ pub fn new(tcx: &'a ty::TyCtxt<'a, 'gcx, 'tcx>) -> Self {
 }
 
 impl<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> RegionScope for StaticRscope<'a, 'gcx, 'tcx> {
 }
 
 impl<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> RegionScope for StaticRscope<'a, 'gcx, 'tcx> {

-    fn anon_regions(&self,
-                    span: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>> {
+    fn anon_region(&self, span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>> {

         if !self.tcx.sess.features.borrow().static_in_const {
             self.tcx
                 .sess
         if !self.tcx.sess.features.borrow().static_in_const {
             self.tcx
                 .sess


@@ -244,7 +231,7 @@ fn anon_regions(&self,
                                  `static_in_const` feature, see #35897")
                 .emit();
         }
                                  `static_in_const` feature, see #35897")
                 .emit();
         }

-        Ok(vec![ty::ReStatic; count])
+        Ok(ty::ReStatic)

     }
 
     fn object_lifetime_default(&self, span: Span) -> Option<ty::Region> {
     }
 
     fn object_lifetime_default(&self, span: Span) -> Option<ty::Region> {


@@ -268,12 +255,6 @@ pub fn new() -> BindingRscope {
             anon_bindings: Cell::new(0),
         }
     }
             anon_bindings: Cell::new(0),
         }
     }

-
-    fn next_region(&self) -> ty::Region {
-        let idx = self.anon_bindings.get();
-        self.anon_bindings.set(idx + 1);
-        ty::ReLateBound(ty::DebruijnIndex::new(1), ty::BrAnon(idx))
-    }

 }
 
 impl RegionScope for BindingRscope {
 }
 
 impl RegionScope for BindingRscope {


@@ -288,12 +269,12 @@ fn base_object_lifetime_default(&self, _span: Span) -> ty::Region {
         ty::ReStatic
     }
 
         ty::ReStatic
     }
 

-    fn anon_regions(&self,
-                    _: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>>
+    fn anon_region(&self, _: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>>

     {
     {

-        Ok((0..count).map(|_| self.next_region()).collect())
+        let idx = self.anon_bindings.get();
+        self.anon_bindings.set(idx + 1);
+        Ok(ty::ReLateBound(ty::DebruijnIndex::new(1), ty::BrAnon(idx)))

     }
 }
 
     }
 }
 


@@ -334,12 +315,10 @@ fn base_object_lifetime_default(&self, span: Span) -> ty::Region {
         self.base_scope.base_object_lifetime_default(span)
     }
 
         self.base_scope.base_object_lifetime_default(span)
     }
 

-    fn anon_regions(&self,
-                    span: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>>
+    fn anon_region(&self, span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>>

     {
     {

-        self.base_scope.anon_regions(span, count)
+        self.base_scope.anon_region(span)

     }
 
     fn anon_type_scope(&self) -> Option<AnonTypeScope> {
     }
 
     fn anon_type_scope(&self) -> Option<AnonTypeScope> {


@@ -369,22 +348,10 @@ fn base_object_lifetime_default(&self, span: Span) -> ty::Region {
         ty::fold::shift_region(self.base_scope.base_object_lifetime_default(span), 1)
     }
 
         ty::fold::shift_region(self.base_scope.base_object_lifetime_default(span), 1)
     }
 

-    fn anon_regions(&self,
-                    span: Span,
-                    count: usize)
-                    -> Result<Vec<ty::Region>, Option<Vec<ElisionFailureInfo>>>
+    fn anon_region(&self, span: Span)
+                   -> Result<ty::Region, Option<Vec<ElisionFailureInfo>>>

     {
     {

-        match self.base_scope.anon_regions(span, count) {
-            Ok(mut v) => {
-                for r in &mut v {
-                    *r = ty::fold::shift_region(*r, 1);
-                }
-                Ok(v)
-            }
-            Err(errs) => {
-                Err(errs)
-            }
-        }
+        self.base_scope.anon_region(span).map(|r| ty::fold::shift_region(r, 1))

     }
 
     fn anon_type_scope(&self) -> Option<AnonTypeScope> {
     }
 
     fn anon_type_scope(&self) -> Option<AnonTypeScope> {