Return Vec on TemplateParameters

ericho · ericho · commit 518ffd5cc464 · 2018-02-04T00:41:57.000-06:00
The Option<T> returned in this trait was removed to return Vec. Fixes rust-lang#960.
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -300,20 +300,20 @@ impl AppendImplicitTemplateParams for quote::Tokens {
             _ => {},
         }
 
-        if let Some(params) = item.used_template_params(ctx) {
-            if params.is_empty() {
-                return;
-            }
+        let params = item.used_template_params(ctx);
 
-            let params = params.into_iter().map(|p| {
-                p.try_to_rust_ty(ctx, &())
-                    .expect("template params cannot fail to be a rust type")
-            });
-
-            self.append_all(quote! {
-                < #( #params ),* >
-            });
+        if params.is_empty() {
+            return;
         }
+
+        let params = params.into_iter().map(|p| {
+            p.try_to_rust_ty(ctx, &())
+                .expect("template params cannot fail to be a rust type")
+        });
+
+        self.append_all(quote! {
+            < #( #params ),* >
+        });
     }
 }
 
@@ -481,10 +481,8 @@ impl CodeGenerator for Var {
         // number of actual variables for a single declaration are open ended
         // and we don't know what instantiations do or don't exist.
         let type_params = item.all_template_params(ctx);
-        if let Some(params) = type_params {
-            if !params.is_empty() {
-                return;
-            }
+        if !type_params.is_empty() {
+            return;
         }
 
         let ty = self.ty().to_rust_ty_or_opaque(ctx, &());
@@ -637,12 +635,10 @@ impl CodeGenerator for Type {
                     return;
                 }
 
-                let mut outer_params = item.used_template_params(ctx)
-                    .and_then(|ps| if ps.is_empty() {
-                        None
-                    } else {
-                        Some(ps)
-                    });
+                let mut outer_params = match item.used_template_params(ctx).len() {
+                    x if x > 0 => Some(item.used_template_params(ctx)),
+                    _ => None,
+                };
 
                 let inner_rust_type = if item.is_opaque(ctx, &()) {
                     outer_params = None;
@@ -1598,21 +1594,20 @@ impl CodeGenerator for CompInfo {
 
         let mut generic_param_names = vec![];
 
-        if let Some(ref params) = used_template_params {
-            for (idx, ty) in params.iter().enumerate() {
-                let param = ctx.resolve_type(*ty);
-                let name = param.name().unwrap();
-                let ident = ctx.rust_ident(name);
-                generic_param_names.push(ident.clone());
 
-                let prefix = ctx.trait_prefix();
-                let field_name = ctx.rust_ident(format!("_phantom_{}", idx));
-                fields.push(quote! {
-                    pub #field_name : ::#prefix::marker::PhantomData<
-                        ::#prefix::cell::UnsafeCell<#ident>
-                    > ,
-                });
-            }
+        for (idx, ty) in used_template_params.iter().enumerate() {
+            let param = ctx.resolve_type(*ty);
+            let name = param.name().unwrap();
+            let ident = ctx.rust_ident(name);
+            generic_param_names.push(ident.clone());
+
+            let prefix = ctx.trait_prefix();
+            let field_name = ctx.rust_ident(format!("_phantom_{}", idx));
+            fields.push(quote! {
+                pub #field_name : ::#prefix::marker::PhantomData<
+                    ::#prefix::cell::UnsafeCell<#ident>
+                > ,
+            });
         }
 
         let generics = if !generic_param_names.is_empty() {
@@ -1657,7 +1652,7 @@ impl CodeGenerator for CompInfo {
             derives.push("Copy");
 
             if ctx.options().rust_features().builtin_clone_impls() ||
-                used_template_params.is_some()
+                used_template_params.len() > 0
             {
                 // FIXME: This requires extra logic if you have a big array in a
                 // templated struct. The reason for this is that the magic:
@@ -1739,7 +1734,7 @@ impl CodeGenerator for CompInfo {
             );
         }
 
-        if used_template_params.is_none() {
+        if used_template_params.is_empty() {
             if !is_opaque {
                 for var in self.inner_vars() {
                     ctx.resolve_item(*var).codegen(ctx, result, &());
@@ -2951,7 +2946,6 @@ impl TryToRustTy for Type {
             TypeKind::TemplateAlias(..) |
             TypeKind::Alias(..) => {
                 let template_params = item.used_template_params(ctx)
-                    .unwrap_or(vec![])
                     .into_iter()
                     .filter(|param| param.is_template_param(ctx, &()))
                     .collect::<Vec<_>>();
@@ -2972,7 +2966,7 @@ impl TryToRustTy for Type {
             TypeKind::Comp(ref info) => {
                 let template_params = item.used_template_params(ctx);
                 if info.has_non_type_template_params() ||
-                    (item.is_opaque(ctx, &()) && template_params.is_some())
+                    (item.is_opaque(ctx, &()) && template_params.len() > 0)
                 {
                     return self.try_to_opaque(ctx, item);
                 }
@@ -3066,18 +3060,16 @@ impl TryToRustTy for TemplateInstantiation {
         let def_path = def.namespace_aware_canonical_path(ctx);
         ty.append_separated(def_path.into_iter().map(|p| ctx.rust_ident(p)), proc_macro2::Term::intern("::"));
 
-        let def_params = match def.self_template_params(ctx) {
-            Some(params) => params,
-            None => {
-                // This can happen if we generated an opaque type for a partial
-                // template specialization, and we've hit an instantiation of
-                // that partial specialization.
-                extra_assert!(
-                    def.is_opaque(ctx, &())
-                );
-                return Err(error::Error::InstantiationOfOpaqueType);
-            }
-        };
+        let def_params = def.self_template_params(ctx);
+        if def_params.is_empty() {
+            // This can happen if we generated an opaque type for a partial
+            // template specialization, and we've hit an instantiation of
+            // that partial specialization.
+            extra_assert!(
+                def.is_opaque(ctx, &())
+            );
+            return Err(error::Error::InstantiationOfOpaqueType);
+        }
 
         // TODO: If the definition type is a template class/struct
         // definition's member template definition, it could rely on
@@ -3171,10 +3163,8 @@ impl CodeGenerator for Function {
         // instantiations is open ended and we have no way of knowing which
         // monomorphizations actually exist.
         let type_params = item.all_template_params(ctx);
-        if let Some(params) = type_params {
-            if !params.is_empty() {
-                return;
-            }
+        if !type_params.is_empty() {
+            return;
         }
 
         let name = self.name();
diff --git a/src/ir/analysis/derive_copy.rs b/src/ir/analysis/derive_copy.rs
@@ -246,8 +246,8 @@ impl<'ctx> MonotoneFramework for CannotDeriveCopy<'ctx> {
                     }
 
                     // https://github.com/rust-lang/rust/issues/36640
-                    if info.self_template_params(self.ctx).is_some() ||
-                        item.used_template_params(self.ctx).is_some()
+                    if !info.self_template_params(self.ctx).is_empty() ||
+                        !item.used_template_params(self.ctx).is_empty()
                     {
                         trace!(
                             "    comp cannot derive copy because issue 36640"
diff --git a/src/ir/analysis/template_params.rs b/src/ir/analysis/template_params.rs
@@ -275,7 +275,7 @@ impl<'ctx> UsedTemplateParameters<'ctx> {
         let decl = self.ctx.resolve_type(instantiation.template_definition());
         let args = instantiation.template_arguments();
 
-        let params = decl.self_template_params(self.ctx).unwrap_or(vec![]);
+        let params = decl.self_template_params(self.ctx);
 
         debug_assert!(this_id != instantiation.template_definition());
         let used_by_def = self.used
@@ -418,8 +418,7 @@ impl<'ctx> MonotoneFramework for UsedTemplateParameters<'ctx> {
                     // Although template definitions should always have
                     // template parameters, there is a single exception:
                     // opaque templates. Hence the unwrap_or.
-                    let params =
-                        decl.self_template_params(ctx).unwrap_or(vec![]);
+                    let params = decl.self_template_params(ctx);
 
                     for (arg, param) in args.iter().zip(params.iter()) {
                         let arg = arg.into_resolver()
diff --git a/src/ir/comp.rs b/src/ir/comp.rs
@@ -1668,12 +1668,8 @@ impl TemplateParameters for CompInfo {
     fn self_template_params(
         &self,
         _ctx: &BindgenContext,
-    ) -> Option<Vec<TypeId>> {
-        if self.template_params.is_empty() {
-            None
-        } else {
-            Some(self.template_params.clone())
-        }
+    ) -> Vec<TypeId> {
+        self.template_params.clone()
     }
 }
 
@@ -1684,7 +1680,7 @@ impl Trace for CompInfo {
     where
         T: Tracer,
     {
-        let params = item.all_template_params(context).unwrap_or(vec![]);
+        let params = item.all_template_params(context);
         for p in params {
             tracer.visit_kind(p.into(), EdgeKind::TemplateParameterDefinition);
         }
diff --git a/src/ir/context.rs b/src/ir/context.rs
@@ -1342,10 +1342,8 @@ impl BindgenContext {
             let mut used_params = HashMap::new();
             for &id in self.whitelisted_items() {
                 used_params.entry(id).or_insert(
-                    id.self_template_params(self).map_or(
-                        Default::default(),
-                        |params| params.into_iter().map(|p| p.into()).collect(),
-                    ),
+                    id.self_template_params(self)
+                        .into_iter().map(|p| p.into()).collect()
                 );
             }
             self.used_template_parameters = Some(used_params);
@@ -1528,15 +1526,11 @@ impl BindgenContext {
             .and_then(|canon_decl| {
                 self.get_resolved_type(&canon_decl).and_then(
                     |template_decl_id| {
-                        template_decl_id.num_self_template_params(self).map(
-                            |num_params| {
-                                (
-                                    *canon_decl.cursor(),
-                                    template_decl_id.into(),
-                                    num_params,
-                                )
-                            },
-                        )
+                        Some((
+                            *canon_decl.cursor(),
+                            template_decl_id.into(),
+                            template_decl_id.num_self_template_params(self),
+                        ))
                     },
                 )
             })
@@ -1557,15 +1551,20 @@ impl BindgenContext {
                             .cloned()
                     })
                     .and_then(|template_decl| {
-                        template_decl.num_self_template_params(self).map(
-                            |num_template_params| {
-                                (
-                                    *template_decl.decl(),
-                                    template_decl.id(),
-                                    num_template_params,
-                                )
-                            },
-                        )
+                        Some((
+                            *template_decl.decl(),
+                            template_decl.id(),
+                            template_decl.num_self_template_params(self),
+                        ))
+                        // template_decl.num_self_template_params(self).map(
+                        //     |num_template_params| {
+                        //         (
+                        //             *template_decl.decl(),
+                        //             template_decl.id(),
+                        //             num_template_params,
+                        //         )
+                        //     },
+                        // )
                     })
             })
     }
@@ -1614,8 +1613,8 @@ impl BindgenContext {
 
         let num_expected_args = match self.resolve_type(template)
             .num_self_template_params(self) {
-            Some(n) => n,
-            None => {
+            n if n > 0 => n,
+            _ => {
                 warn!(
                     "Tried to instantiate a template for which we could not \
                        determine any template parameters"
@@ -2622,13 +2621,13 @@ impl TemplateParameters for PartialType {
     fn self_template_params(
         &self,
         _ctx: &BindgenContext,
-    ) -> Option<Vec<TypeId>> {
+    ) -> Vec<TypeId> {
         // Maybe at some point we will eagerly parse named types, but for now we
         // don't and this information is unavailable.
-        None
+        vec![]
     }
 
-    fn num_self_template_params(&self, _ctx: &BindgenContext) -> Option<usize> {
+    fn num_self_template_params(&self, _ctx: &BindgenContext) -> usize {
         // Wouldn't it be nice if libclang would reliably give us this
         // information‽
         match self.decl().kind() {
@@ -2647,9 +2646,9 @@ impl TemplateParameters for PartialType {
                     };
                     clang_sys::CXChildVisit_Continue
                 });
-                Some(num_params)
+                num_params
             }
-            _ => None,
+            _ => 0,
         }
     }
 }
diff --git a/src/ir/item.rs b/src/ir/item.rs
@@ -1112,18 +1112,18 @@ where
     fn self_template_params(
         &self,
         ctx: &BindgenContext,
-    ) -> Option<Vec<TypeId>> {
+    ) -> Vec<TypeId> {
         ctx.resolve_item_fallible(*self).and_then(|item| {
-            item.self_template_params(ctx)
-        })
+            Some(item.self_template_params(ctx))
+        }).unwrap_or(vec![])
     }
 }
 
 impl TemplateParameters for Item {
     fn self_template_params(
         &self,
         ctx: &BindgenContext,
-    ) -> Option<Vec<TypeId>> {
+    ) -> Vec<TypeId> {
         self.kind.self_template_params(ctx)
     }
 }
@@ -1132,15 +1132,15 @@ impl TemplateParameters for ItemKind {
     fn self_template_params(
         &self,
         ctx: &BindgenContext,
-    ) -> Option<Vec<TypeId>> {
+    ) -> Vec<TypeId> {
         match *self {
             ItemKind::Type(ref ty) => ty.self_template_params(ctx),
             // If we start emitting bindings to explicitly instantiated
             // functions, then we'll need to check ItemKind::Function for
             // template params.
             ItemKind::Function(_) |
             ItemKind::Module(_) |
-            ItemKind::Var(_) => None,
+            ItemKind::Var(_) => vec![],
         }
     }
 }
diff --git a/src/ir/template.rs b/src/ir/template.rs
diff --git a/src/ir/ty.rs b/src/ir/ty.rs

Original file line number	Diff line number	Diff line change
`@@ -246,8 +246,8 @@ impl<'ctx> MonotoneFramework for CannotDeriveCopy<'ctx> {`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`// https://github.com/rust-lang/rust/issues/36640`
`249`		`- if info.self_template_params(self.ctx).is_some() \|\|`
`250`		`- item.used_template_params(self.ctx).is_some()`
	`249`	`+ if !info.self_template_params(self.ctx).is_empty() \|\|`
	`250`	`+ !item.used_template_params(self.ctx).is_empty()`
`251`	`251`	`{`
`252`	`252`	`trace!(`
`253`	`253`	`" comp cannot derive copy because issue 36640"`
Original file line number	Diff line number	Diff line change
`@@ -1668,12 +1668,8 @@ impl TemplateParameters for CompInfo {`
`1668`	`1668`	`fn self_template_params(`
`1669`	`1669`	`&self,`
`1670`	`1670`	`_ctx: &BindgenContext,`
`1671`		`- ) -> Option<Vec<TypeId>> {`
`1672`		`- if self.template_params.is_empty() {`
`1673`		`- None`
`1674`		`- } else {`
`1675`		`- Some(self.template_params.clone())`
`1676`		`- }`
	`1671`	`+ ) -> Vec<TypeId> {`
	`1672`	`+ self.template_params.clone()`
`1677`	`1673`	`}`
`1678`	`1674`	`}`
`1679`	`1675`
`@@ -1684,7 +1680,7 @@ impl Trace for CompInfo {`
`1684`	`1680`	`where`
`1685`	`1681`	`T: Tracer,`
`1686`	`1682`	`{`
`1687`		`- let params = item.all_template_params(context).unwrap_or(vec![]);`
	`1683`	`+ let params = item.all_template_params(context);`
`1688`	`1684`	`for p in params {`
`1689`	`1685`	`tracer.visit_kind(p.into(), EdgeKind::TemplateParameterDefinition);`
`1690`	`1686`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1112,18 +1112,18 @@ where`
`1112`	`1112`	`fn self_template_params(`
`1113`	`1113`	`&self,`
`1114`	`1114`	`ctx: &BindgenContext,`
`1115`		`- ) -> Option<Vec<TypeId>> {`
	`1115`	`+ ) -> Vec<TypeId> {`
`1116`	`1116`	`ctx.resolve_item_fallible(*self).and_then(\|item\| {`
`1117`		`- item.self_template_params(ctx)`
`1118`		`- })`
	`1117`	`+ Some(item.self_template_params(ctx))`
	`1118`	`+ }).unwrap_or(vec![])`
`1119`	`1119`	`}`
`1120`	`1120`	`}`
`1121`	`1121`
`1122`	`1122`	`impl TemplateParameters for Item {`
`1123`	`1123`	`fn self_template_params(`
`1124`	`1124`	`&self,`
`1125`	`1125`	`ctx: &BindgenContext,`
`1126`		`- ) -> Option<Vec<TypeId>> {`
	`1126`	`+ ) -> Vec<TypeId> {`
`1127`	`1127`	`self.kind.self_template_params(ctx)`
`1128`	`1128`	`}`
`1129`	`1129`	`}`
`@@ -1132,15 +1132,15 @@ impl TemplateParameters for ItemKind {`
`1132`	`1132`	`fn self_template_params(`
`1133`	`1133`	`&self,`
`1134`	`1134`	`ctx: &BindgenContext,`
`1135`		`- ) -> Option<Vec<TypeId>> {`
	`1135`	`+ ) -> Vec<TypeId> {`
`1136`	`1136`	`match *self {`
`1137`	`1137`	`ItemKind::Type(ref ty) => ty.self_template_params(ctx),`
`1138`	`1138`	`// If we start emitting bindings to explicitly instantiated`
`1139`	`1139`	`// functions, then we'll need to check ItemKind::Function for`
`1140`	`1140`	`// template params.`
`1141`	`1141`	`ItemKind::Function(_) \|`
`1142`	`1142`	`ItemKind::Module(_) \|`
`1143`		`- ItemKind::Var(_) => None,`
	`1143`	`+ ItemKind::Var(_) => vec![],`
`1144`	`1144`	`}`
`1145`	`1145`	`}`
`1146`	`1146`	`}`