Bug 1604173 - Rustfmt recent changes.
authorEmilio Cobos Álvarez <emilio@crisal.io>
Mon, 16 Dec 2019 13:34:20 +0000
changeset 507120 8c1790e4a72707e7813405a2d78f1d6622e3aee9
parent 507119 aa02e93402e01025296051964250b2dcc0486312
child 507121 e48f16780da57d3c915e7fed254a0bcaffbe7477
push id103277
push userealvarez@mozilla.com
push dateMon, 16 Dec 2019 13:35:25 +0000
treeherderautoland@e48f16780da5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1604173
milestone73.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1604173 - Rustfmt recent changes. Differential Revision: https://phabricator.services.mozilla.com/D57314
servo/components/selectors/builder.rs
servo/components/style/dom.rs
servo/components/style/font_metrics.rs
servo/components/style/gecko/media_queries.rs
servo/components/style/gecko/wrapper.rs
servo/components/style/invalidation/element/invalidation_map.rs
servo/components/style/invalidation/element/state_and_attributes.rs
servo/components/style/logical_geometry.rs
servo/components/style/rule_collector.rs
servo/components/style/rule_tree/mod.rs
servo/components/style/servo/media_queries.rs
servo/components/style/stylesheets/mod.rs
servo/components/style/stylesheets/stylesheet.rs
servo/components/style/values/animated/transform.rs
servo/components/style/values/computed/length.rs
servo/components/style/values/computed/mod.rs
servo/components/style/values/computed/text.rs
servo/components/style/values/specified/box.rs
servo/components/style/values/specified/font.rs
servo/components/style/values/specified/gecko.rs
servo/components/style/values/specified/length.rs
servo/components/style/values/specified/mod.rs
--- a/servo/components/selectors/builder.rs
+++ b/servo/components/selectors/builder.rs
@@ -319,17 +319,17 @@ where
             Component::NthChild(..) |
             Component::NthLastChild(..) |
             Component::NthOfType(..) |
             Component::NthLastOfType(..) |
             Component::FirstOfType |
             Component::LastOfType |
             Component::OnlyOfType => {
                 specificity.class_like_selectors += 1;
-            }
+            },
             Component::NonTSPseudoClass(ref pseudo) => {
                 if !pseudo.has_zero_specificity() {
                     specificity.class_like_selectors += 1;
                 }
             },
             Component::ExplicitUniversalType |
             Component::ExplicitAnyNamespace |
             Component::ExplicitNoNamespace |
--- a/servo/components/style/dom.rs
+++ b/servo/components/style/dom.rs
@@ -862,24 +862,24 @@ pub trait TElement:
                                     f(data, shadow.host())
                                 }
                             }
                             // TODO: Could be more granular.
                             if !shadow.host().exports_any_part() {
                                 break;
                             }
                             inner_shadow = shadow;
-                        }
+                        },
                         None => {
                             // TODO(emilio): Should probably distinguish with
                             // MatchesDocumentRules::{No,Yes,IfPart} or
                             // something so that we could skip some work.
                             doc_rules_apply = true;
                             break;
-                        }
+                        },
                     }
                 }
             }
         }
 
         doc_rules_apply
     }
 
--- a/servo/components/style/font_metrics.rs
+++ b/servo/components/style/font_metrics.rs
@@ -2,18 +2,18 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 //! Access to font metrics from the style system.
 
 #![deny(missing_docs)]
 
 use crate::context::SharedStyleContext;
+use crate::values::computed::Length;
 use crate::Atom;
-use crate::values::computed::Length;
 
 /// Represents the font metrics that style needs from a font to compute the
 /// value of certain CSS units like `ex`.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct FontMetrics {
     /// The x-height of the font.
     pub x_height: Option<Length>,
     /// The zero advance. This is usually writing mode dependent
--- a/servo/components/style/gecko/media_queries.rs
+++ b/servo/components/style/gecko/media_queries.rs
@@ -133,17 +133,18 @@ impl Device {
     /// Get the font size of the root element (for rem)
     pub fn root_font_size(&self) -> Au {
         self.used_root_font_size.store(true, Ordering::Relaxed);
         Au::new(self.root_font_size.load(Ordering::Relaxed) as i32)
     }
 
     /// Set the font size of the root element (for rem)
     pub fn set_root_font_size(&self, size: Au) {
-        self.root_font_size.store(size.0 as isize, Ordering::Relaxed)
+        self.root_font_size
+            .store(size.0 as isize, Ordering::Relaxed)
     }
 
     /// Sets the body text color for the "inherit color from body" quirk.
     ///
     /// <https://quirks.spec.whatwg.org/#the-tables-inherit-color-from-body-quirk>
     pub fn set_body_text_color(&self, color: RGBA) {
         self.body_text_color
             .store(convert_rgba_to_nscolor(&color) as usize, Ordering::Relaxed)
--- a/servo/components/style/gecko/wrapper.rs
+++ b/servo/components/style/gecko/wrapper.rs
@@ -995,17 +995,18 @@ impl structs::FontSizePrefs {
             GenericFontFamily::Serif => self.mDefaultSerifSize,
             GenericFontFamily::SansSerif => self.mDefaultSansSerifSize,
             GenericFontFamily::Monospace => self.mDefaultMonospaceSize,
             GenericFontFamily::Cursive => self.mDefaultCursiveSize,
             GenericFontFamily::Fantasy => self.mDefaultFantasySize,
             GenericFontFamily::MozEmoji => unreachable!(
                 "Should never get here, since this doesn't (yet) appear on font family"
             ),
-        }).into()
+        })
+        .into()
     }
 }
 
 impl<'le> TElement for GeckoElement<'le> {
     type ConcreteNode = GeckoNode<'le>;
     type FontMetricsProvider = GeckoFontMetricsProvider;
     type TraversalChildrenIterator = GeckoChildrenIterator<'le>;
 
@@ -2126,17 +2127,19 @@ impl<'le> ::selectors::Element for Gecko
                     .dom_children()
                     .any(|c| c.contains_non_whitespace_content())
                 {
                     return false;
                 }
                 true
             },
             NonTSPseudoClass::MozNativeAnonymous |
-            NonTSPseudoClass::MozNativeAnonymousNoSpecificity => self.is_in_native_anonymous_subtree(),
+            NonTSPseudoClass::MozNativeAnonymousNoSpecificity => {
+                self.is_in_native_anonymous_subtree()
+            },
             NonTSPseudoClass::MozUseShadowTreeRoot => self.is_root_of_use_element_shadow_tree(),
             NonTSPseudoClass::MozTableBorderNonzero => unsafe {
                 bindings::Gecko_IsTableBorderNonzero(self.0)
             },
             NonTSPseudoClass::MozBrowserFrame => unsafe { bindings::Gecko_IsBrowserFrame(self.0) },
             NonTSPseudoClass::MozIsHTML => self.is_html_element_in_html_document(),
             NonTSPseudoClass::MozLWTheme => self.document_theme() != DocumentTheme::Doc_Theme_None,
             NonTSPseudoClass::MozLWThemeBrightText => {
--- a/servo/components/style/invalidation/element/invalidation_map.rs
+++ b/servo/components/style/invalidation/element/invalidation_map.rs
@@ -391,17 +391,19 @@ impl<'a> SelectorVisitor for CompoundSel
         self.other_attributes = true;
         let may_match_in_no_namespace = match *constraint {
             NamespaceConstraint::Any => true,
             NamespaceConstraint::Specific(ref ns) => ns.is_empty(),
         };
 
         if may_match_in_no_namespace {
             if *local_name_lower == local_name!("id") {
-                self.flags.insert(InvalidationMapFlags::HAS_ID_ATTR_SELECTOR)
+                self.flags
+                    .insert(InvalidationMapFlags::HAS_ID_ATTR_SELECTOR)
             } else if *local_name_lower == local_name!("class") {
-                self.flags.insert(InvalidationMapFlags::HAS_CLASS_ATTR_SELECTOR)
+                self.flags
+                    .insert(InvalidationMapFlags::HAS_CLASS_ATTR_SELECTOR)
             }
         }
 
         true
     }
 }
--- a/servo/components/style/invalidation/element/state_and_attributes.rs
+++ b/servo/components/style/invalidation/element/state_and_attributes.rs
@@ -199,17 +199,20 @@ where
 
             if old_id != current_id {
                 id_removed = old_id;
                 id_added = current_id;
             }
         }
 
         if log_enabled!(::log::Level::Debug) {
-            debug!("Collecting changes for: {:?}, flags {:?}", element, attr_selector_flags);
+            debug!(
+                "Collecting changes for: {:?}, flags {:?}",
+                element, attr_selector_flags
+            );
             if !state_changes.is_empty() {
                 debug!(" > state: {:?}", state_changes);
             }
             if snapshot.id_changed() {
                 debug!(" > id changed: +{:?} -{:?}", id_added, id_removed);
             }
             if snapshot.class_changed() {
                 debug!(
@@ -357,18 +360,18 @@ where
         for class in self.classes_added.iter().chain(self.classes_removed.iter()) {
             if let Some(deps) = map.class_to_selector.get(class, quirks_mode) {
                 for dep in deps {
                     self.scan_dependency(dep);
                 }
             }
         }
 
-        let should_examine_attribute_selector_map = self.snapshot.other_attr_changed() ||
-            map.flags.intersects(self.attr_selector_flags);
+        let should_examine_attribute_selector_map =
+            self.snapshot.other_attr_changed() || map.flags.intersects(self.attr_selector_flags);
 
         if should_examine_attribute_selector_map {
             self.collect_dependencies_in_map(&map.other_attribute_affecting_selectors)
         }
 
         let state_changes = self.state_changes;
         if !state_changes.is_empty() {
             self.collect_state_dependencies(&map.state_affecting_selectors, state_changes)
--- a/servo/components/style/logical_geometry.rs
+++ b/servo/components/style/logical_geometry.rs
@@ -892,17 +892,16 @@ impl<T> LogicalMargin<T> {
                 inline_start = offsets.right;
                 inline_end = offsets.left;
             }
         }
         LogicalMargin::new(mode, block_start, inline_end, block_end, inline_start)
     }
 }
 
-
 impl<T: Copy> LogicalMargin<T> {
     #[inline]
     pub fn new_all_same(mode: WritingMode, value: T) -> LogicalMargin<T> {
         LogicalMargin::new(mode, value, value, value, value)
     }
 
     #[inline]
     pub fn top(&self, mode: WritingMode) -> T {
--- a/servo/components/style/rule_collector.rs
+++ b/servo/components/style/rule_collector.rs
@@ -343,17 +343,16 @@ where
         let mut parts = SmallVec::<[Atom; 3]>::new();
         self.rule_hash_target.each_part(|p| parts.push(p.clone()));
 
         loop {
             if parts.is_empty() {
                 return;
             }
 
-
             let inner_shadow_host = inner_shadow.host();
             let outer_shadow = inner_shadow_host.containing_shadow();
             let part_rules = match outer_shadow {
                 Some(shadow) => shadow
                     .style_data()
                     .and_then(|data| data.part_rules(self.pseudo_element)),
                 None => self
                     .stylist
--- a/servo/components/style/rule_tree/mod.rs
+++ b/servo/components/style/rule_tree/mod.rs
@@ -587,18 +587,18 @@ impl RuleTree {
                 children.push((
                     node.get().source.as_ref().unwrap().clone(),
                     node.cascade_level(),
                 ));
             }
             last = node;
         }
 
-        let rule =
-            self.insert_ordered_rules_from(last.parent().unwrap().clone(), children.drain(..).rev());
+        let rule = self
+            .insert_ordered_rules_from(last.parent().unwrap().clone(), children.drain(..).rev());
         rule
     }
 
     /// Returns new rule node by adding animation rules at transition level.
     /// The additional rules must be appropriate for the transition
     /// level of the cascade, which is the highest level of the cascade.
     /// (This is the case for one current caller, the cover rule used
     /// for CSS transitions.)
--- a/servo/components/style/servo/media_queries.rs
+++ b/servo/components/style/servo/media_queries.rs
@@ -6,18 +6,18 @@
 
 use crate::custom_properties::CssEnvironment;
 use crate::media_queries::media_feature::{AllowsRanges, ParsingRequirements};
 use crate::media_queries::media_feature::{Evaluator, MediaFeatureDescription};
 use crate::media_queries::media_feature_expression::RangeOrOperator;
 use crate::media_queries::MediaType;
 use crate::properties::ComputedValues;
 use crate::values::computed::CSSPixelLength;
+use crate::values::specified::font::FONT_MEDIUM_PX;
 use crate::values::KeyframesName;
-use crate::values::specified::font::FONT_MEDIUM_PX;
 use app_units::Au;
 use cssparser::RGBA;
 use euclid::default::Size2D as UntypedSize2D;
 use euclid::{Scale, Size2D};
 use std::sync::atomic::{AtomicBool, AtomicIsize, Ordering};
 use style_traits::viewport::ViewportConstraints;
 use style_traits::{CSSPixel, DevicePixel};
 
--- a/servo/components/style/stylesheets/mod.rs
+++ b/servo/components/style/stylesheets/mod.rs
@@ -54,18 +54,18 @@ pub use self::namespace_rule::NamespaceR
 pub use self::origin::{Origin, OriginSet, OriginSetIterator, PerOrigin, PerOriginIter};
 pub use self::page_rule::PageRule;
 pub use self::rule_list::{CssRules, CssRulesHelpers};
 pub use self::rule_parser::{InsertRuleContext, State, TopLevelRuleParser};
 pub use self::rules_iterator::{AllRules, EffectiveRules};
 pub use self::rules_iterator::{NestedRuleIterationCondition, RulesIterator};
 pub use self::style_rule::StyleRule;
 pub use self::stylesheet::{DocumentStyleSheet, Namespaces, Stylesheet};
+pub use self::stylesheet::{SanitizationData, SanitizationKind};
 pub use self::stylesheet::{StylesheetContents, StylesheetInDocument, UserAgentStylesheets};
-pub use self::stylesheet::{SanitizationData, SanitizationKind};
 pub use self::supports_rule::SupportsRule;
 pub use self::viewport_rule::ViewportRule;
 
 /// The CORS mode used for a CSS load.
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ToShmem)]
 pub enum CorsMode {
     /// No CORS mode, so cross-origin loads can be done.
--- a/servo/components/style/stylesheets/stylesheet.rs
+++ b/servo/components/style/stylesheets/stylesheet.rs
@@ -363,19 +363,17 @@ impl SanitizationKind {
         // and such. But this doesn't seem necessary at the moment.
         let is_standard = matches!(self, SanitizationKind::Standard);
         match *rule {
             CssRule::Document(..) |
             CssRule::Media(..) |
             CssRule::Supports(..) |
             CssRule::Import(..) => false,
 
-            CssRule::FontFace(..) |
-            CssRule::Namespace(..) |
-            CssRule::Style(..) => true,
+            CssRule::FontFace(..) | CssRule::Namespace(..) | CssRule::Style(..) => true,
 
             CssRule::Keyframes(..) |
             CssRule::Page(..) |
             CssRule::FontFeatureValues(..) |
             CssRule::Viewport(..) |
             CssRule::CounterStyle(..) => !is_standard,
         }
     }
--- a/servo/components/style/values/animated/transform.rs
+++ b/servo/components/style/values/animated/transform.rs
@@ -1368,21 +1368,17 @@ impl ComputedTranslate {
         //
         // Unspecified translations default to 0px
         match *self {
             Translate::None => (
                 LengthPercentage::zero(),
                 LengthPercentage::zero(),
                 Length::zero(),
             ),
-            Translate::Translate(ref tx, ref ty, ref tz) => (
-                tx.clone(),
-                ty.clone(),
-                tz.clone(),
-            ),
+            Translate::Translate(ref tx, ref ty, ref tz) => (tx.clone(), ty.clone(), tz.clone()),
         }
     }
 }
 
 impl Animate for ComputedTranslate {
     #[inline]
     fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
         match (self, other) {
--- a/servo/components/style/values/computed/length.rs
+++ b/servo/components/style/values/computed/length.rs
@@ -70,19 +70,17 @@ impl ToComputedValue for specified::Leng
     }
 }
 
 /// A `<length-percentage>` value. This can be either a `<length>`, a
 /// `<percentage>`, or a combination of both via `calc()`.
 ///
 /// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
 #[allow(missing_docs)]
-#[derive(
-    Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
-)]
+#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue)]
 #[repr(C)]
 pub struct LengthPercentage {
     length: Length,
     percentage: Percentage,
     #[animation(constant)]
     pub clamping_mode: AllowedNumericType,
     /// Whether we specified a percentage or not.
     #[animation(constant)]
--- a/servo/components/style/values/computed/mod.rs
+++ b/servo/components/style/values/computed/mod.rs
@@ -70,21 +70,21 @@ pub use self::motion::{OffsetPath, Offse
 pub use self::outline::OutlineStyle;
 pub use self::percentage::{NonNegativePercentage, Percentage};
 pub use self::position::{GridAutoFlow, GridTemplateAreas, Position, PositionOrAuto, ZIndex};
 pub use self::rect::NonNegativeLengthOrNumberRect;
 pub use self::resolution::Resolution;
 pub use self::svg::MozContextProperties;
 pub use self::svg::{SVGLength, SVGOpacity, SVGPaint, SVGPaintKind};
 pub use self::svg::{SVGPaintOrder, SVGStrokeDashArray, SVGWidth};
+pub use self::text::TextUnderlinePosition;
 pub use self::text::{InitialLetter, LetterSpacing, LineBreak, LineHeight};
 pub use self::text::{OverflowWrap, TextOverflow, WordBreak, WordSpacing};
 pub use self::text::{TextAlign, TextEmphasisPosition, TextEmphasisStyle};
 pub use self::text::{TextDecorationLength, TextDecorationSkipInk};
-pub use self::text::TextUnderlinePosition;
 pub use self::time::Time;
 pub use self::transform::{Rotate, Scale, Transform, TransformOperation};
 pub use self::transform::{TransformOrigin, TransformStyle, Translate};
 #[cfg(feature = "gecko")]
 pub use self::ui::CursorImage;
 pub use self::ui::{Cursor, MozForceBrokenImageIcon, UserSelect};
 pub use super::specified::TextTransform;
 pub use super::specified::{BorderStyle, TextDecorationLine};
--- a/servo/components/style/values/computed/text.rs
+++ b/servo/components/style/values/computed/text.rs
@@ -14,20 +14,20 @@ use crate::values::generics::text::{Gene
 use crate::values::specified::text::{self as specified, TextOverflowSide};
 use crate::values::specified::text::{TextEmphasisFillMode, TextEmphasisShapeKeyword};
 use crate::values::{CSSFloat, CSSInteger};
 use crate::Zero;
 use std::fmt::{self, Write};
 use style_traits::{CssWriter, ToCss};
 
 pub use crate::values::specified::TextAlignKeyword as TextAlign;
+pub use crate::values::specified::TextUnderlinePosition;
 pub use crate::values::specified::{LineBreak, OverflowWrap, WordBreak};
 pub use crate::values::specified::{TextDecorationLine, TextEmphasisPosition};
 pub use crate::values::specified::{TextDecorationSkipInk, TextTransform};
-pub use crate::values::specified::TextUnderlinePosition;
 
 /// A computed value for the `initial-letter` property.
 pub type InitialLetter = GenericInitialLetter<CSSFloat, CSSInteger>;
 
 /// Implements type for `text-underline-offset` and `text-decoration-thickness` properties
 pub type TextDecorationLength = GenericTextDecorationLength<Length>;
 
 /// A computed value for the `letter-spacing` property.
--- a/servo/components/style/values/specified/box.rs
+++ b/servo/components/style/values/specified/box.rs
@@ -385,21 +385,19 @@ impl Display {
                     DisplayInside::Inline | DisplayInside::FlowRoot => DisplayInside::Block,
                     #[cfg(feature = "servo-layout-2020")]
                     DisplayInside::FlowRoot => DisplayInside::Flow,
                     inside => inside,
                 };
                 Display::from3(DisplayOutside::Block, inside, self.is_list_item())
             },
             #[cfg(feature = "gecko")]
-            DisplayOutside::XUL => {
-                match self.inside() {
-                    DisplayInside::MozInlineBox | DisplayInside::MozBox => Display::MozBox,
-                    _ => Display::Block,
-                }
+            DisplayOutside::XUL => match self.inside() {
+                DisplayInside::MozInlineBox | DisplayInside::MozBox => Display::MozBox,
+                _ => Display::Block,
             },
             DisplayOutside::Block | DisplayOutside::None => *self,
             #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
             _ => Display::Block,
         }
     }
 
     /// Convert this display into an equivalent inline-outside display.
--- a/servo/components/style/values/specified/font.rs
+++ b/servo/components/style/values/specified/font.rs
@@ -956,17 +956,18 @@ impl FontSize {
                     info = parent.keyword_info.map(|i| i.compose(ratio, abs));
                 }
                 let calc = calc.to_computed_value_zoomed(context, base_size);
                 // FIXME(emilio): we _could_ use clamp_to_non_negative()
                 // everywhere, without affecting behavior in theory, since the
                 // others should reject negatives during parsing. But SMIL
                 // allows parsing negatives, and relies on us _not_ doing that
                 // clamping. That's so bonkers :(
-                calc.percentage_relative_to(base_size.resolve(context)).clamp_to_non_negative()
+                calc.percentage_relative_to(base_size.resolve(context))
+                    .clamp_to_non_negative()
             },
             FontSize::Keyword(i) => {
                 // As a specified keyword, this is keyword derived
                 info = Some(i);
                 i.to_computed_value(context).clamp_to_non_negative()
             },
             FontSize::Smaller => {
                 info = compose_keyword(1. / LARGER_FONT_SIZE_RATIO);
--- a/servo/components/style/values/specified/gecko.rs
+++ b/servo/components/style/values/specified/gecko.rs
@@ -1,16 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 //! Specified types for legacy Gecko-only properties.
 
 use crate::parser::{Parse, ParserContext};
-use crate::values::computed::{self, LengthPercentage, Length};
+use crate::values::computed::{self, Length, LengthPercentage};
 use crate::values::generics::rect::Rect;
 use cssparser::{Parser, Token};
 use std::fmt;
 use style_traits::values::SequenceWriter;
 use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 
 fn parse_pixel_or_percent<'i, 't>(
     _context: &ParserContext,
--- a/servo/components/style/values/specified/length.rs
+++ b/servo/components/style/values/specified/length.rs
@@ -96,17 +96,21 @@ impl FontRelativeLength {
             FontRelativeLength::Em(v) |
             FontRelativeLength::Ex(v) |
             FontRelativeLength::Ch(v) |
             FontRelativeLength::Rem(v) => v == 0.0,
         }
     }
 
     /// Computes the font-relative length.
-    pub fn to_computed_value(&self, context: &Context, base_size: FontBaseSize) -> computed::Length {
+    pub fn to_computed_value(
+        &self,
+        context: &Context,
+        base_size: FontBaseSize,
+    ) -> computed::Length {
         let (reference_size, length) = self.reference_font_size_and_length(context, base_size);
         reference_size * length
     }
 
     /// Return reference font size.
     ///
     /// We use the base_size flag to pass a different size for computing
     /// font-size and unconstrained font-size.
--- a/servo/components/style/values/specified/mod.rs
+++ b/servo/components/style/values/specified/mod.rs
@@ -75,21 +75,21 @@ pub use self::percentage::Percentage;
 pub use self::position::{GridAutoFlow, GridTemplateAreas, Position, PositionOrAuto};
 pub use self::position::{PositionComponent, ZIndex};
 pub use self::rect::NonNegativeLengthOrNumberRect;
 pub use self::resolution::Resolution;
 pub use self::svg::MozContextProperties;
 pub use self::svg::{SVGLength, SVGOpacity, SVGPaint};
 pub use self::svg::{SVGPaintOrder, SVGStrokeDashArray, SVGWidth};
 pub use self::svg_path::SVGPathData;
+pub use self::text::TextUnderlinePosition;
 pub use self::text::{InitialLetter, LetterSpacing, LineBreak, LineHeight, TextAlign};
 pub use self::text::{OverflowWrap, TextEmphasisPosition, TextEmphasisStyle, WordBreak};
 pub use self::text::{TextAlignKeyword, TextDecorationLine, TextOverflow, WordSpacing};
 pub use self::text::{TextDecorationLength, TextDecorationSkipInk, TextTransform};
-pub use self::text::TextUnderlinePosition;
 pub use self::time::Time;
 pub use self::transform::{Rotate, Scale, Transform};
 pub use self::transform::{TransformOrigin, TransformStyle, Translate};
 #[cfg(feature = "gecko")]
 pub use self::ui::CursorImage;
 pub use self::ui::{Cursor, MozForceBrokenImageIcon, UserSelect};
 pub use super::generics::grid::GridTemplateComponent as GenericGridTemplateComponent;