Elide most 'a lifetimes

components/layout/block.rs

@@ -696,7 +696,7 @@ impl BlockFlow {
     }
 
     /// Return this flow's fragment.
-    pub fn fragment<'a>(&'a mut self) -> &'a mut Fragment {
+    pub fn fragment(&mut self) -> &mut Fragment {
         &mut self.fragment
     }
 
@@ -1624,11 +1624,11 @@ impl Flow for BlockFlow {
         FlowClass::Block
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         self
     }
 
-    fn as_block<'a>(&'a self) -> &'a BlockFlow {
+    fn as_block(&self) -> &BlockFlow {
         self
     }
 

components/layout/css/matching.rs

@@ -348,7 +348,7 @@ impl StyleSharingCandidateCache {
         }
     }
 
-    pub fn iter<'a>(&'a self) -> Iter<'a, (StyleSharingCandidate, ())> {
+    pub fn iter(&self) -> Iter<(StyleSharingCandidate, ())> {
         self.cache.iter()
     }
 

components/layout/flex.rs

@@ -309,7 +309,7 @@ impl Flow for FlexFlow {
         FlowClass::Flex
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 

components/layout/flow.rs

@@ -77,108 +77,108 @@ pub trait Flow: fmt::Debug + Sync + Send + 'static {
     fn class(&self) -> FlowClass;
 
     /// If this is a block flow, returns the underlying object. Fails otherwise.
-    fn as_block<'a>(&'a self) -> &'a BlockFlow {
+    fn as_block(&self) -> &BlockFlow {
         panic!("called as_block() on a non-block flow")
     }
 
     /// If this is a block flow, returns the underlying object, borrowed mutably. Fails otherwise.
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         debug!("called as_mut_block() on a flow of type {:?}", self.class());
         panic!("called as_mut_block() on a non-block flow")
     }
 
     /// If this is an inline flow, returns the underlying object. Fails otherwise.
-    fn as_inline<'a>(&'a self) -> &'a InlineFlow {
+    fn as_inline(&self) -> &InlineFlow {
         panic!("called as_inline() on a non-inline flow")
     }
 
     /// If this is an inline flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_inline<'a>(&'a mut self) -> &'a mut InlineFlow {
+    fn as_mut_inline(&mut self) -> &mut InlineFlow {
         panic!("called as_mut_inline() on a non-inline flow")
     }
 
     /// If this is a table wrapper flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_table_wrapper<'a>(&'a mut self) -> &'a mut TableWrapperFlow {
+    fn as_mut_table_wrapper(&mut self) -> &mut TableWrapperFlow {
         panic!("called as_mut_table_wrapper() on a non-tablewrapper flow")
     }
 
     /// If this is a table wrapper flow, returns the underlying object. Fails otherwise.
-    fn as_table_wrapper<'a>(&'a self) -> &'a TableWrapperFlow {
+    fn as_table_wrapper(&self) -> &TableWrapperFlow {
         panic!("called as_table_wrapper() on a non-tablewrapper flow")
     }
 
     /// If this is a table flow, returns the underlying object, borrowed mutably. Fails otherwise.
-    fn as_mut_table<'a>(&'a mut self) -> &'a mut TableFlow {
+    fn as_mut_table(&mut self) -> &mut TableFlow {
         panic!("called as_mut_table() on a non-table flow")
     }
 
     /// If this is a table flow, returns the underlying object. Fails otherwise.
-    fn as_table<'a>(&'a self) -> &'a TableFlow {
+    fn as_table(&self) -> &TableFlow {
         panic!("called as_table() on a non-table flow")
     }
 
     /// If this is a table colgroup flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_table_colgroup<'a>(&'a mut self) -> &'a mut TableColGroupFlow {
+    fn as_mut_table_colgroup(&mut self) -> &mut TableColGroupFlow {
         panic!("called as_mut_table_colgroup() on a non-tablecolgroup flow")
     }
 
     /// If this is a table rowgroup flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_table_rowgroup<'a>(&'a mut self) -> &'a mut TableRowGroupFlow {
+    fn as_mut_table_rowgroup(&mut self) -> &mut TableRowGroupFlow {
         panic!("called as_mut_table_rowgroup() on a non-tablerowgroup flow")
     }
 
     /// If this is a table rowgroup flow, returns the underlying object. Fails otherwise.
-    fn as_table_rowgroup<'a>(&'a self) -> &'a TableRowGroupFlow {
+    fn as_table_rowgroup(&self) -> &TableRowGroupFlow {
         panic!("called as_table_rowgroup() on a non-tablerowgroup flow")
     }
 
     /// If this is a table row flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_table_row<'a>(&'a mut self) -> &'a mut TableRowFlow {
+    fn as_mut_table_row(&mut self) -> &mut TableRowFlow {
         panic!("called as_mut_table_row() on a non-tablerow flow")
     }
 
     /// If this is a table row flow, returns the underlying object. Fails otherwise.
-    fn as_table_row<'a>(&'a self) -> &'a TableRowFlow {
+    fn as_table_row(&self) -> &TableRowFlow {
         panic!("called as_table_row() on a non-tablerow flow")
     }
 
     /// If this is a table cell flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_table_caption<'a>(&'a mut self) -> &'a mut TableCaptionFlow {
+    fn as_mut_table_caption(&mut self) -> &mut TableCaptionFlow {
         panic!("called as_mut_table_caption() on a non-tablecaption flow")
     }
 
     /// If this is a table cell flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_table_cell<'a>(&'a mut self) -> &'a mut TableCellFlow {
+    fn as_mut_table_cell(&mut self) -> &mut TableCellFlow {
         panic!("called as_mut_table_cell() on a non-tablecell flow")
     }
 
     /// If this is a multicol flow, returns the underlying object, borrowed mutably. Fails
     /// otherwise.
-    fn as_mut_multicol<'a>(&'a mut self) -> &'a mut MulticolFlow {
+    fn as_mut_multicol(&mut self) -> &mut MulticolFlow {
         panic!("called as_mut_multicol() on a non-multicol flow")
     }
 
     /// If this is a table cell flow, returns the underlying object. Fails otherwise.
-    fn as_table_cell<'a>(&'a self) -> &'a TableCellFlow {
+    fn as_table_cell(&self) -> &TableCellFlow {
         panic!("called as_table_cell() on a non-tablecell flow")
     }
 
     /// If this is a table row, table rowgroup, or table flow, returns column intrinsic
     /// inline-sizes. Fails otherwise.
-    fn column_intrinsic_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnIntrinsicInlineSize> {
+    fn column_intrinsic_inline_sizes(&mut self) -> &mut Vec<ColumnIntrinsicInlineSize> {
         panic!("called column_intrinsic_inline_sizes() on non-table flow")
     }
 
     /// If this is a table row, table rowgroup, or table flow, returns column computed
     /// inline-sizes. Fails otherwise.
-    fn column_computed_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnComputedInlineSize> {
+    fn column_computed_inline_sizes(&mut self) -> &mut Vec<ColumnComputedInlineSize> {
         panic!("called column_intrinsic_inline_sizes() on non-table flow")
     }
 
@@ -756,7 +756,7 @@ impl AbsoluteDescendants {
     }
 
     /// Return an iterator over the descendant flows.
-    pub fn iter<'a>(&'a mut self) -> AbsoluteDescendantIter<'a> {
+    pub fn iter(&mut self) -> AbsoluteDescendantIter {
         AbsoluteDescendantIter {
             iter: self.descendant_links.iter_mut(),
         }
@@ -1093,7 +1093,7 @@ impl BaseFlow {
         }
     }
 
-    pub fn child_iter<'a>(&'a mut self) -> MutFlowListIterator<'a> {
+    pub fn child_iter(&mut self) -> MutFlowListIterator {
         self.children.iter_mut()
     }
 
@@ -1497,7 +1497,7 @@ impl ContainingBlockLink {
     }
 
     #[allow(unsafe_code)]
-    pub unsafe fn get<'a>(&'a mut self) -> &'a mut Option<WeakFlowRef> {
+    pub unsafe fn get(&mut self) -> &mut Option<WeakFlowRef> {
         &mut self.link
     }
 

components/layout/flow_list.rs

@@ -25,27 +25,27 @@ pub struct MutFlowListIterator<'a> {
 impl FlowList {
     /// Provide a reference to the front element, or None if the list is empty
     #[inline]
-    pub fn front<'a>(&'a self) -> Option<&'a Flow> {
+    pub fn front(&self) -> Option<&Flow> {
         self.flows.front().map(|head| &**head)
     }
 
     /// Provide a mutable reference to the front element, or None if the list is empty
     #[inline]
     #[allow(unsafe_code)]
-    pub unsafe fn front_mut<'a>(&'a mut self) -> Option<&'a mut Flow> {
+    pub unsafe fn front_mut(&mut self) -> Option<&mut Flow> {
         self.flows.front_mut().map(flow_ref::deref_mut)
     }
 
     /// Provide a reference to the back element, or None if the list is empty
     #[inline]
-    pub fn back<'a>(&'a self) -> Option<&'a Flow> {
+    pub fn back(&self) -> Option<&Flow> {
         self.flows.back().map(|tail| &**tail)
     }
 
     /// Provide a mutable reference to the back element, or None if the list is empty
     #[inline]
     #[allow(unsafe_code)]
-    pub unsafe fn back_mut<'a>(&'a mut self) -> Option<&'a mut Flow> {
+    pub unsafe fn back_mut(&mut self) -> Option<&mut Flow> {
         self.flows.back_mut().map(flow_ref::deref_mut)
     }
 
@@ -80,7 +80,7 @@ impl FlowList {
 
     /// Provide a forward iterator
     #[inline]
-    pub fn iter<'a>(&'a self) -> FlowListIterator<'a> {
+    pub fn iter(&self) -> FlowListIterator {
         FlowListIterator {
             it: self.flows.iter(),
         }
@@ -88,7 +88,7 @@ impl FlowList {
 
     /// Provide a forward iterator with mutable references
     #[inline]
-    pub fn iter_mut<'a>(&'a mut self) -> MutFlowListIterator<'a> {
+    pub fn iter_mut(&mut self) -> MutFlowListIterator {
         MutFlowListIterator {
             it: self.flows.iter_mut(),
         }

components/layout/inline.rs

@@ -841,12 +841,12 @@ impl InlineFragments {
     }
 
     /// A convenience function to return the fragment at a given index.
-    pub fn get<'a>(&'a self, index: usize) -> &'a Fragment {
+    pub fn get(&self, index: usize) -> &Fragment {
         &self.fragments[index]
     }
 
     /// A convenience function to return a mutable reference to the fragment at a given index.
-    pub fn get_mut<'a>(&'a mut self, index: usize) -> &'a mut Fragment {
+    pub fn get_mut(&mut self, index: usize) -> &mut Fragment {
         &mut self.fragments[index]
     }
 }
@@ -1314,11 +1314,11 @@ impl Flow for InlineFlow {
         FlowClass::Inline
     }
 
-    fn as_inline<'a>(&'a self) -> &'a InlineFlow {
+    fn as_inline(&self) -> &InlineFlow {
         self
     }
 
-    fn as_mut_inline<'a>(&'a mut self) -> &'a mut InlineFlow {
+    fn as_mut_inline(&mut self) -> &mut InlineFlow {
         self
     }
 

components/layout/layout_task.rs

@@ -1266,7 +1266,7 @@ impl LayoutTask {
         animation::tick_all_animations(self, &mut rw_data)
     }
 
-    pub fn tick_animations<'a>(&'a self, rw_data: &mut LayoutTaskData) {
+    pub fn tick_animations(&self, rw_data: &mut LayoutTaskData) {
         let reflow_info = Reflow {
             goal: ReflowGoal::ForDisplay,
             page_clip_rect: MAX_RECT,

components/layout/list_item.rs

@@ -68,11 +68,11 @@ impl Flow for ListItemFlow {
         FlowClass::ListItem
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 
-    fn as_block<'a>(&'a self) -> &'a BlockFlow {
+    fn as_block(&self) -> &BlockFlow {
         &self.block_flow
     }
 

components/layout/multicol.rs

@@ -36,15 +36,15 @@ impl Flow for MulticolFlow {
         FlowClass::Multicol
     }
 
-    fn as_mut_multicol<'a>(&'a mut self) -> &'a mut MulticolFlow {
+    fn as_mut_multicol(&mut self) -> &mut MulticolFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 
-    fn as_block<'a>(&'a self) -> &'a BlockFlow {
+    fn as_block(&self) -> &BlockFlow {
         &self.block_flow
     }
 

components/layout/table.rs

@@ -191,15 +191,15 @@ impl Flow for TableFlow {
         FlowClass::Table
     }
 
-    fn as_mut_table<'a>(&'a mut self) -> &'a mut TableFlow {
+    fn as_mut_table(&mut self) -> &mut TableFlow {
         self
     }
 
-    fn as_table<'a>(&'a self) -> &'a TableFlow {
+    fn as_table(&self) -> &TableFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 
@@ -211,11 +211,11 @@ impl Flow for TableFlow {
         self.block_flow.mark_as_root();
     }
 
-    fn column_intrinsic_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnIntrinsicInlineSize> {
+    fn column_intrinsic_inline_sizes(&mut self) -> &mut Vec<ColumnIntrinsicInlineSize> {
         &mut self.column_intrinsic_inline_sizes
     }
 
-    fn column_computed_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnComputedInlineSize> {
+    fn column_computed_inline_sizes(&mut self) -> &mut Vec<ColumnComputedInlineSize> {
         &mut self.column_computed_inline_sizes
     }
 

components/layout/table_caption.rs

@@ -36,11 +36,11 @@ impl Flow for TableCaptionFlow {
         FlowClass::TableCaption
     }
 
-    fn as_mut_table_caption<'a>(&'a mut self) -> &'a mut TableCaptionFlow {
+    fn as_mut_table_caption(&mut self) -> &mut TableCaptionFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 

components/layout/table_cell.rs

@@ -59,11 +59,11 @@ impl TableCellFlow {
         }
     }
 
-    pub fn fragment<'a>(&'a mut self) -> &'a Fragment {
+    pub fn fragment(&mut self) -> &Fragment {
         &self.block_flow.fragment
     }
 
-    pub fn mut_fragment<'a>(&'a mut self) -> &'a mut Fragment {
+    pub fn mut_fragment(&mut self) -> &mut Fragment {
         &mut self.block_flow.fragment
     }
 
@@ -84,15 +84,15 @@ impl Flow for TableCellFlow {
         FlowClass::TableCell
     }
 
-    fn as_mut_table_cell<'a>(&'a mut self) -> &'a mut TableCellFlow {
+    fn as_mut_table_cell(&mut self) -> &mut TableCellFlow {
         self
     }
 
-    fn as_table_cell<'a>(&'a self) -> &'a TableCellFlow {
+    fn as_table_cell(&self) -> &TableCellFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 

components/layout/table_colgroup.rs

@@ -56,7 +56,7 @@ impl Flow for TableColGroupFlow {
         FlowClass::TableColGroup
     }
 
-    fn as_mut_table_colgroup<'a>(&'a mut self) -> &'a mut TableColGroupFlow {
+    fn as_mut_table_colgroup(&mut self) -> &mut TableColGroupFlow {
         self
     }
 

components/layout/table_row.rs

@@ -96,7 +96,7 @@ impl TableRowFlow {
         }
     }
 
-    pub fn fragment<'a>(&'a mut self) -> &'a Fragment {
+    pub fn fragment(&mut self) -> &Fragment {
         &self.block_flow.fragment
     }
 
@@ -107,7 +107,7 @@ impl TableRowFlow {
     /// inline(always) because this is only ever called by in-order or non-in-order top-level
     /// methods
     #[inline(always)]
-    fn assign_block_size_table_row_base<'a>(&mut self, layout_context: &'a LayoutContext<'a>) {
+    fn assign_block_size_table_row_base(&mut self, layout_context: &LayoutContext) {
         // Per CSS 2.1 § 17.5.3, find max_y = max(computed `block-size`, minimum block-size of all
         // cells).
         let mut max_block_size = Au(0);
@@ -202,15 +202,15 @@ impl Flow for TableRowFlow {
         FlowClass::TableRow
     }
 
-    fn as_mut_table_row<'a>(&'a mut self) -> &'a mut TableRowFlow {
+    fn as_mut_table_row(&mut self) -> &mut TableRowFlow {
         self
     }
 
-    fn as_table_row<'a>(&'a self) -> &'a TableRowFlow {
+    fn as_table_row(&self) -> &TableRowFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 
@@ -218,11 +218,11 @@ impl Flow for TableRowFlow {
         &self.block_flow
     }
 
-    fn column_intrinsic_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnIntrinsicInlineSize> {
+    fn column_intrinsic_inline_sizes(&mut self) -> &mut Vec<ColumnIntrinsicInlineSize> {
         panic!("can't call column_intrinsic_inline_sizes() on table row")
     }
 
-    fn column_computed_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnComputedInlineSize> {
+    fn column_computed_inline_sizes(&mut self) -> &mut Vec<ColumnComputedInlineSize> {
         &mut self.column_computed_inline_sizes
     }
 
@@ -407,7 +407,7 @@ impl Flow for TableRowFlow {
         })
     }
 
-    fn assign_block_size<'a>(&mut self, layout_context: &'a LayoutContext<'a>) {
+    fn assign_block_size(&mut self, layout_context: &LayoutContext) {
         debug!("assign_block_size: assigning block_size for table_row");
         self.assign_block_size_table_row_base(layout_context);
     }

components/layout/table_rowgroup.rs

@@ -79,7 +79,7 @@ impl TableRowGroupFlow {
         }
     }
 
-    pub fn fragment<'a>(&'a mut self) -> &'a Fragment {
+    pub fn fragment(&mut self) -> &Fragment {
         &self.block_flow.fragment
     }
 
@@ -112,15 +112,15 @@ impl Flow for TableRowGroupFlow {
         FlowClass::TableRowGroup
     }
 
-    fn as_mut_table_rowgroup<'a>(&'a mut self) -> &'a mut TableRowGroupFlow {
+    fn as_mut_table_rowgroup(&mut self) -> &mut TableRowGroupFlow {
         self
     }
 
-    fn as_table_rowgroup<'a>(&'a self) -> &'a TableRowGroupFlow {
+    fn as_table_rowgroup(&self) -> &TableRowGroupFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 
@@ -128,11 +128,11 @@ impl Flow for TableRowGroupFlow {
         &self.block_flow
     }
 
-    fn column_intrinsic_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnIntrinsicInlineSize> {
+    fn column_intrinsic_inline_sizes(&mut self) -> &mut Vec<ColumnIntrinsicInlineSize> {
         &mut self.column_intrinsic_inline_sizes
     }
 
-    fn column_computed_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<ColumnComputedInlineSize> {
+    fn column_computed_inline_sizes(&mut self) -> &mut Vec<ColumnComputedInlineSize> {
         &mut self.column_computed_inline_sizes
     }
 

components/layout/table_wrapper.rs

@@ -285,19 +285,19 @@ impl Flow for TableWrapperFlow {
         FlowClass::TableWrapper
     }
 
-    fn as_mut_table_wrapper<'a>(&'a mut self) -> &'a mut TableWrapperFlow {
+    fn as_mut_table_wrapper(&mut self) -> &mut TableWrapperFlow {
         self
     }
 
-    fn as_table_wrapper<'a>(&'a self) -> &'a TableWrapperFlow {
+    fn as_table_wrapper(&self) -> &TableWrapperFlow {
         self
     }
 
-    fn as_mut_block<'a>(&'a mut self) -> &'a mut BlockFlow {
+    fn as_mut_block(&mut self) -> &mut BlockFlow {
         &mut self.block_flow
     }
 
-    fn as_block<'a>(&'a self) -> &'a BlockFlow {
+    fn as_block(&self) -> &BlockFlow {
         &self.block_flow
     }
 

components/layout/wrapper.rs

@@ -160,7 +160,7 @@ impl<'ln> LayoutNode<'ln> {
 
     /// Returns the interior of this node as a `LayoutJS`. This is highly unsafe for layout to
     /// call and as such is marked `unsafe`.
-    unsafe fn get_jsmanaged<'a>(&'a self) -> &'a LayoutJS<Node> {
+    unsafe fn get_jsmanaged(&self) -> &LayoutJS<Node> {
         &self.node
     }
 
@@ -280,7 +280,7 @@ impl<'ln> LayoutNode<'ln> {
 
     /// Borrows the layout data immutably. Fails on a conflicting borrow.
     #[inline(always)]
-    pub fn borrow_layout_data<'a>(&'a self) -> Ref<'a, Option<LayoutDataWrapper>> {
+    pub fn borrow_layout_data(&self) -> Ref<Option<LayoutDataWrapper>> {
         unsafe {
             mem::transmute(self.get_jsmanaged().layout_data())
         }
@@ -288,7 +288,7 @@ impl<'ln> LayoutNode<'ln> {
 
     /// Borrows the layout data mutably. Fails on a conflicting borrow.
     #[inline(always)]
-    pub fn mutate_layout_data<'a>(&'a self) -> RefMut<'a, Option<LayoutDataWrapper>> {
+    pub fn mutate_layout_data(&self) -> RefMut<Option<LayoutDataWrapper>> {
         unsafe {
             mem::transmute(self.get_jsmanaged().layout_data_mut())
         }
@@ -431,12 +431,12 @@ impl<'le> ::selectors::Element for LayoutElement<'le> {
     }
 
     #[inline]
-    fn get_local_name<'a>(&'a self) -> &'a Atom {
+    fn get_local_name(&self) -> &Atom {
         self.element.local_name()
     }
 
     #[inline]
-    fn get_namespace<'a>(&'a self) -> &'a Namespace {
+    fn get_namespace(&self) -> &Namespace {
         self.element.namespace()
     }
 
@@ -666,7 +666,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
 
     /// Returns the interior of this node as a `LayoutJS`. This is highly unsafe for layout to
     /// call and as such is marked `unsafe`.
-    unsafe fn get_jsmanaged<'a>(&'a self) -> &'a LayoutJS<Node> {
+    unsafe fn get_jsmanaged(&self) -> &LayoutJS<Node> {
         self.node.get_jsmanaged()
     }
 
@@ -739,7 +739,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
 
     /// Borrows the layout data without checking.
     #[inline(always)]
-    fn borrow_layout_data_unchecked<'a>(&'a self) -> *const Option<LayoutDataWrapper> {
+    fn borrow_layout_data_unchecked(&self) -> *const Option<LayoutDataWrapper> {
         unsafe {
             self.node.borrow_layout_data_unchecked()
         }
@@ -749,7 +749,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     ///
     /// TODO(pcwalton): Make this private. It will let us avoid borrow flag checks in some cases.
     #[inline(always)]
-    pub fn borrow_layout_data<'a>(&'a self) -> Ref<'a, Option<LayoutDataWrapper>> {
+    pub fn borrow_layout_data(&self) -> Ref<Option<LayoutDataWrapper>> {
         self.node.borrow_layout_data()
     }
 
@@ -757,14 +757,14 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
     ///
     /// TODO(pcwalton): Make this private. It will let us avoid borrow flag checks in some cases.
     #[inline(always)]
-    pub fn mutate_layout_data<'a>(&'a self) -> RefMut<'a, Option<LayoutDataWrapper>> {
+    pub fn mutate_layout_data(&self) -> RefMut<Option<LayoutDataWrapper>> {
         self.node.mutate_layout_data()
     }
 
     /// Returns the style results for the given node. If CSS selector matching
     /// has not yet been performed, fails.
     #[inline]
-    pub fn style<'a>(&'a self) -> Ref<'a, Arc<ComputedValues>> {
+    pub fn style(&self) -> Ref<Arc<ComputedValues>> {
         Ref::map(self.borrow_layout_data(), |layout_data_ref| {
             let layout_data = layout_data_ref.as_ref().expect("no layout data");
             let style = match self.get_pseudo_element_type() {
@@ -1000,8 +1000,8 @@ pub struct ThreadSafeLayoutNodeChildrenIterator<'a> {
 
 impl<'a> ThreadSafeLayoutNodeChildrenIterator<'a> {
     fn new(parent: ThreadSafeLayoutNode<'a>) -> ThreadSafeLayoutNodeChildrenIterator<'a> {
-        fn first_child<'a>(parent: ThreadSafeLayoutNode<'a>)
-                           -> Option<ThreadSafeLayoutNode<'a>> {
+        fn first_child(parent: ThreadSafeLayoutNode)
+                           -> Option<ThreadSafeLayoutNode> {
             if parent.pseudo != PseudoElementType::Normal {
                 return None
             }