From a2f8af920366499f8235630720dd8a627a1dc667 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 9 Jul 2017 20:57:06 +0200 Subject: [PATCH 01/11] style: Derive Default for EagerPseudoStyles. MozReview-Commit-ID: HkTtrV5CcF0 --- components/style/data.rs | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/components/style/data.rs b/components/style/data.rs index 7888445943d..197f2818714 100644 --- a/components/style/data.rs +++ b/components/style/data.rs @@ -105,7 +105,7 @@ impl RestyleData { /// not require duplicate allocations. We leverage the copy-on-write semantics of /// Arc::make_mut(), which is free (i.e. does not require atomic RMU operations) /// in servo_arc. -#[derive(Clone, Debug)] +#[derive(Clone, Debug, Default)] pub struct EagerPseudoStyles(Option>); #[derive(Debug, Default)] @@ -234,7 +234,7 @@ impl EagerPseudoStyles { /// The styles associated with a node, including the styles for any /// pseudo-elements. -#[derive(Clone, Debug)] +#[derive(Clone, Debug, Default)] pub struct ElementStyles { /// The element's style. pub primary: Option>, @@ -242,16 +242,6 @@ pub struct ElementStyles { pub pseudos: EagerPseudoStyles, } -impl Default for ElementStyles { - /// Construct an empty `ElementStyles`. - fn default() -> Self { - ElementStyles { - primary: None, - pseudos: EagerPseudoStyles(None), - } - } -} - impl ElementStyles { /// Returns the primary style. pub fn get_primary(&self) -> Option<&Arc> { From 95a2ac51c4da93c55b8f678dac35c7d640fb4a1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 9 Jul 2017 20:59:39 +0200 Subject: [PATCH 02/11] style: Remove unused AFFECTED_BY_PSEUDO_ELEMENTS StyleRelation. MozReview-Commit-ID: yHldvHm87b --- components/selectors/context.rs | 2 -- components/style/matching.rs | 9 ++------- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/components/selectors/context.rs b/components/selectors/context.rs index 12ebd977837..e27cd6811bb 100644 --- a/components/selectors/context.rs +++ b/components/selectors/context.rs @@ -15,8 +15,6 @@ bitflags! { /// Whether this element is affected by presentational hints. This is /// computed externally (that is, in Servo). const AFFECTED_BY_PRESENTATIONAL_HINTS = 1 << 0, - /// Whether this element has pseudo-element styles. Computed externally. - const AFFECTED_BY_PSEUDO_ELEMENTS = 1 << 1, } } diff --git a/components/style/matching.rs b/components/style/matching.rs index b10a3204e32..bb510840bea 100644 --- a/components/style/matching.rs +++ b/components/style/matching.rs @@ -24,7 +24,7 @@ use properties::longhands::display::computed_value as display; use rule_tree::{CascadeLevel, StrongRuleNode}; use selector_parser::{PseudoElement, RestyleDamage, SelectorImpl}; use selectors::matching::{ElementSelectorFlags, MatchingContext, MatchingMode, StyleRelations}; -use selectors::matching::{VisitedHandlingMode, AFFECTED_BY_PSEUDO_ELEMENTS}; +use selectors::matching::VisitedHandlingMode; use sharing::StyleSharingBehavior; use stylearc::Arc; use stylist::RuleInclusion; @@ -1003,7 +1003,7 @@ pub trait MatchMethods : TElement { debug!("Match and cascade for {:?}", self); // Perform selector matching for the primary style. - let mut primary_results = + let primary_results = self.match_primary(context, data, VisitedHandlingMode::AllLinksUnvisited); let important_rules_changed = primary_results.important_rules_overriding_animation_changed; @@ -1051,11 +1051,6 @@ pub trait MatchMethods : TElement { self.cascade_pseudos(context, data, CascadeVisitedMode::Unvisited); } - // If we have any pseudo elements, indicate so in the primary StyleRelations. - if !data.styles.pseudos.is_empty() { - primary_results.relations |= AFFECTED_BY_PSEUDO_ELEMENTS; - } - // If the style is shareable, add it to the LRU cache. if sharing == StyleSharingBehavior::Allow { // If we previously tried to match this element against the cache, From cc94a8b7cb1849baef91280e6fd078aece4cd58c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 9 Jul 2017 21:01:00 +0200 Subject: [PATCH 03/11] style: Undo the optimization for grabbing animation rules from the style data. This is unfortunate, but for now it complicates things, I would like not needing a ElementData to get the style of an Element in order to fix all the getDefaultComputedStyle bugs. MozReview-Commit-ID: LZvsdFEqrDE --- components/style/data.rs | 29 +-------- components/style/dom.rs | 14 ++++- components/style/matching.rs | 60 ++++++++++--------- .../style/properties/declaration_block.rs | 6 +- components/style/rule_tree/mod.rs | 28 +-------- 5 files changed, 51 insertions(+), 86 deletions(-) diff --git a/components/style/data.rs b/components/style/data.rs index 197f2818714..a62d1359e1a 100644 --- a/components/style/data.rs +++ b/components/style/data.rs @@ -8,11 +8,11 @@ use arrayvec::ArrayVec; use context::SharedStyleContext; use dom::TElement; use invalidation::element::restyle_hints::RestyleHint; -use properties::{AnimationRules, ComputedValues, PropertyDeclarationBlock}; +use properties::ComputedValues; use properties::longhands::display::computed_value as display; use rule_tree::StrongRuleNode; use selector_parser::{EAGER_PSEUDO_COUNT, PseudoElement, RestyleDamage}; -use shared_lock::{Locked, StylesheetGuards}; +use shared_lock::StylesheetGuards; use std::ops::{Deref, DerefMut}; use stylearc::Arc; @@ -402,29 +402,4 @@ impl ElementData { pub fn clear_restyle_state(&mut self) { self.restyle.clear(); } - - /// Returns SMIL overriden value if exists. - pub fn get_smil_override(&self) -> Option<&Arc>> { - if cfg!(feature = "servo") { - // Servo has no knowledge of a SMIL rule, so just avoid looking for it. - return None; - } - - match self.styles.get_primary() { - Some(v) => v.rules().get_smil_animation_rule(), - None => None, - } - } - - /// Returns AnimationRules that has processed during animation-only restyles. - pub fn get_animation_rules(&self) -> AnimationRules { - if cfg!(feature = "servo") { - return AnimationRules(None, None) - } - - match self.styles.get_primary() { - Some(v) => v.rules().get_animation_rules(), - None => AnimationRules(None, None), - } - } } diff --git a/components/style/dom.rs b/components/style/dom.rs index ac5d051e865..ffb874430f6 100644 --- a/components/style/dom.rs +++ b/components/style/dom.rs @@ -15,7 +15,7 @@ use data::ElementData; use element_state::ElementState; use font_metrics::FontMetricsProvider; use media_queries::Device; -use properties::{ComputedValues, PropertyDeclarationBlock}; +use properties::{AnimationRules, ComputedValues, PropertyDeclarationBlock}; #[cfg(feature = "gecko")] use properties::animated_properties::AnimationValue; #[cfg(feature = "gecko")] use properties::animated_properties::TransitionProperty; use rule_tree::CascadeLevel; @@ -379,6 +379,18 @@ pub trait TElement : Eq + PartialEq + Debug + Hash + Sized + Copy + Clone + None } + /// Get the combined animation and transition rules. + fn get_animation_rules(&self) -> AnimationRules { + if !self.may_have_animations() { + return AnimationRules(None, None) + } + + AnimationRules( + self.get_animation_rule(), + self.get_transition_rule(), + ) + } + /// Get this element's animation rule. fn get_animation_rule(&self) -> Option>> { diff --git a/components/style/matching.rs b/components/style/matching.rs index bb510840bea..0cd55918457 100644 --- a/components/style/matching.rs +++ b/components/style/matching.rs @@ -237,7 +237,7 @@ impl CascadeVisitedMode { /// Returns whether there might be visited values that should be inserted /// within the regular computed values based on the cascade mode. - fn visited_values_for_insertion(&self) -> bool { + pub fn visited_values_for_insertion(&self) -> bool { *self == CascadeVisitedMode::Unvisited } @@ -258,7 +258,7 @@ impl CascadeVisitedMode { /// Returns whether the cascade should filter to only visited dependent /// properties based on the cascade mode. - fn visited_dependent_only(&self) -> bool { + pub fn visited_dependent_only(&self) -> bool { *self == CascadeVisitedMode::Visited } } @@ -446,7 +446,7 @@ trait PrivateMatchMethods: TElement { debug_assert!(pseudo.is_before_or_after()); let parent = self.parent_element().unwrap(); if !parent.may_have_animations() || - primary_inputs.rules().get_animation_rules().is_empty() { + self.get_animation_rules().is_empty() { let parent_data = parent.borrow_data().unwrap(); let pseudo_style = parent_data.styles.pseudos.get(&pseudo).unwrap(); @@ -994,12 +994,12 @@ impl MatchingResults { pub trait MatchMethods : TElement { /// Performs selector matching and property cascading on an element and its /// eager pseudos. - fn match_and_cascade(&self, - context: &mut StyleContext, - data: &mut ElementData, - sharing: StyleSharingBehavior) - -> ChildCascadeRequirement - { + fn match_and_cascade( + &self, + context: &mut StyleContext, + data: &mut ElementData, + sharing: StyleSharingBehavior + ) -> ChildCascadeRequirement { debug!("Match and cascade for {:?}", self); // Perform selector matching for the primary style. @@ -1021,16 +1021,24 @@ pub trait MatchMethods : TElement { // if our parent has visited styles. let parent_and_styles = self.get_inherited_style_and_parent(); if relevant_link_found || parent_and_styles.has_visited_style() { - self.cascade_primary(context, data, important_rules_changed, - &parent_and_styles, - CascadeVisitedMode::Visited); + self.cascade_primary( + context, + data, + important_rules_changed, + &parent_and_styles, + CascadeVisitedMode::Visited + ); } // Cascade properties and compute primary values. let child_cascade_requirement = - self.cascade_primary(context, data, important_rules_changed, - &parent_and_styles, - CascadeVisitedMode::Unvisited); + self.cascade_primary( + context, + data, + important_rules_changed, + &parent_and_styles, + CascadeVisitedMode::Unvisited + ); // Match and cascade eager pseudo-elements. if !data.styles.is_display_none() { @@ -1109,12 +1117,12 @@ pub trait MatchMethods : TElement { /// /// Returns `MatchingResults` with the new rules and other associated data /// from the matching process. - fn match_primary(&self, - context: &mut StyleContext, - data: &mut ElementData, - visited_handling: VisitedHandlingMode) - -> MatchingResults - { + fn match_primary( + &self, + context: &mut StyleContext, + data: &mut ElementData, + visited_handling: VisitedHandlingMode + ) -> MatchingResults { debug!("Match primary for {:?}, visited: {:?}", self, visited_handling); let mut primary_inputs = context.thread_local.current_element_info @@ -1145,7 +1153,7 @@ pub trait MatchMethods : TElement { parent_data.styles.pseudos.get(&pseudo).unwrap(); let mut rules = pseudo_style.rules().clone(); if parent.may_have_animations() { - let animation_rules = data.get_animation_rules(); + let animation_rules = self.get_animation_rules(); // Handle animations here. if let Some(animation_rule) = animation_rules.0 { @@ -1208,12 +1216,8 @@ pub trait MatchMethods : TElement { context.shared.quirks_mode); { - let smil_override = data.get_smil_override(); - let animation_rules = if self.may_have_animations() { - data.get_animation_rules() - } else { - AnimationRules(None, None) - }; + let smil_override = self.get_smil_override(); + let animation_rules = self.get_animation_rules(); // Compute the primary rule node. stylist.push_applicable_declarations(self, diff --git a/components/style/properties/declaration_block.rs b/components/style/properties/declaration_block.rs index 5a6eed8c5af..a90627aae41 100644 --- a/components/style/properties/declaration_block.rs +++ b/components/style/properties/declaration_block.rs @@ -28,10 +28,10 @@ use values::computed::Context; /// /// The first one is for Animation cascade level, and the second one is for /// Transition cascade level. -pub struct AnimationRules<'a>(pub Option<&'a Arc>>, - pub Option<&'a Arc>>); +pub struct AnimationRules(pub Option>>, + pub Option>>); -impl<'a> AnimationRules<'a> { +impl AnimationRules { /// Returns whether these animation rules represents an actual rule or not. pub fn is_empty(&self) -> bool { self.0.is_none() && self.1.is_none() diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs index 4ef94cd12a2..25cf08efb2b 100644 --- a/components/style/rule_tree/mod.rs +++ b/components/style/rule_tree/mod.rs @@ -9,7 +9,7 @@ use applicable_declarations::ApplicableDeclarationList; #[cfg(feature = "servo")] use heapsize::HeapSizeOf; -use properties::{AnimationRules, Importance, LonghandIdSet, PropertyDeclarationBlock}; +use properties::{Importance, LonghandIdSet, PropertyDeclarationBlock}; use shared_lock::{Locked, StylesheetGuards, SharedRwLockReadGuard}; use smallvec::SmallVec; use std::io::{self, Write}; @@ -1321,32 +1321,6 @@ impl StrongRuleNode { .find(|node| node.cascade_level() == CascadeLevel::SMILOverride) .map(|node| node.get_animation_style()) } - - /// Returns AnimationRules that has processed during animation-only restyles. - pub fn get_animation_rules(&self) -> AnimationRules { - if cfg!(feature = "servo") { - return AnimationRules(None, None); - } - - let mut animation = None; - let mut transition = None; - - for node in self.self_and_ancestors() - .take_while(|node| node.cascade_level() >= CascadeLevel::Animations) { - match node.cascade_level() { - CascadeLevel::Animations => { - debug_assert!(animation.is_none()); - animation = Some(node.get_animation_style()) - }, - CascadeLevel::Transitions => { - debug_assert!(transition.is_none()); - transition = Some(node.get_animation_style()) - }, - _ => {}, - } - } - AnimationRules(animation, transition) - } } /// An iterator over a rule node and its ancestors. From fcf85e46582f9321bc165746ac13acf05413bbab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 9 Jul 2017 21:02:21 +0200 Subject: [PATCH 04/11] style: Make RuleTree::root return a reference instead of a strong pointer. There's no reason it wasn't done before. MozReview-Commit-ID: G0lMLWmfHbS --- components/style/rule_tree/mod.rs | 26 +++++++------- components/style/stylist.rs | 59 ++++++++++++------------------- 2 files changed, 37 insertions(+), 48 deletions(-) diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs index 25cf08efb2b..a6a729fe2d5 100644 --- a/components/style/rule_tree/mod.rs +++ b/components/style/rule_tree/mod.rs @@ -150,8 +150,8 @@ impl RuleTree { } /// Get the root rule node. - pub fn root(&self) -> StrongRuleNode { - self.root.clone() + pub fn root(&self) -> &StrongRuleNode { + &self.root } fn dump(&self, guards: &StylesheetGuards, writer: &mut W) { @@ -171,11 +171,13 @@ impl RuleTree { /// !important rules are detected and inserted into the appropriate position /// in the rule tree. This allows selector matching to ignore importance, /// while still maintaining the appropriate cascade order in the rule tree. - pub fn insert_ordered_rules_with_important<'a, I>(&self, - iter: I, - guards: &StylesheetGuards) - -> StrongRuleNode - where I: Iterator, + pub fn insert_ordered_rules_with_important<'a, I>( + &self, + iter: I, + guards: &StylesheetGuards + ) -> StrongRuleNode + where + I: Iterator, { use self::CascadeLevel::*; let mut current = self.root.clone(); @@ -257,11 +259,11 @@ impl RuleTree { /// Given a list of applicable declarations, insert the rules and return the /// corresponding rule node. - pub fn compute_rule_node(&self, - applicable_declarations: &mut ApplicableDeclarationList, - guards: &StylesheetGuards) - -> StrongRuleNode - { + pub fn compute_rule_node( + &self, + applicable_declarations: &mut ApplicableDeclarationList, + guards: &StylesheetGuards + ) -> StrongRuleNode { let rules = applicable_declarations.drain().map(|d| d.order_and_level()); let rule_node = self.insert_ordered_rules_with_important(rules, guards); rule_node diff --git a/components/style/stylist.rs b/components/style/stylist.rs index 427147e7e4f..0a7f6c105f8 100644 --- a/components/style/stylist.rs +++ b/components/style/stylist.rs @@ -21,7 +21,7 @@ use properties::{self, CascadeFlags, ComputedValues}; use properties::{AnimationRules, PropertyDeclarationBlock}; #[cfg(feature = "servo")] use properties::INHERIT_ALL; -use rule_tree::{CascadeLevel, RuleTree, StrongRuleNode, StyleSource}; +use rule_tree::{CascadeLevel, RuleTree, StyleSource}; use selector_map::{SelectorMap, SelectorMapEntry}; use selector_parser::{SelectorImpl, PseudoElement}; use selectors::attr::NamespaceConstraint; @@ -607,13 +607,12 @@ impl Stylist { let rule_node = match self.precomputed_pseudo_element_decls.get(pseudo) { Some(declarations) => { - // FIXME(emilio): When we've taken rid of the cascade we can just - // use into_iter. self.rule_tree.insert_ordered_rules_with_important( declarations.into_iter().map(|a| (a.source.clone(), a.level())), - guards) + guards + ) } - None => self.rule_tree.root(), + None => self.rule_tree.root().clone(), }; // NOTE(emilio): We skip calculating the proper layout parent style @@ -757,13 +756,7 @@ impl Stylist { // We may not have non-visited rules, if we only had visited ones. In // that case we want to use the root rulenode for our non-visited rules. - let root; - let rules = if let Some(rules) = inputs.get_rules() { - rules - } else { - root = self.rule_tree.root(); - &root - }; + let rules = inputs.get_rules().unwrap_or(self.rule_tree.root()); // Read the comment on `precomputed_values_for_pseudo` to see why it's // difficult to assert that display: contents nodes never arrive here @@ -839,25 +832,25 @@ impl Stylist { MatchingContext::new(MatchingMode::ForStatelessPseudoElement, None, self.quirks_mode); - self.push_applicable_declarations(element, - Some(&pseudo), - None, - None, - AnimationRules(None, None), - rule_inclusion, - &mut declarations, - &mut matching_context, - &mut set_selector_flags); + + self.push_applicable_declarations( + element, + Some(&pseudo), + None, + None, + AnimationRules(None, None), + rule_inclusion, + &mut declarations, + &mut matching_context, + &mut set_selector_flags + ); if !declarations.is_empty() { - let rule_node = self.rule_tree.insert_ordered_rules_with_important( - declarations.into_iter().map(|a| a.order_and_level()), - guards); - if rule_node != self.rule_tree.root() { - inputs.set_rules(VisitedHandlingMode::AllLinksUnvisited, - rule_node); - } - }; + let rule_node = + self.rule_tree.compute_rule_node(&mut declarations, guards); + debug_assert!(rule_node != *self.rule_tree.root()); + inputs.set_rules(VisitedHandlingMode::AllLinksUnvisited, rule_node); + } if is_probe && !inputs.has_rules() { // When probing, don't compute visited styles if we have no @@ -886,7 +879,7 @@ impl Stylist { self.rule_tree.insert_ordered_rules_with_important( declarations.into_iter().map(|a| a.order_and_level()), guards); - if rule_node != self.rule_tree.root() { + if rule_node != *self.rule_tree.root() { inputs.set_rules(VisitedHandlingMode::RelevantLinkVisited, rule_node); } @@ -1295,12 +1288,6 @@ impl Stylist { &self.animations } - /// Returns the rule root node. - #[inline] - pub fn rule_tree_root(&self) -> StrongRuleNode { - self.rule_tree.root() - } - /// Computes the match results of a given element against the set of /// revalidation selectors. pub fn match_revalidation_selectors(&self, From b4c8ba30294dd7e96d2c7681f194094830fd8fb2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 9 Jul 2017 21:19:04 +0200 Subject: [PATCH 05/11] style: Introduce StyleResolverForElement. This still doesn't make use of it so far, but I prefer introducing it atomically, then introduce its usage. MozReview-Commit-ID: 9dRUsl3srHp --- components/style/lib.rs | 1 + components/style/style_resolver.rs | 370 +++++++++++++++++++++++++++++ 2 files changed, 371 insertions(+) create mode 100644 components/style/style_resolver.rs diff --git a/components/style/lib.rs b/components/style/lib.rs index 41d9815bff8..5775dc1001b 100644 --- a/components/style/lib.rs +++ b/components/style/lib.rs @@ -123,6 +123,7 @@ pub mod selector_map; pub mod selector_parser; pub mod shared_lock; pub mod sharing; +pub mod style_resolver; pub mod stylist; #[cfg(feature = "servo")] #[allow(unsafe_code)] pub mod servo; pub mod sequential; diff --git a/components/style/style_resolver.rs b/components/style/style_resolver.rs new file mode 100644 index 00000000000..cecb52cd9eb --- /dev/null +++ b/components/style/style_resolver.rs @@ -0,0 +1,370 @@ +/* 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 http://mozilla.org/MPL/2.0/. */ + +//! Style resolution for a given element or pseudo-element. + +use applicable_declarations::ApplicableDeclarationList; +use cascade_info::CascadeInfo; +use context::StyleContext; +use data::{ElementStyles, EagerPseudoStyles}; +use dom::TElement; +use log::LogLevel::Trace; +use matching::{CascadeVisitedMode, MatchMethods}; +use properties::{AnimationRules, CascadeFlags, ComputedValues}; +use properties::{IS_ROOT_ELEMENT, PROHIBIT_DISPLAY_CONTENTS, SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP}; +use properties::{VISITED_DEPENDENT_ONLY, cascade}; +use rule_tree::StrongRuleNode; +use selector_parser::{PseudoElement, SelectorImpl}; +use selectors::matching::{ElementSelectorFlags, MatchingContext, MatchingMode, VisitedHandlingMode}; +use stylearc::Arc; +use stylist::RuleInclusion; + +/// A struct that takes care of resolving the style of a given element. +pub struct StyleResolverForElement<'a, 'b, E> +where + 'b: 'a, + E: TElement + MatchMethods + 'static, +{ + element: E, + context: &'a mut StyleContext<'b, E>, + rule_inclusion: RuleInclusion, +} + +struct MatchingResults { + rule_node: StrongRuleNode, + relevant_link_found: bool, +} + +/// The primary style of an element or an element-backed pseudo-element. +pub struct PrimaryStyle { + /// The style per se. + pub style: Arc, + + /// Whether a relevant link was found while computing this style. + /// + /// FIXME(emilio): Slightly out of place? + pub relevant_link_found: bool, +} + +impl<'a, 'b, E> StyleResolverForElement<'a, 'b, E> +where + 'b: 'a, + E: TElement + MatchMethods + 'static, +{ + /// Trivially construct a new StyleResolverForElement. + pub fn new( + element: E, + context: &'a mut StyleContext<'b, E>, + rule_inclusion: RuleInclusion, + ) -> Self { + Self { element, context, rule_inclusion, } + } + + /// Resolve just the style of a given element. + pub fn resolve_primary_style( + &mut self, + parent_style: Option<&ComputedValues>, + layout_parent_style: Option<&ComputedValues>, + ) -> PrimaryStyle { + let primary_results = + self.match_primary(VisitedHandlingMode::AllLinksUnvisited); + + let relevant_link_found = primary_results.relevant_link_found; + + let visited_rules = if relevant_link_found { + let visited_matching_results = + self.match_primary(VisitedHandlingMode::RelevantLinkVisited); + Some(visited_matching_results.rule_node) + } else { + None + }; + + let mut visited_style = None; + let should_compute_visited_style = + relevant_link_found || + parent_style.and_then(|s| s.get_visited_style()).is_some(); + + if should_compute_visited_style { + visited_style = Some(self.cascade_style( + visited_rules.as_ref().unwrap_or(&primary_results.rule_node), + /* style_if_visited = */ None, + parent_style, + layout_parent_style, + CascadeVisitedMode::Visited, + /* pseudo = */ None, + )); + } + + let style = self.cascade_style( + &primary_results.rule_node, + visited_style, + parent_style, + layout_parent_style, + CascadeVisitedMode::Unvisited, + /* pseudo = */ None, + ); + + PrimaryStyle { style, relevant_link_found, } + } + + + /// Resolve the style of a given element, and all its eager pseudo-elements. + pub fn resolve_style( + &mut self, + parent_style: Option<&ComputedValues>, + layout_parent_style: Option<&ComputedValues>, + ) -> ElementStyles { + use properties::longhands::display::computed_value::T as display; + + let primary_style = + self.resolve_primary_style(parent_style, layout_parent_style); + + let mut pseudo_styles = EagerPseudoStyles::default(); + if primary_style.style.get_box().clone_display() == display::none { + return ElementStyles { + // FIXME(emilio): Remove the Option<>. + primary: Some(primary_style.style), + pseudos: pseudo_styles, + } + } + + { + let layout_parent_style_for_pseudo = + if primary_style.style.is_display_contents() { + layout_parent_style + } else { + Some(&*primary_style.style) + }; + SelectorImpl::each_eagerly_cascaded_pseudo_element(|pseudo| { + let pseudo_style = self.resolve_pseudo_style( + &pseudo, + &primary_style, + layout_parent_style_for_pseudo + ); + if let Some(style) = pseudo_style { + pseudo_styles.set(&pseudo, style); + } + }) + } + + ElementStyles { + // FIXME(emilio): Remove the Option<>. + primary: Some(primary_style.style), + pseudos: pseudo_styles, + } + } + + fn resolve_pseudo_style( + &mut self, + pseudo: &PseudoElement, + originating_element_style: &PrimaryStyle, + layout_parent_style: Option<&ComputedValues>, + ) -> Option> { + let rules = self.match_pseudo( + &originating_element_style.style, + pseudo, + VisitedHandlingMode::AllLinksUnvisited + ); + let rules = match rules { + Some(rules) => rules, + None => return None, + }; + + let mut visited_style = None; + if originating_element_style.relevant_link_found { + let visited_rules = self.match_pseudo( + &originating_element_style.style, + pseudo, + VisitedHandlingMode::RelevantLinkVisited, + ); + + if let Some(ref rules) = visited_rules { + visited_style = Some(self.cascade_style( + rules, + /* style_if_visited = */ None, + Some(&originating_element_style.style), + layout_parent_style, + CascadeVisitedMode::Visited, + Some(pseudo), + )); + } + } + + Some(self.cascade_style( + &rules, + visited_style, + Some(&originating_element_style.style), + layout_parent_style, + CascadeVisitedMode::Unvisited, + Some(pseudo) + )) + } + + fn match_primary( + &mut self, + visited_handling: VisitedHandlingMode, + ) -> MatchingResults { + debug!("Match primary for {:?}, visited: {:?}", + self.element, visited_handling); + let mut applicable_declarations = ApplicableDeclarationList::new(); + + let map = &mut self.context.thread_local.selector_flags; + let bloom_filter = self.context.thread_local.bloom_filter.filter(); + let mut matching_context = + MatchingContext::new_for_visited( + MatchingMode::Normal, + Some(bloom_filter), + visited_handling, + self.context.shared.quirks_mode + ); + + let stylist = &self.context.shared.stylist; + let implemented_pseudo = self.element.implemented_pseudo_element(); + { + let resolving_element = self.element; + let mut set_selector_flags = |element: &E, flags: ElementSelectorFlags| { + resolving_element.apply_selector_flags(map, element, flags); + }; + + // Compute the primary rule node. + stylist.push_applicable_declarations( + &self.element, + implemented_pseudo.as_ref(), + self.element.style_attribute(), + self.element.get_smil_override(), + self.element.get_animation_rules(), + self.rule_inclusion, + &mut applicable_declarations, + &mut matching_context, + &mut set_selector_flags, + ); + } + + // FIXME(emilio): This is a hack for animations, and should go away. + self.element.unset_dirty_style_attribute(); + + let relevant_link_found = matching_context.relevant_link_found; + let rule_node = stylist.rule_tree().compute_rule_node( + &mut applicable_declarations, + &self.context.shared.guards + ); + + if log_enabled!(Trace) { + trace!("Matched rules:"); + for rn in rule_node.self_and_ancestors() { + let source = rn.style_source(); + if source.is_some() { + trace!(" > {:?}", source); + } + } + } + + MatchingResults { rule_node, relevant_link_found } + } + + fn match_pseudo( + &mut self, + originating_element_style: &ComputedValues, + pseudo_element: &PseudoElement, + visited_handling: VisitedHandlingMode, + ) -> Option { + debug!("Match pseudo {:?} for {:?}, visited: {:?}", + self.element, pseudo_element, visited_handling); + debug_assert!(pseudo_element.is_eager() || pseudo_element.is_lazy()); + debug_assert!(self.element.implemented_pseudo_element().is_none(), + "Element pseudos can't have any other pseudo."); + + let mut applicable_declarations = ApplicableDeclarationList::new(); + + let stylist = &self.context.shared.stylist; + + if !self.element.may_generate_pseudo(pseudo_element, originating_element_style) { + return None; + } + + let bloom_filter = self.context.thread_local.bloom_filter.filter(); + + let mut matching_context = + MatchingContext::new_for_visited( + MatchingMode::ForStatelessPseudoElement, + Some(bloom_filter), + visited_handling, + self.context.shared.quirks_mode + ); + + let map = &mut self.context.thread_local.selector_flags; + let resolving_element = self.element; + let mut set_selector_flags = |element: &E, flags: ElementSelectorFlags| { + resolving_element.apply_selector_flags(map, element, flags); + }; + + // NB: We handle animation rules for ::before and ::after when + // traversing them. + stylist.push_applicable_declarations( + &self.element, + Some(pseudo_element), + None, + None, + AnimationRules(None, None), + self.rule_inclusion, + &mut applicable_declarations, + &mut matching_context, + &mut set_selector_flags + ); + + if applicable_declarations.is_empty() { + return None; + } + + let rule_node = stylist.rule_tree().compute_rule_node( + &mut applicable_declarations, + &self.context.shared.guards + ); + + Some(rule_node) + } + + fn cascade_style( + &mut self, + rules: &StrongRuleNode, + style_if_visited: Option>, + parent_style: Option<&ComputedValues>, + layout_parent_style: Option<&ComputedValues>, + cascade_visited: CascadeVisitedMode, + pseudo: Option<&PseudoElement>, + ) -> Arc { + let mut cascade_info = CascadeInfo::new(); + let mut cascade_flags = CascadeFlags::empty(); + + if self.element.skip_root_and_item_based_display_fixup() { + cascade_flags.insert(SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP); + } + if cascade_visited.visited_dependent_only() { + cascade_flags.insert(VISITED_DEPENDENT_ONLY); + } + if self.element.is_native_anonymous() || pseudo.is_some() { + cascade_flags.insert(PROHIBIT_DISPLAY_CONTENTS); + } else if self.element.is_root() { + cascade_flags.insert(IS_ROOT_ELEMENT); + } + + let values = + Arc::new(cascade( + self.context.shared.stylist.device(), + rules, + &self.context.shared.guards, + parent_style, + layout_parent_style, + style_if_visited, + Some(&mut cascade_info), + &*self.context.shared.error_reporter, + &self.context.thread_local.font_metrics_provider, + cascade_flags, + self.context.shared.quirks_mode + )); + + cascade_info.finish(&self.element.as_node()); + values + } +} From 0ad2d39c30ac2827e4956224de578f2dea78916d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 9 Jul 2017 22:12:59 +0200 Subject: [PATCH 06/11] style: Rewrite get*Style using StyleResolverForElement. Removing the ugly. MozReview-Commit-ID: BvahbMKS7QU --- components/layout/query.rs | 52 +++++--- components/style/style_resolver.rs | 26 ++-- components/style/traversal.rs | 206 ++++++++++------------------- ports/geckolib/glue.rs | 20 +-- 4 files changed, 126 insertions(+), 178 deletions(-) diff --git a/components/layout/query.rs b/components/layout/query.rs index ae7a506124b..e96d50890be 100644 --- a/components/layout/query.rs +++ b/components/layout/query.rs @@ -37,7 +37,7 @@ use style::selector_parser::PseudoElement; use style_traits::ToCss; use style_traits::cursor::Cursor; use webrender_traits::ClipId; -use wrapper::{LayoutNodeHelpers, LayoutNodeLayoutData}; +use wrapper::LayoutNodeLayoutData; /// Mutable data belonging to the LayoutThread. /// @@ -680,7 +680,9 @@ pub fn process_resolved_style_request<'a, N>(context: &LayoutContext, layout_root: &mut Flow) -> String where N: LayoutNode, { + use style::stylist::RuleInclusion; use style::traversal::resolve_style; + let element = node.as_element().unwrap(); // We call process_resolved_style_request after performing a whole-document @@ -689,30 +691,43 @@ pub fn process_resolved_style_request<'a, N>(context: &LayoutContext, return process_resolved_style_request_internal(node, pseudo, property, layout_root); } - // However, the element may be in a display:none subtree. The style system - // has a mechanism to give us that within a defined scope (after which point - // it's cleared to maintained style system invariants). + // In a display: none subtree. No pseudo-element exists. + if pseudo.is_some() { + return String::new(); + } + let mut tlc = ThreadLocalStyleContext::new(&context.style_context); let mut context = StyleContext { shared: &context.style_context, thread_local: &mut tlc, }; - let mut result = None; - let ensure = |el: N::ConcreteElement| el.as_node().initialize_data(); - let clear = |el: N::ConcreteElement| el.as_node().clear_data(); - resolve_style(&mut context, element, &ensure, &clear, |_: &_| { - let s = process_resolved_style_request_internal(node, pseudo, property, layout_root); - result = Some(s); - }); - result.unwrap() + + let styles = resolve_style(&mut context, element, RuleInclusion::All); + let style = styles.primary(); + let longhand_id = match *property { + PropertyId::Longhand(id) => id, + // Firefox returns blank strings for the computed value of shorthands, + // so this should be web-compatible. + PropertyId::Shorthand(_) => return String::new(), + PropertyId::Custom(ref name) => { + return style.computed_value_to_string(PropertyDeclarationId::Custom(name)) + } + }; + + // No need to care about used values here, since we're on a display: none + // subtree, use the resolved value. + style.computed_value_to_string(PropertyDeclarationId::Longhand(longhand_id)) } /// The primary resolution logic, which assumes that the element is styled. -fn process_resolved_style_request_internal<'a, N>(requested_node: N, - pseudo: &Option, - property: &PropertyId, - layout_root: &mut Flow) -> String - where N: LayoutNode, +fn process_resolved_style_request_internal<'a, N>( + requested_node: N, + pseudo: &Option, + property: &PropertyId, + layout_root: &mut Flow, +) -> String +where + N: LayoutNode, { let layout_el = requested_node.to_threadsafe().as_element().unwrap(); let layout_el = match *pseudo { @@ -721,6 +736,8 @@ fn process_resolved_style_request_internal<'a, N>(requested_node: N, Some(PseudoElement::DetailsSummary) | Some(PseudoElement::DetailsContent) | Some(PseudoElement::Selection) => None, + // FIXME(emilio): What about the other pseudos? Probably they shouldn't + // just return the element's style! _ => Some(layout_el) }; @@ -735,7 +752,6 @@ fn process_resolved_style_request_internal<'a, N>(requested_node: N, }; let style = &*layout_el.resolved_style(); - let longhand_id = match *property { PropertyId::Longhand(id) => id, diff --git a/components/style/style_resolver.rs b/components/style/style_resolver.rs index cecb52cd9eb..e926ba69f95 100644 --- a/components/style/style_resolver.rs +++ b/components/style/style_resolver.rs @@ -21,14 +21,16 @@ use stylearc::Arc; use stylist::RuleInclusion; /// A struct that takes care of resolving the style of a given element. -pub struct StyleResolverForElement<'a, 'b, E> +pub struct StyleResolverForElement<'a, 'ctx, 'le, E> where - 'b: 'a, - E: TElement + MatchMethods + 'static, + 'ctx: 'a, + 'le: 'ctx, + E: TElement + MatchMethods + 'le, { element: E, - context: &'a mut StyleContext<'b, E>, + context: &'a mut StyleContext<'ctx, E>, rule_inclusion: RuleInclusion, + _marker: ::std::marker::PhantomData<&'le E>, } struct MatchingResults { @@ -47,18 +49,24 @@ pub struct PrimaryStyle { pub relevant_link_found: bool, } -impl<'a, 'b, E> StyleResolverForElement<'a, 'b, E> +impl<'a, 'ctx, 'le, E> StyleResolverForElement<'a, 'ctx, 'le, E> where - 'b: 'a, - E: TElement + MatchMethods + 'static, + 'ctx: 'a, + 'le: 'ctx, + E: TElement + MatchMethods + 'le, { /// Trivially construct a new StyleResolverForElement. pub fn new( element: E, - context: &'a mut StyleContext<'b, E>, + context: &'a mut StyleContext<'ctx, E>, rule_inclusion: RuleInclusion, ) -> Self { - Self { element, context, rule_inclusion, } + Self { + element, + context, + rule_inclusion, + _marker: ::std::marker::PhantomData, + } } /// Resolve just the style of a given element. diff --git a/components/style/traversal.rs b/components/style/traversal.rs index 47203980fc5..d7b0835a991 100644 --- a/components/style/traversal.rs +++ b/components/style/traversal.rs @@ -7,12 +7,12 @@ use atomic_refcell::AtomicRefCell; use context::{ElementCascadeInputs, StyleContext, SharedStyleContext}; use data::{ElementData, ElementStyles}; -use dom::{DirtyDescendants, NodeInfo, OpaqueNode, TElement, TNode}; +use dom::{NodeInfo, OpaqueNode, TElement, TNode}; use invalidation::element::restyle_hints::{RECASCADE_SELF, RECASCADE_DESCENDANTS, RestyleHint}; use matching::{ChildCascadeRequirement, MatchMethods}; use sharing::{StyleSharingBehavior, StyleSharingTarget}; -#[cfg(feature = "servo")] use servo_config::opts; use smallvec::SmallVec; +use stylist::RuleInclusion; /// A per-traversal-level chunk of data. This is sent down by the traversal, and /// currently only holds the dom depth for the bloom filter. @@ -126,6 +126,8 @@ impl TraversalDriver { #[cfg(feature = "servo")] fn is_servo_nonincremental_layout() -> bool { + use servo_config::opts; + opts::get().nonincremental_layout } @@ -520,151 +522,87 @@ pub trait DomTraversal : Sync { fn is_parallel(&self) -> bool; } -/// Helper for the function below. -fn resolve_style_internal( - context: &mut StyleContext, - element: E, ensure_data: &F -) -> Option - where E: TElement, - F: Fn(E), -{ - ensure_data(element); - let mut data = element.mutate_data().unwrap(); - let mut display_none_root = None; - - // If the Element isn't styled, we need to compute its style. - if !data.has_styles() { - // Compute the parent style if necessary. - let parent = element.traversal_parent(); - if let Some(p) = parent { - display_none_root = resolve_style_internal(context, p, ensure_data); - } - - // Maintain the bloom filter. If it doesn't exist, we need to build it - // from scratch. Otherwise we just need to push the parent. - if context.thread_local.bloom_filter.is_empty() { - context.thread_local.bloom_filter.rebuild(element); - } else { - context.thread_local.bloom_filter.push(parent.unwrap()); - context.thread_local.bloom_filter.assert_complete(element); - } - - // Compute our style. - context.thread_local.begin_element(element, &data); - element.match_and_cascade(context, - &mut data, - StyleSharingBehavior::Disallow); - context.thread_local.end_element(element); - - if !context.shared.traversal_flags.for_default_styles() { - // Conservatively mark us as having dirty descendants, since there - // might be other unstyled siblings we miss when walking straight up - // the parent chain. - // - // No need to do this if we're computing default styles, since - // resolve_default_style will want the tree to be left as it is. - unsafe { element.note_descendants::() }; - } - } - - // If we're display:none and none of our ancestors are, we're the root of a - // display:none subtree. - if display_none_root.is_none() && data.styles.is_display_none() { - display_none_root = Some(element); - } - - return display_none_root -} - /// Manually resolve style by sequentially walking up the parent chain to the /// first styled Element, ignoring pending restyles. The resolved style is made /// available via a callback, and can be dropped by the time this function /// returns in the display:none subtree case. -pub fn resolve_style(context: &mut StyleContext, element: E, - ensure_data: &F, clear_data: &G, callback: H) - where E: TElement, - F: Fn(E), - G: Fn(E), - H: FnOnce(&ElementStyles) +pub fn resolve_style( + context: &mut StyleContext, + element: E, + rule_inclusion: RuleInclusion, +) -> ElementStyles +where + E: TElement, { + use style_resolver::StyleResolverForElement; + + debug_assert!(rule_inclusion == RuleInclusion::DefaultOnly || + element.borrow_data().map_or(true, |d| !d.has_styles()), + "Why are we here?"); + let mut ancestors_requiring_style_resolution = SmallVec::<[E; 16]>::new(); + // Clear the bloom filter, just in case the caller is reusing TLS. context.thread_local.bloom_filter.clear(); - // Resolve styles up the tree. - let display_none_root = resolve_style_internal(context, element, ensure_data); - - // Make them available for the scope of the callback. The callee may use the - // argument, or perform any other processing that requires the styles to - // exist on the Element. - callback(&element.borrow_data().unwrap().styles); - - // Clear any styles in display:none subtrees or subtrees not in the - // document, to leave the tree in a valid state. For display:none subtrees, - // we leave the styles on the display:none root, but for subtrees not in the - // document, we clear styles all the way up to the root of the disconnected - // subtree. - let in_doc = element.as_node().is_in_doc(); - if !in_doc || display_none_root.is_some() { - let mut curr = element; - loop { - unsafe { - curr.unset_dirty_descendants(); - curr.unset_animation_only_dirty_descendants(); - } - if in_doc && curr == display_none_root.unwrap() { - break; - } - clear_data(curr); - curr = match curr.traversal_parent() { - Some(parent) => parent, - None => break, - }; - } - } -} - -/// Manually resolve default styles for the given Element, which are the styles -/// only taking into account user agent and user cascade levels. The resolved -/// style is made available via a callback, and will be dropped by the time this -/// function returns. -pub fn resolve_default_style( - context: &mut StyleContext, - element: E, - ensure_data: &F, - set_data: &G, - callback: H -) -where - E: TElement, - F: Fn(E), - G: Fn(E, Option) -> Option, - H: FnOnce(&ElementStyles), -{ - // Save and clear out element data from the element and its ancestors. - let mut old_data: SmallVec<[(E, Option); 8]> = SmallVec::new(); - { - let mut e = element; - loop { - old_data.push((e, set_data(e, None))); - match e.traversal_parent() { - Some(parent) => e = parent, - None => break, + let mut style = None; + let mut ancestor = element.traversal_parent(); + while let Some(current) = ancestor { + if rule_inclusion == RuleInclusion::All { + if let Some(data) = element.borrow_data() { + if let Some(ancestor_style) = data.styles.get_primary() { + style = Some(ancestor_style.clone()); + break; + } } } + ancestors_requiring_style_resolution.push(current); + ancestor = current.traversal_parent(); } - // Resolve styles up the tree. - resolve_style_internal(context, element, ensure_data); - - // Make them available for the scope of the callback. The callee may use the - // argument, or perform any other processing that requires the styles to - // exist on the Element. - callback(&element.borrow_data().unwrap().styles); - - // Swap the old element data back into the element and its ancestors. - for entry in old_data { - set_data(entry.0, entry.1); + if let Some(ancestor) = ancestor { + context.thread_local.bloom_filter.rebuild(ancestor); + context.thread_local.bloom_filter.push(ancestor); } + + let mut layout_parent_style = style.clone(); + while let Some(style) = layout_parent_style.take() { + if !style.is_display_contents() { + layout_parent_style = Some(style); + break; + } + + ancestor = ancestor.unwrap().traversal_parent(); + layout_parent_style = ancestor.map(|a| { + a.borrow_data().unwrap().styles.primary().clone() + }); + } + + for ancestor in ancestors_requiring_style_resolution.iter().rev() { + context.thread_local.bloom_filter.assert_complete(*ancestor); + + let primary_style = + StyleResolverForElement::new(*ancestor, context, rule_inclusion) + .resolve_primary_style( + style.as_ref().map(|s| &**s), + layout_parent_style.as_ref().map(|s| &**s) + ); + + let is_display_contents = primary_style.style.is_display_contents(); + + style = Some(primary_style.style); + if !is_display_contents { + layout_parent_style = style.clone(); + } + + context.thread_local.bloom_filter.push(*ancestor); + } + + context.thread_local.bloom_filter.assert_complete(element); + StyleResolverForElement::new(element, context, rule_inclusion) + .resolve_style( + style.as_ref().map(|s| &**s), + layout_parent_style.as_ref().map(|s| &**s) + ) } /// Calculates the style for a single node. diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs index 5edcc134fa3..3e049e1da3d 100644 --- a/ports/geckolib/glue.rs +++ b/ports/geckolib/glue.rs @@ -114,7 +114,7 @@ use style::thread_state; use style::timer::Timer; use style::traversal::{ANIMATION_ONLY, DomTraversal, FOR_CSS_RULE_CHANGES, FOR_RECONSTRUCT}; use style::traversal::{FOR_DEFAULT_STYLES, TraversalDriver, TraversalFlags, UNSTYLED_CHILDREN_ONLY}; -use style::traversal::{resolve_style, resolve_default_style}; +use style::traversal::resolve_style; use style::values::{CustomIdent, KeyframesName}; use style::values::computed::Context; use style_traits::{PARSING_MODE_DEFAULT, ToCss}; @@ -2775,7 +2775,6 @@ pub extern "C" fn Servo_ResolveStyleLazily(element: RawGeckoElementBorrowed, }; // We don't have the style ready. Go ahead and compute it as necessary. - let mut result = None; let shared = create_shared_context(&global_style_data, &guard, &data, @@ -2786,22 +2785,9 @@ pub extern "C" fn Servo_ResolveStyleLazily(element: RawGeckoElementBorrowed, shared: &shared, thread_local: &mut tlc, }; - let ensure = |el: GeckoElement| { unsafe { el.ensure_data(); } }; - match rule_inclusion { - RuleInclusion::All => { - let clear = |el: GeckoElement| el.clear_data(); - resolve_style(&mut context, element, &ensure, &clear, - |styles| result = Some(finish(styles))); - } - RuleInclusion::DefaultOnly => { - let set_data = |el: GeckoElement, data| { unsafe { el.set_data(data) } }; - resolve_default_style(&mut context, element, &ensure, &set_data, - |styles| result = Some(finish(styles))); - } - } - - result.unwrap().into_strong() + let styles = resolve_style(&mut context, element, rule_inclusion); + finish(&styles).into_strong() } #[cfg(feature = "gecko_debug")] From c6d5dbbb01eeb41865f0f070d9c72a0b7589ad09 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Wed, 12 Jul 2017 08:40:23 +0200 Subject: [PATCH 07/11] style: Rewrite restyling to split between resolving styles and handling changes. MozReview-Commit-ID: 4BzjbLbFebF --- components/style/context.rs | 370 +---- components/style/matching.rs | 1264 +++-------------- .../style/properties/properties.mako.rs | 4 +- components/style/sharing/mod.rs | 14 +- components/style/style_resolver.rs | 191 ++- components/style/stylist.rs | 28 +- components/style/traversal.rs | 71 +- ports/geckolib/glue.rs | 43 +- 8 files changed, 485 insertions(+), 1500 deletions(-) diff --git a/components/style/context.rs b/components/style/context.rs index 5300b04b498..f36df67a55c 100644 --- a/components/style/context.rs +++ b/components/style/context.rs @@ -7,7 +7,6 @@ #[cfg(feature = "servo")] use animation::Animation; use animation::PropertyAnimation; use app_units::Au; -use arrayvec::ArrayVec; use bloom::StyleBloom; use cache::LRUCache; use data::{EagerPseudoStyles, ElementData}; @@ -19,8 +18,8 @@ use font_metrics::FontMetricsProvider; #[cfg(feature = "servo")] use parking_lot::RwLock; use properties::ComputedValues; use rule_tree::StrongRuleNode; -use selector_parser::{EAGER_PSEUDO_COUNT, PseudoElement, SnapshotMap}; -use selectors::matching::{ElementSelectorFlags, VisitedHandlingMode}; +use selector_parser::{EAGER_PSEUDO_COUNT, SnapshotMap}; +use selectors::matching::ElementSelectorFlags; use shared_lock::StylesheetGuards; use sharing::{ValidationData, StyleSharingCandidateCache}; use std::fmt; @@ -162,36 +161,17 @@ impl<'a> SharedStyleContext<'a> { /// within the `CurrentElementInfo`. At the end of the cascade, they are folded /// down into the main `ComputedValues` to reduce memory usage per element while /// still remaining accessible. -#[derive(Clone)] +#[derive(Clone, Default)] pub struct CascadeInputs { /// The rule node representing the ordered list of rules matched for this /// node. - rules: Option, + pub rules: Option, /// The rule node representing the ordered list of rules matched for this /// node if visited, only computed if there's a relevant link for this /// element. A element's "relevant link" is the element being matched if it /// is a link or the nearest ancestor link. - visited_rules: Option, - - /// The element's computed values if visited, only computed if there's a - /// relevant link for this element. A element's "relevant link" is the - /// element being matched if it is a link or the nearest ancestor link. - /// - /// We also store a reference to this inside the regular ComputedValues to - /// avoid refactoring all APIs to become aware of multiple ComputedValues - /// objects. - visited_values: Option>, -} - -impl Default for CascadeInputs { - fn default() -> Self { - CascadeInputs { - rules: None, - visited_rules: None, - visited_values: None, - } - } + pub visited_rules: Option, } impl CascadeInputs { @@ -200,125 +180,8 @@ impl CascadeInputs { CascadeInputs { rules: style.rules.clone(), visited_rules: style.get_visited_style().and_then(|v| v.rules.clone()), - // Values will be re-cascaded if necessary, so this can be None. - visited_values: None, } } - - /// Whether there are any rules. Rules will be present after unvisited - /// matching or pulled from a previous cascade if no matching is expected. - pub fn has_rules(&self) -> bool { - self.rules.is_some() - } - - /// Gets a mutable reference to the rule node, if any. - pub fn get_rules_mut(&mut self) -> Option<&mut StrongRuleNode> { - self.rules.as_mut() - } - - /// Gets a reference to the rule node, if any. - pub fn get_rules(&self) -> Option<&StrongRuleNode> { - self.rules.as_ref() - } - - /// Gets a reference to the rule node. Panic if the element does not have - /// rule node. - pub fn rules(&self) -> &StrongRuleNode { - self.rules.as_ref().unwrap() - } - - /// Sets the rule node depending on visited mode. - /// Returns whether the rules changed. - pub fn set_rules(&mut self, - visited_handling: VisitedHandlingMode, - rules: StrongRuleNode) - -> bool { - match visited_handling { - VisitedHandlingMode::AllLinksVisitedAndUnvisited => { - unreachable!("We should never try to selector match with \ - AllLinksVisitedAndUnvisited"); - }, - VisitedHandlingMode::AllLinksUnvisited => self.set_unvisited_rules(rules), - VisitedHandlingMode::RelevantLinkVisited => self.set_visited_rules(rules), - } - } - - /// Sets the unvisited rule node, and returns whether it changed. - fn set_unvisited_rules(&mut self, rules: StrongRuleNode) -> bool { - if let Some(ref old_rules) = self.rules { - if *old_rules == rules { - return false - } - } - self.rules = Some(rules); - true - } - - /// Whether there are any visited rules. Visited rules will be present - /// after visited matching or pulled from a previous cascade (assuming there - /// was a relevant link at the time) if no matching is expected. - pub fn has_visited_rules(&self) -> bool { - self.visited_rules.is_some() - } - - /// Gets a reference to the visited rule node, if any. - pub fn get_visited_rules(&self) -> Option<&StrongRuleNode> { - self.visited_rules.as_ref() - } - - /// Gets a mutable reference to the visited rule node, if any. - pub fn get_visited_rules_mut(&mut self) -> Option<&mut StrongRuleNode> { - self.visited_rules.as_mut() - } - - /// Gets a reference to the visited rule node. Panic if the element does not - /// have visited rule node. - pub fn visited_rules(&self) -> &StrongRuleNode { - self.visited_rules.as_ref().unwrap() - } - - /// Sets the visited rule node, and returns whether it changed. - fn set_visited_rules(&mut self, rules: StrongRuleNode) -> bool { - if let Some(ref old_rules) = self.visited_rules { - if *old_rules == rules { - return false - } - } - self.visited_rules = Some(rules); - true - } - - /// Takes the visited rule node. - pub fn take_visited_rules(&mut self) -> Option { - self.visited_rules.take() - } - - /// Whether there are any visited values. - pub fn has_visited_values(&self) -> bool { - self.visited_values.is_some() - } - - /// Gets a reference to the visited computed values. Panic if the element - /// does not have visited computed values. - pub fn visited_values(&self) -> &Arc { - self.visited_values.as_ref().unwrap() - } - - /// Sets the visited computed values. - pub fn set_visited_values(&mut self, values: Arc) { - self.visited_values = Some(values); - } - - /// Take the visited computed values. - pub fn take_visited_values(&mut self) -> Option> { - self.visited_values.take() - } - - /// Clone the visited computed values Arc. Used to store a reference to the - /// visited values inside the regular values. - pub fn clone_visited_values(&self) -> Option> { - self.visited_values.clone() - } } // We manually implement Debug for CascadeInputs so that we can avoid the @@ -363,160 +226,9 @@ impl EagerPseudoCascadeInputs { })) } - /// Returns whether there are any pseudo inputs. - pub fn is_empty(&self) -> bool { - self.0.is_none() - } - - /// Returns a reference to the inputs for a given eager pseudo, if they exist. - pub fn get(&self, pseudo: &PseudoElement) -> Option<&CascadeInputs> { - debug_assert!(pseudo.is_eager()); - self.0.as_ref().and_then(|p| p[pseudo.eager_index()].as_ref()) - } - - /// Returns a mutable reference to the inputs for a given eager pseudo, if they exist. - pub fn get_mut(&mut self, pseudo: &PseudoElement) -> Option<&mut CascadeInputs> { - debug_assert!(pseudo.is_eager()); - self.0.as_mut().and_then(|p| p[pseudo.eager_index()].as_mut()) - } - - /// Returns true if the EagerPseudoCascadeInputs has a inputs for |pseudo|. - pub fn has(&self, pseudo: &PseudoElement) -> bool { - self.get(pseudo).is_some() - } - - /// Inserts a pseudo-element. The pseudo-element must not already exist. - pub fn insert(&mut self, pseudo: &PseudoElement, inputs: CascadeInputs) { - debug_assert!(!self.has(pseudo)); - if self.0.is_none() { - self.0 = Some(Default::default()); - } - self.0.as_mut().unwrap()[pseudo.eager_index()] = Some(inputs); - } - - /// Removes a pseudo-element inputs if they exist, and returns it. - pub fn take(&mut self, pseudo: &PseudoElement) -> Option { - let result = match self.0.as_mut() { - None => return None, - Some(arr) => arr[pseudo.eager_index()].take(), - }; - let empty = self.0.as_ref().unwrap().iter().all(|x| x.is_none()); - if empty { - self.0 = None; - } - result - } - - /// Returns a list of the pseudo-elements. - pub fn keys(&self) -> ArrayVec<[PseudoElement; EAGER_PSEUDO_COUNT]> { - let mut v = ArrayVec::new(); - if let Some(ref arr) = self.0 { - for i in 0..EAGER_PSEUDO_COUNT { - if arr[i].is_some() { - v.push(PseudoElement::from_eager_index(i)); - } - } - } - v - } - - /// Adds the unvisited rule node for a given pseudo-element, which may or - /// may not exist. - /// - /// Returns true if the pseudo-element is new. - fn add_unvisited_rules(&mut self, - pseudo: &PseudoElement, - rules: StrongRuleNode) - -> bool { - if let Some(mut inputs) = self.get_mut(pseudo) { - inputs.set_unvisited_rules(rules); - return false - } - let mut inputs = CascadeInputs::default(); - inputs.set_unvisited_rules(rules); - self.insert(pseudo, inputs); - true - } - - /// Remove the unvisited rule node for a given pseudo-element, which may or - /// may not exist. Since removing the rule node implies we don't need any - /// other data for the pseudo, take the entire pseudo if found. - /// - /// Returns true if the pseudo-element was removed. - fn remove_unvisited_rules(&mut self, pseudo: &PseudoElement) -> bool { - self.take(pseudo).is_some() - } - - /// Adds the visited rule node for a given pseudo-element. It is assumed to - /// already exist because unvisited inputs should have been added first. - /// - /// Returns true if the pseudo-element is new. (Always false, but returns a - /// bool for parity with `add_unvisited_rules`.) - fn add_visited_rules(&mut self, - pseudo: &PseudoElement, - rules: StrongRuleNode) - -> bool { - debug_assert!(self.has(pseudo)); - let mut inputs = self.get_mut(pseudo).unwrap(); - inputs.set_visited_rules(rules); - false - } - - /// Remove the visited rule node for a given pseudo-element, which may or - /// may not exist. - /// - /// Returns true if the psuedo-element was removed. (Always false, but - /// returns a bool for parity with `remove_unvisited_rules`.) - fn remove_visited_rules(&mut self, pseudo: &PseudoElement) -> bool { - if let Some(mut inputs) = self.get_mut(pseudo) { - inputs.take_visited_rules(); - } - false - } - - /// Adds a rule node for a given pseudo-element, which may or may not exist. - /// The type of rule node depends on the visited mode. - /// - /// Returns true if the pseudo-element is new. - pub fn add_rules(&mut self, - pseudo: &PseudoElement, - visited_handling: VisitedHandlingMode, - rules: StrongRuleNode) - -> bool { - match visited_handling { - VisitedHandlingMode::AllLinksVisitedAndUnvisited => { - unreachable!("We should never try to selector match with \ - AllLinksVisitedAndUnvisited"); - }, - VisitedHandlingMode::AllLinksUnvisited => { - self.add_unvisited_rules(&pseudo, rules) - }, - VisitedHandlingMode::RelevantLinkVisited => { - self.add_visited_rules(&pseudo, rules) - }, - } - } - - /// Removes a rule node for a given pseudo-element, which may or may not - /// exist. The type of rule node depends on the visited mode. - /// - /// Returns true if the psuedo-element was removed. - pub fn remove_rules(&mut self, - pseudo: &PseudoElement, - visited_handling: VisitedHandlingMode) - -> bool { - match visited_handling { - VisitedHandlingMode::AllLinksVisitedAndUnvisited => { - unreachable!("We should never try to selector match with \ - AllLinksVisitedAndUnvisited"); - }, - VisitedHandlingMode::AllLinksUnvisited => { - self.remove_unvisited_rules(&pseudo) - }, - VisitedHandlingMode::RelevantLinkVisited => { - self.remove_visited_rules(&pseudo) - }, - } + /// Returns the list of rules, if they exist. + pub fn into_array(self) -> Option<[Option; EAGER_PSEUDO_COUNT]> { + self.0 } } @@ -530,56 +242,20 @@ impl EagerPseudoCascadeInputs { #[derive(Clone, Debug)] pub struct ElementCascadeInputs { /// The element's cascade inputs. - pub primary: Option, + pub primary: CascadeInputs, /// A list of the inputs for the element's eagerly-cascaded pseudo-elements. pub pseudos: EagerPseudoCascadeInputs, } -impl Default for ElementCascadeInputs { - /// Construct an empty `ElementCascadeInputs`. - fn default() -> Self { - ElementCascadeInputs { - primary: None, - pseudos: EagerPseudoCascadeInputs(None), - } - } -} - impl ElementCascadeInputs { /// Construct inputs from previous cascade results, if any. pub fn new_from_element_data(data: &ElementData) -> Self { - if !data.has_styles() { - return ElementCascadeInputs::default() - } + debug_assert!(data.has_styles()); ElementCascadeInputs { - primary: Some(CascadeInputs::new_from_style(data.styles.primary())), + primary: CascadeInputs::new_from_style(data.styles.primary()), pseudos: EagerPseudoCascadeInputs::new_from_style(&data.styles.pseudos), } } - - /// Returns whether we have primary inputs. - pub fn has_primary(&self) -> bool { - self.primary.is_some() - } - - /// Gets the primary inputs. Panic if unavailable. - pub fn primary(&self) -> &CascadeInputs { - self.primary.as_ref().unwrap() - } - - /// Gets the mutable primary inputs. Panic if unavailable. - pub fn primary_mut(&mut self) -> &mut CascadeInputs { - self.primary.as_mut().unwrap() - } - - /// Ensure primary inputs exist and create them if they do not. - /// Returns a mutable reference to the primary inputs. - pub fn ensure_primary(&mut self) -> &mut CascadeInputs { - if self.primary.is_none() { - self.primary = Some(CascadeInputs::default()); - } - self.primary.as_mut().unwrap() - } } /// Information about the current element being processed. We group this @@ -598,11 +274,6 @@ pub struct CurrentElementInfo { /// A Vec of possibly expired animations. Used only by Servo. #[allow(dead_code)] pub possibly_expired_animations: Vec, - /// Temporary storage for various intermediate inputs that are eventually - /// used by by the cascade. At the end of the cascade, they are folded down - /// into the main `ComputedValues` to reduce memory usage per element while - /// still remaining accessible. - pub cascade_inputs: ElementCascadeInputs, } /// Statistics gathered during the traversal. We gather statistics on each @@ -906,7 +577,6 @@ impl ThreadLocalStyleContext { is_initial_style: !data.has_styles(), validation_data: ValidationData::default(), possibly_expired_animations: Vec::new(), - cascade_inputs: ElementCascadeInputs::default(), }); } @@ -951,24 +621,6 @@ pub struct StyleContext<'a, E: TElement + 'a> { pub thread_local: &'a mut ThreadLocalStyleContext, } -impl<'a, E: TElement + 'a> StyleContext<'a, E> { - /// Returns a reference to the cascade inputs. Panics if there is no - /// `CurrentElementInfo`. - pub fn cascade_inputs(&self) -> &ElementCascadeInputs { - &self.thread_local.current_element_info - .as_ref().unwrap() - .cascade_inputs - } - - /// Returns a mutable reference to the cascade inputs. Panics if there is - /// no `CurrentElementInfo`. - pub fn cascade_inputs_mut(&mut self) -> &mut ElementCascadeInputs { - &mut self.thread_local.current_element_info - .as_mut().unwrap() - .cascade_inputs - } -} - /// Why we're doing reflow. #[derive(PartialEq, Copy, Clone, Debug)] pub enum ReflowGoal { diff --git a/components/style/matching.rs b/components/style/matching.rs index 0cd55918457..6b20226a620 100644 --- a/components/style/matching.rs +++ b/components/style/matching.rs @@ -7,46 +7,18 @@ #![allow(unsafe_code)] #![deny(missing_docs)] -use applicable_declarations::ApplicableDeclarationList; -use cascade_info::CascadeInfo; -use context::{CascadeInputs, SelectorFlagsMap, SharedStyleContext, StyleContext}; +use context::{ElementCascadeInputs, SelectorFlagsMap, SharedStyleContext, StyleContext}; use data::{ElementData, ElementStyles, RestyleData}; -use dom::{TElement, TNode}; -use font_metrics::FontMetricsProvider; +use dom::TElement; use invalidation::element::restyle_hints::{RESTYLE_CSS_ANIMATIONS, RESTYLE_CSS_TRANSITIONS}; use invalidation::element::restyle_hints::{RESTYLE_SMIL, RESTYLE_STYLE_ATTRIBUTE}; use invalidation::element::restyle_hints::RestyleHint; -use log::LogLevel::Trace; -use properties::{AnimationRules, CascadeFlags, ComputedValues}; -use properties::{IS_ROOT_ELEMENT, PROHIBIT_DISPLAY_CONTENTS, SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP}; -use properties::{VISITED_DEPENDENT_ONLY, cascade}; +use properties::ComputedValues; use properties::longhands::display::computed_value as display; use rule_tree::{CascadeLevel, StrongRuleNode}; -use selector_parser::{PseudoElement, RestyleDamage, SelectorImpl}; -use selectors::matching::{ElementSelectorFlags, MatchingContext, MatchingMode, StyleRelations}; -use selectors::matching::VisitedHandlingMode; -use sharing::StyleSharingBehavior; +use selector_parser::{PseudoElement, RestyleDamage}; +use selectors::matching::ElementSelectorFlags; use stylearc::Arc; -use stylist::RuleInclusion; - -/// Whether we are cascading for an eager pseudo-element or something else. -/// -/// Controls where we inherit styles from, and whether display:contents is -/// prohibited. -#[derive(PartialEq, Copy, Clone, Debug)] -enum CascadeTarget { - /// Inherit from the parent element, as normal CSS dictates, _or_ from the - /// closest non-Native Anonymous element in case this is Native Anonymous - /// Content. display:contents is allowed. - Normal, - /// Inherit from the primary style, this is used while computing eager - /// pseudos, like ::before and ::after when we're traversing the parent. - /// Also prohibits display:contents from having an effect. - /// - /// TODO(emilio) display:contents really should apply to ::before/::after. - /// https://github.com/w3c/csswg-drafts/issues/1345 - EagerPseudo, -} /// Represents the result of comparing an element's old and new style. pub struct StyleDifference { @@ -78,11 +50,12 @@ pub enum StyleChange { /// Whether or not newly computed values for an element need to be cascade /// to children. +#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Debug)] pub enum ChildCascadeRequirement { /// Old and new computed values were the same, or we otherwise know that /// we won't bother recomputing style for children, so we can skip cascading /// the new values into child elements. - CanSkipCascade, + CanSkipCascade = 0, /// Old and new computed values were different, so we must cascade the /// new values to children. /// @@ -91,11 +64,11 @@ pub enum ChildCascadeRequirement { /// property values. When we do that, we can treat `MustCascadeChildren` as /// "must cascade unless we know that changes to these properties can be /// ignored". - MustCascadeChildren, + MustCascadeChildren = 1, /// The same as `MustCascadeChildren`, but for the entire subtree. This is /// used to handle root font-size updates needing to recascade the whole /// document. - MustCascadeDescendants, + MustCascadeDescendants = 2, } bitflags! { @@ -133,129 +106,7 @@ pub enum CascadeVisitedMode { Visited, } -/// Various helper methods to ease navigating the style storage locations -/// depending on the current cascade mode. impl CascadeVisitedMode { - /// Returns whether there is a rule node based on the cascade mode. - /// Rules will be present after matching or pulled from a previous cascade - /// if no matching is expected. For visited, this means rules exist only - /// if a revelant link existed when matching was last done. - fn has_rules(&self, inputs: &CascadeInputs) -> bool { - match *self { - CascadeVisitedMode::Unvisited => inputs.has_rules(), - CascadeVisitedMode::Visited => inputs.has_visited_rules(), - } - } - - /// Returns the rule node based on the cascade mode. - fn rules<'a>(&self, inputs: &'a CascadeInputs) -> &'a StrongRuleNode { - match *self { - CascadeVisitedMode::Unvisited => inputs.rules(), - CascadeVisitedMode::Visited => match inputs.get_visited_rules() { - Some(rules) => rules, - None => inputs.rules(), - } - } - } - - /// Returns a mutable rules node based on the cascade mode, if any. - fn get_rules_mut<'a>(&self, inputs: &'a mut CascadeInputs) -> Option<&'a mut StrongRuleNode> { - match *self { - CascadeVisitedMode::Unvisited => inputs.get_rules_mut(), - CascadeVisitedMode::Visited => inputs.get_visited_rules_mut(), - } - } - - /// Returns the computed values based on the cascade mode. In visited mode, - /// visited values are only returned if they already exist. If they don't, - /// we fallback to the regular, unvisited styles. - pub fn values<'a>(&self, values: &'a Arc) -> &'a Arc { - if *self == CascadeVisitedMode::Visited && values.get_visited_style().is_some() { - return values.visited_style(); - } - - values - } - - /// Set the primary computed values based on the cascade mode. - fn set_primary_values(&self, - styles: &mut ElementStyles, - inputs: &mut CascadeInputs, - values: Arc) { - // Unvisited values are stored in permanent storage on `ElementData`. - // Visited values are stored temporarily in `CascadeInputs` and then - // folded into the unvisited values when they cascade. - match *self { - CascadeVisitedMode::Unvisited => styles.primary = Some(values), - CascadeVisitedMode::Visited => inputs.set_visited_values(values), - } - } - - /// Set the primary computed values based on the cascade mode. - fn set_pseudo_values(&self, - styles: &mut ElementStyles, - inputs: &mut CascadeInputs, - pseudo: &PseudoElement, - values: Arc) { - // Unvisited values are stored in permanent storage on `ElementData`. - // Visited values are stored temporarily in `CascadeInputs` and then - // folded into the unvisited values when they cascade. - match *self { - CascadeVisitedMode::Unvisited => styles.pseudos.set(pseudo, values), - CascadeVisitedMode::Visited => inputs.set_visited_values(values), - } - } - - /// Take the primary computed values based on the cascade mode. - fn take_primary_values(&self, - styles: &mut ElementStyles, - inputs: &mut CascadeInputs) - -> Option> { - // Unvisited values are stored in permanent storage on `ElementData`. - // Visited values are stored temporarily in `CascadeInputs` and then - // folded into the unvisited values when they cascade. - match *self { - CascadeVisitedMode::Unvisited => styles.primary.take(), - CascadeVisitedMode::Visited => inputs.take_visited_values(), - } - } - - /// Take the pseudo computed values based on the cascade mode. - fn take_pseudo_values(&self, - styles: &mut ElementStyles, - inputs: &mut CascadeInputs, - pseudo: &PseudoElement) - -> Option> { - // Unvisited values are stored in permanent storage on `ElementData`. - // Visited values are stored temporarily in `CascadeInputs` and then - // folded into the unvisited values when they cascade. - match *self { - CascadeVisitedMode::Unvisited => styles.pseudos.take(pseudo), - CascadeVisitedMode::Visited => inputs.take_visited_values(), - } - } - - /// Returns whether there might be visited values that should be inserted - /// within the regular computed values based on the cascade mode. - pub fn visited_values_for_insertion(&self) -> bool { - *self == CascadeVisitedMode::Unvisited - } - - /// Returns whether animations should be processed based on the cascade - /// mode. At the moment, it appears we don't need to support animating - /// visited styles. - fn should_process_animations(&self) -> bool { - *self == CascadeVisitedMode::Unvisited - } - - /// Returns whether we should accumulate restyle damage based on the cascade - /// mode. At the moment, it appears we don't need to do so for visited - /// styles. TODO: Verify this is correct as part of - /// https://bugzilla.mozilla.org/show_bug.cgi?id=1364484. - fn should_accumulate_damage(&self) -> bool { - *self == CascadeVisitedMode::Unvisited - } - /// Returns whether the cascade should filter to only visited dependent /// properties based on the cascade mode. pub fn visited_dependent_only(&self) -> bool { @@ -264,419 +115,39 @@ impl CascadeVisitedMode { } trait PrivateMatchMethods: TElement { - /// Returns the closest parent element that doesn't have a display: contents - /// style (and thus generates a box). - /// - /// This is needed to correctly handle blockification of flex and grid - /// items. - /// - /// Returns itself if the element has no parent. In practice this doesn't - /// happen because the root element is blockified per spec, but it could - /// happen if we decide to not blockify for roots of disconnected subtrees, - /// which is a kind of dubious beahavior. - fn layout_parent(&self) -> Self { - let mut current = self.clone(); - loop { - current = match current.traversal_parent() { - Some(el) => el, - None => return current, - }; - - let is_display_contents = - current.borrow_data().unwrap().styles.primary().is_display_contents(); - - if !is_display_contents { - return current; - } - } - } - - /// Get the ComputedValues (if any) for our inheritance parent. - fn get_inherited_style_and_parent(&self) -> ParentElementAndStyle { - let parent_el = self.inheritance_parent(); - let parent_data = parent_el.as_ref().and_then(|e| e.borrow_data()); - let parent_style = parent_data.as_ref().map(|d| { - // Sometimes Gecko eagerly styles things without processing - // pending restyles first. In general we'd like to avoid this, - // but there can be good reasons (for example, needing to - // construct a frame for some small piece of newly-added - // content in order to do something specific with that frame, - // but not wanting to flush all of layout). - debug_assert!(cfg!(feature = "gecko") || - parent_el.unwrap().has_current_styles(d)); - d.styles.primary() - }); - - ParentElementAndStyle { - element: parent_el, - style: parent_style.cloned(), - } - } - - /// A common path for the cascade used by both primary elements and eager - /// pseudo-elements after collecting the appropriate rules to use. - /// - /// `primary_style` is expected to be Some for eager pseudo-elements. - /// - /// `parent_info` is our style parent and its primary style, if - /// it's already been computed. - fn cascade_with_rules(&self, - shared_context: &SharedStyleContext, - font_metrics_provider: &FontMetricsProvider, - rule_node: &StrongRuleNode, - primary_style: Option<&Arc>, - cascade_target: CascadeTarget, - cascade_visited: CascadeVisitedMode, - parent_info: Option<&ParentElementAndStyle>, - visited_values_to_insert: Option>) - -> Arc { - let mut cascade_info = CascadeInfo::new(); - let mut cascade_flags = CascadeFlags::empty(); - if self.skip_root_and_item_based_display_fixup() { - cascade_flags.insert(SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP) - } - if cascade_visited.visited_dependent_only() { - cascade_flags.insert(VISITED_DEPENDENT_ONLY); - } - if self.is_native_anonymous() || cascade_target == CascadeTarget::EagerPseudo { - cascade_flags.insert(PROHIBIT_DISPLAY_CONTENTS); - } else if self.is_root() { - cascade_flags.insert(IS_ROOT_ELEMENT); - } - - // Grab the inherited values. - let parent_el; - let element_and_style; // So parent_el and style_to_inherit_from are known live. - let style_to_inherit_from = match cascade_target { - CascadeTarget::Normal => { - let info = match parent_info { - Some(element_and_style) => element_and_style, - None => { - element_and_style = self.get_inherited_style_and_parent(); - &element_and_style - } - }; - parent_el = info.element; - info.style.as_ref().map(|s| cascade_visited.values(s)) - } - CascadeTarget::EagerPseudo => { - parent_el = Some(self.clone()); - Some(cascade_visited.values(primary_style.unwrap())) - } - }; - - let mut layout_parent_el = parent_el.clone(); - let layout_parent_data; - let mut layout_parent_style = style_to_inherit_from; - if style_to_inherit_from.map_or(false, |s| s.is_display_contents()) { - layout_parent_el = Some(layout_parent_el.unwrap().layout_parent()); - layout_parent_data = layout_parent_el.as_ref().unwrap().borrow_data().unwrap(); - layout_parent_style = Some(cascade_visited.values(layout_parent_data.styles.primary())); - } - - let style_to_inherit_from = style_to_inherit_from.map(|x| &**x); - let layout_parent_style = layout_parent_style.map(|x| &**x); - - // Propagate the "can be fragmented" bit. It would be nice to - // encapsulate this better. - // - // Note that this is technically not needed for pseudos since we already - // do that when we resolve the non-pseudo style, but it doesn't hurt - // anyway. - // - // TODO(emilio): This is servo-only, move somewhere else? - if let Some(ref p) = layout_parent_style { - let can_be_fragmented = - p.is_multicol() || - layout_parent_el.as_ref().unwrap().as_node().can_be_fragmented(); - unsafe { self.as_node().set_can_be_fragmented(can_be_fragmented); } - } - - // Invoke the cascade algorithm. - let values = - Arc::new(cascade(shared_context.stylist.device(), - rule_node, - &shared_context.guards, - style_to_inherit_from, - layout_parent_style, - visited_values_to_insert, - Some(&mut cascade_info), - font_metrics_provider, - cascade_flags, - shared_context.quirks_mode)); - - cascade_info.finish(&self.as_node()); - values - } - - /// A common path for the cascade used by both primary elements and eager - /// pseudo-elements. - /// - /// `primary_style` is expected to be Some for eager pseudo-elements. - /// - /// `parent_info` is our style parent and its primary style, if - /// it's already been computed. - fn cascade_internal(&self, - context: &StyleContext, - primary_style: Option<&Arc>, - primary_inputs: &CascadeInputs, - eager_pseudo_inputs: Option<&CascadeInputs>, - parent_info: Option<&ParentElementAndStyle>, - cascade_visited: CascadeVisitedMode) - -> Arc { - if let Some(pseudo) = self.implemented_pseudo_element() { - debug_assert!(eager_pseudo_inputs.is_none()); - - // This is an element-backed pseudo, just grab the styles from the - // parent if it's eager, and recascade otherwise. - // - // We also recascade if the eager pseudo-style has any animation - // rules, because we don't cascade those during the eager traversal. - // - // We could make that a bit better if the complexity cost is not too - // big, but given further restyles are posted directly to - // pseudo-elements, it doesn't seem worth the effort at a glance. - // - // For the same reason as described in match_primary, if we are - // computing default styles, we aren't guaranteed the parent - // will have eagerly computed our styles, so we just handled it - // below like a lazy pseudo. - let only_default_rules = context.shared.traversal_flags.for_default_styles(); - if pseudo.is_eager() && !only_default_rules { - debug_assert!(pseudo.is_before_or_after()); - let parent = self.parent_element().unwrap(); - if !parent.may_have_animations() || - self.get_animation_rules().is_empty() { - let parent_data = parent.borrow_data().unwrap(); - let pseudo_style = - parent_data.styles.pseudos.get(&pseudo).unwrap(); - let values = cascade_visited.values(pseudo_style); - return values.clone() - } - } - } - - // Find possible visited computed styles to insert within the regular - // computed values we are about to create. - let visited_values_to_insert = if cascade_visited.visited_values_for_insertion() { - match eager_pseudo_inputs { - Some(ref s) => s.clone_visited_values(), - None => primary_inputs.clone_visited_values(), - } - } else { - None - }; - - // Grab the rule node. - let inputs = eager_pseudo_inputs.unwrap_or(primary_inputs); - // We'd really like to take the rules here to avoid refcount traffic, - // but animation's usage of `apply_declarations` make this tricky. - // See bug 1375525. - let rule_node = cascade_visited.rules(inputs); - let cascade_target = if eager_pseudo_inputs.is_some() { - CascadeTarget::EagerPseudo - } else { - CascadeTarget::Normal - }; - - self.cascade_with_rules(context.shared, - &context.thread_local.font_metrics_provider, - rule_node, - primary_style, - cascade_target, - cascade_visited, - parent_info, - visited_values_to_insert) - } - - /// Computes values and damage for the primary style of an element, setting - /// them on the ElementData. - /// - /// `parent_info` is our style parent and its primary style. - fn cascade_primary(&self, - context: &mut StyleContext, - data: &mut ElementData, - important_rules_changed: bool, - parent_info: &ParentElementAndStyle, - cascade_visited: CascadeVisitedMode) - -> ChildCascadeRequirement { - debug!("Cascade primary for {:?}, visited: {:?}", self, cascade_visited); - - let mut old_values = cascade_visited.take_primary_values( - &mut data.styles, - context.cascade_inputs_mut().primary_mut() - ); - - let mut new_values = { - let primary_inputs = context.cascade_inputs().primary(); - - // If there was no relevant link at the time of matching, we won't - // have any visited rules, so there may not be anything do for the - // visited case. This early return is especially important for the - // `cascade_primary_and_pseudos` path since we rely on the state of - // some previous matching run. - // - // Note that we cannot take this early return if our parent has - // visited style, because then we too have visited style. - if !cascade_visited.has_rules(primary_inputs) && !parent_info.has_visited_style() { - return ChildCascadeRequirement::CanSkipCascade - } - - // Compute the new values. - self.cascade_internal(context, - None, - primary_inputs, - None, - /* parent_info = */ None, - cascade_visited) - }; - - // NB: Animations for pseudo-elements in Gecko are handled while - // traversing the pseudo-elements themselves. - if !context.shared.traversal_flags.for_animation_only() && - cascade_visited.should_process_animations() { - self.process_animations(context, - &mut old_values, - &mut new_values, - important_rules_changed); - } - - let mut child_cascade_requirement = - ChildCascadeRequirement::CanSkipCascade; - if cascade_visited.should_accumulate_damage() { - child_cascade_requirement = - self.accumulate_damage(&context.shared, - &mut data.restyle, - old_values.as_ref().map(|v| v.as_ref()), - &new_values, - None); - - // Handle root font-size changes. - // - // TODO(emilio): This should arguably be outside of the path for - // getComputedStyle/getDefaultComputedStyle, but it's unclear how to - // do it without duplicating a bunch of code. - if self.is_root() && !self.is_native_anonymous() && - !context.shared.traversal_flags.for_default_styles() { - let device = context.shared.stylist.device(); - let new_font_size = new_values.get_font().clone_font_size(); - - // If the root font-size changed since last time, and something - // in the document did use rem units, ensure we recascade the - // entire tree. - if old_values.map_or(true, |v| v.get_font().clone_font_size() != new_font_size) { - // FIXME(emilio): This can fire when called from a document - // from the bfcache (bug 1376897). - debug_assert!(self.owner_doc_matches_for_testing(device)); - device.set_root_font_size(new_font_size); - if device.used_root_font_size() { - child_cascade_requirement = ChildCascadeRequirement::MustCascadeDescendants; - } - } - } - } - - // If there were visited values to insert, ensure they do in fact exist - // inside the new values. - debug_assert!(!cascade_visited.visited_values_for_insertion() || - context.cascade_inputs().primary().has_visited_values() == - new_values.has_visited_style()); - - // Set the new computed values. - let primary_inputs = context.cascade_inputs_mut().primary_mut(); - cascade_visited.set_primary_values(&mut data.styles, - primary_inputs, - new_values); - - // Return whether the damage indicates we must cascade new inherited - // values into children. - child_cascade_requirement - } - - /// Computes values and damage for the eager pseudo-element styles of an - /// element, setting them on the ElementData. - fn cascade_eager_pseudo(&self, - context: &mut StyleContext, - data: &mut ElementData, - pseudo: &PseudoElement, - cascade_visited: CascadeVisitedMode) { - debug_assert!(pseudo.is_eager()); - - let old_values = cascade_visited.take_pseudo_values( - &mut data.styles, - context.cascade_inputs_mut().pseudos.get_mut(pseudo).unwrap(), - pseudo - ); - - let new_values = { - let pseudo_inputs = context.cascade_inputs().pseudos - .get(pseudo).unwrap(); - - // If there was no relevant link at the time of matching, we won't - // have any visited rules, so there may not be anything do for the - // visited case. This early return is especially important for the - // `cascade_primary_and_pseudos` path since we rely on the state of - // some previous matching run. - if !cascade_visited.has_rules(pseudo_inputs) { - return - } - - // Primary inputs should already have rules populated since it's - // always processed before eager pseudos. - let primary_inputs = context.cascade_inputs().primary(); - debug_assert!(cascade_visited.has_rules(primary_inputs)); - - self.cascade_internal(context, - data.styles.get_primary(), - primary_inputs, - Some(pseudo_inputs), - /* parent_info = */ None, - cascade_visited) - }; - - if cascade_visited.should_accumulate_damage() { - self.accumulate_damage(&context.shared, - &mut data.restyle, - old_values.as_ref().map(|v| v.as_ref()), - &new_values, - Some(pseudo)); - } - - let pseudo_inputs = context.cascade_inputs_mut().pseudos - .get_mut(pseudo).unwrap(); - cascade_visited.set_pseudo_values(&mut data.styles, - pseudo_inputs, - pseudo, - new_values); - } - - /// get_after_change_style removes the transition rules from the ComputedValues. /// If there is no transition rule in the ComputedValues, it returns None. #[cfg(feature = "gecko")] - fn get_after_change_style(&self, - context: &mut StyleContext, - primary_style: &Arc) - -> Option> { + fn get_after_change_style( + &self, + context: &mut StyleContext, + primary_style: &Arc + ) -> Option> { + use context::CascadeInputs; + use style_resolver::StyleResolverForElement; + use stylist::RuleInclusion; + let rule_node = primary_style.rules(); let without_transition_rules = context.shared.stylist.rule_tree().remove_transition_rule_if_applicable(rule_node); if without_transition_rules == *rule_node { - // We don't have transition rule in this case, so return None to let the caller - // use the original ComputedValues. + // We don't have transition rule in this case, so return None to let + // the caller use the original ComputedValues. return None; } - // This currently passes through visited styles, if they exist. - // When fixing bug 868975, compute after change for visited styles as - // well, along with updating the rest of the animation processing. - Some(self.cascade_with_rules(context.shared, - &context.thread_local.font_metrics_provider, - &without_transition_rules, - Some(primary_style), - CascadeTarget::Normal, - CascadeVisitedMode::Unvisited, - /* parent_info = */ None, - primary_style.get_visited_style().cloned())) + // FIXME(bug 868975): We probably need to transition visited style as + // well. + let inputs = + CascadeInputs { + rules: Some(without_transition_rules), + visited_rules: primary_style.get_visited_style().and_then(|s| s.rules.clone()), + }; + + let style = + StyleResolverForElement::new(*self, context, RuleInclusion::All) + .cascade_style_and_visited_with_default_parents(inputs); + + Some(style) } #[cfg(feature = "gecko")] @@ -788,6 +259,7 @@ trait PrivateMatchMethods: TElement { new_values: &mut Arc, _important_rules_changed: bool) { use animation; + use dom::TNode; let possibly_expired_animations = &mut context.thread_local.current_element_info.as_mut().unwrap() @@ -819,6 +291,7 @@ trait PrivateMatchMethods: TElement { } } + /// Computes and applies non-redundant damage. #[cfg(feature = "gecko")] fn accumulate_damage_for(&self, @@ -829,7 +302,6 @@ trait PrivateMatchMethods: TElement { pseudo: Option<&PseudoElement>) -> ChildCascadeRequirement { use properties::computed_value_flags::*; - // Don't accumulate damage if we're in a restyle for reconstruction. if shared_context.traversal_flags.for_reconstruct() { return ChildCascadeRequirement::MustCascadeChildren; @@ -889,8 +361,9 @@ trait PrivateMatchMethods: TElement { context: &SharedStyleContext, style: &mut Arc, possibly_expired_animations: &mut Vec<::animation::PropertyAnimation>, - font_metrics: &FontMetricsProvider) { + font_metrics: &::font_metrics::FontMetricsProvider) { use animation::{self, Animation}; + use dom::TNode; // Finish any expired transitions. let this_opaque = self.as_node().opaque(); @@ -931,457 +404,167 @@ trait PrivateMatchMethods: TElement { impl PrivateMatchMethods for E {} -/// A struct that holds an element we inherit from and its ComputedValues. -#[derive(Debug)] -struct ParentElementAndStyle { - /// Our style parent element. - element: Option, - /// Element's primary ComputedValues. Not a borrow because we can't prove - /// that the thing hanging off element won't change while we're passing this - /// struct around. - style: Option>, -} - -impl ParentElementAndStyle { - fn has_visited_style(&self) -> bool { - self.style.as_ref().map_or(false, |v| { v.get_visited_style().is_some() }) - } -} - -/// Collects the outputs of the primary matching process, including the rule -/// node and other associated data. -#[derive(Debug)] -pub struct MatchingResults { - /// Whether the rules changed. - rules_changed: bool, - /// Whether there are any changes of important rules overriding animations. - important_rules_overriding_animation_changed: bool, - /// Records certains relations between elements noticed during matching (and - /// also extended after matching). - relations: StyleRelations, - /// Whether we encountered a "relevant link" while matching _any_ selector - /// for this element. (This differs from `RelevantLinkStatus` which tracks - /// the status for the _current_ selector only.) - relevant_link_found: bool, -} - -impl MatchingResults { - /// Create `MatchingResults` with only the basic required outputs. - fn new(rules_changed: bool, important_rules: bool) -> Self { - Self { - rules_changed: rules_changed, - important_rules_overriding_animation_changed: important_rules, - relations: StyleRelations::default(), - relevant_link_found: false, - } - } - - /// Create `MatchingResults` from the output fields of `MatchingContext`. - fn new_from_context(rules_changed: bool, - important_rules: bool, - context: MatchingContext) - -> Self { - Self { - rules_changed: rules_changed, - important_rules_overriding_animation_changed: important_rules, - relations: context.relations, - relevant_link_found: context.relevant_link_found, - } - } -} - /// The public API that elements expose for selector matching. pub trait MatchMethods : TElement { - /// Performs selector matching and property cascading on an element and its - /// eager pseudos. - fn match_and_cascade( - &self, - context: &mut StyleContext, - data: &mut ElementData, - sharing: StyleSharingBehavior - ) -> ChildCascadeRequirement { - debug!("Match and cascade for {:?}", self); - - // Perform selector matching for the primary style. - let primary_results = - self.match_primary(context, data, VisitedHandlingMode::AllLinksUnvisited); - let important_rules_changed = - primary_results.important_rules_overriding_animation_changed; - - // If there's a relevant link involved, match and cascade primary styles - // as if the link is visited as well. This is done before the regular - // cascade because the visited ComputedValues are placed within the - // regular ComputedValues, which is immutable after the cascade. - let relevant_link_found = primary_results.relevant_link_found; - if relevant_link_found { - self.match_primary(context, data, VisitedHandlingMode::RelevantLinkVisited); - } - - // Even if there is no relevant link, we need to cascade visited styles - // if our parent has visited styles. - let parent_and_styles = self.get_inherited_style_and_parent(); - if relevant_link_found || parent_and_styles.has_visited_style() { - self.cascade_primary( - context, - data, - important_rules_changed, - &parent_and_styles, - CascadeVisitedMode::Visited - ); - } - - // Cascade properties and compute primary values. - let child_cascade_requirement = - self.cascade_primary( - context, - data, - important_rules_changed, - &parent_and_styles, - CascadeVisitedMode::Unvisited - ); - - // Match and cascade eager pseudo-elements. - if !data.styles.is_display_none() { - self.match_pseudos(context, data, VisitedHandlingMode::AllLinksUnvisited); - - // If there's a relevant link involved, match and cascade eager - // pseudo-element styles as if the link is visited as well. - // This runs after matching for regular styles because matching adds - // each pseudo as needed to the PseudoMap, and this runs before - // cascade for regular styles because the visited ComputedValues - // are placed within the regular ComputedValues, which is immutable - // after the cascade. - if relevant_link_found { - self.match_pseudos(context, data, VisitedHandlingMode::RelevantLinkVisited); - self.cascade_pseudos(context, data, CascadeVisitedMode::Visited); - } - - self.cascade_pseudos(context, data, CascadeVisitedMode::Unvisited); - } - - // If the style is shareable, add it to the LRU cache. - if sharing == StyleSharingBehavior::Allow { - // If we previously tried to match this element against the cache, - // the revalidation match results will already be cached. Otherwise - // we'll have None, and compute them later on-demand. - // - // If we do have the results, grab them here to satisfy the borrow - // checker. - let validation_data = - context.thread_local - .current_element_info - .as_mut().unwrap() - .validation_data - .take(); - - let dom_depth = context.thread_local.bloom_filter.matching_depth(); - context.thread_local - .style_sharing_candidate_cache - .insert_if_possible(self, - data.styles.primary(), - primary_results.relations, - validation_data, - dom_depth); - } - - child_cascade_requirement - } - - /// Performs the cascade, without matching. - fn cascade_primary_and_pseudos(&self, - context: &mut StyleContext, - mut data: &mut ElementData, - important_rules_changed: bool) - -> ChildCascadeRequirement - { - // If there's a relevant link involved, cascade styles as if the link is - // visited as well. This is done before the regular cascade because the - // visited ComputedValues are placed within the regular ComputedValues, - // which is immutable after the cascade. If there aren't any visited - // rules, these calls will return without cascading. - let parent_and_styles = self.get_inherited_style_and_parent(); - self.cascade_primary(context, &mut data, important_rules_changed, - &parent_and_styles, - CascadeVisitedMode::Visited); - let child_cascade_requirement = - self.cascade_primary(context, &mut data, important_rules_changed, - &parent_and_styles, - CascadeVisitedMode::Unvisited); - self.cascade_pseudos(context, &mut data, CascadeVisitedMode::Visited); - self.cascade_pseudos(context, &mut data, CascadeVisitedMode::Unvisited); - child_cascade_requirement - } - - /// Runs selector matching to (re)compute the primary rule node for this - /// element. + /// Returns the closest parent element that doesn't have a display: contents + /// style (and thus generates a box). /// - /// Returns `MatchingResults` with the new rules and other associated data - /// from the matching process. - fn match_primary( + /// This is needed to correctly handle blockification of flex and grid + /// items. + /// + /// Returns itself if the element has no parent. In practice this doesn't + /// happen because the root element is blockified per spec, but it could + /// happen if we decide to not blockify for roots of disconnected subtrees, + /// which is a kind of dubious beahavior. + fn layout_parent(&self) -> Self { + let mut current = self.clone(); + loop { + current = match current.traversal_parent() { + Some(el) => el, + None => return current, + }; + + let is_display_contents = + current.borrow_data().unwrap().styles.primary().is_display_contents(); + + if !is_display_contents { + return current; + } + } + } + + /// Updates the styles with the new ones, diffs them, and stores the restyle + /// damage. + fn finish_restyle( &self, context: &mut StyleContext, - data: &mut ElementData, - visited_handling: VisitedHandlingMode - ) -> MatchingResults { - debug!("Match primary for {:?}, visited: {:?}", self, visited_handling); + mut data: &mut ElementData, + mut new_styles: ElementStyles, + important_rules_changed: bool, + ) -> ChildCascadeRequirement { + use dom::TNode; + use std::cmp; + use std::mem; - let mut primary_inputs = context.thread_local.current_element_info - .as_mut().unwrap() - .cascade_inputs.ensure_primary(); + debug_assert!(new_styles.primary.is_some(), "How did that happen?"); - let only_default_rules = context.shared.traversal_flags.for_default_styles(); - let implemented_pseudo = self.implemented_pseudo_element(); - if let Some(ref pseudo) = implemented_pseudo { - // We don't expect to match against a non-canonical pseudo-element. - debug_assert_eq!(*pseudo, pseudo.canonical()); - if pseudo.is_eager() && !only_default_rules { - // If it's an eager element-backed pseudo, we can generally just - // grab the matched rules from the parent, and then update - // animations. - // - // However, if we're computing default styles, then we might - // have traversed to this pseudo-implementing element without - // any pseudo styles stored on the parent. For example, if - // document-level style sheets cause the element to exist, due - // to ::before rules, then those rules won't be found when - // computing default styles on the parent, so we won't have - // bothered to store pseudo styles there. In this case, we just - // treat it like a lazily computed pseudo. - let parent = self.parent_element().unwrap(); - let parent_data = parent.borrow_data().unwrap(); - let pseudo_style = - parent_data.styles.pseudos.get(&pseudo).unwrap(); - let mut rules = pseudo_style.rules().clone(); - if parent.may_have_animations() { - let animation_rules = self.get_animation_rules(); + if !context.shared.traversal_flags.for_animation_only() { + self.process_animations( + context, + &mut data.styles.primary, + &mut new_styles.primary.as_mut().unwrap(), + important_rules_changed, + ); + } - // Handle animations here. - if let Some(animation_rule) = animation_rules.0 { - let animation_rule_node = - context.shared.stylist.rule_tree() - .update_rule_at_level(CascadeLevel::Animations, - Some(&animation_rule), - &mut rules, - &context.shared.guards); - if let Some(node) = animation_rule_node { - rules = node; - } - } + // First of all, update the styles. + let old_styles = mem::replace(&mut data.styles, new_styles); - if let Some(animation_rule) = animation_rules.1 { - let animation_rule_node = - context.shared.stylist.rule_tree() - .update_rule_at_level(CascadeLevel::Transitions, - Some(&animation_rule), - &mut rules, - &context.shared.guards); - if let Some(node) = animation_rule_node { - rules = node; - } - } - } - let important_rules_changed = - self.has_animations() && - data.has_styles() && - data.important_rules_are_different(&rules, - &context.shared.guards); + // Propagate the "can be fragmented" bit. It would be nice to + // encapsulate this better. + // + // Note that this is technically not needed for pseudos since we already + // do that when we resolve the non-pseudo style, but it doesn't hurt + // anyway. + if cfg!(feature = "servo") { + let layout_parent = + self.inheritance_parent().map(|e| e.layout_parent()); + let layout_parent_data = + layout_parent.as_ref().and_then(|e| e.borrow_data()); + let layout_parent_style = + layout_parent_data.as_ref().map(|d| d.styles.primary()); - let rules_changed = primary_inputs.set_rules(visited_handling, rules); - - return MatchingResults::new(rules_changed, important_rules_changed) + if let Some(ref p) = layout_parent_style { + let can_be_fragmented = + p.is_multicol() || + layout_parent.as_ref().unwrap().as_node().can_be_fragmented(); + unsafe { self.as_node().set_can_be_fragmented(can_be_fragmented); } } } - let mut applicable_declarations = ApplicableDeclarationList::new(); - - let stylist = &context.shared.stylist; - let style_attribute = self.style_attribute(); - - let map = &mut context.thread_local.selector_flags; - let mut set_selector_flags = |element: &Self, flags: ElementSelectorFlags| { - self.apply_selector_flags(map, element, flags); - }; - - let rule_inclusion = if only_default_rules { - RuleInclusion::DefaultOnly - } else { - RuleInclusion::All - }; - - let bloom_filter = context.thread_local.bloom_filter.filter(); - let mut matching_context = - MatchingContext::new_for_visited(MatchingMode::Normal, - Some(bloom_filter), - visited_handling, - context.shared.quirks_mode); - - { - let smil_override = self.get_smil_override(); - let animation_rules = self.get_animation_rules(); - - // Compute the primary rule node. - stylist.push_applicable_declarations(self, - implemented_pseudo.as_ref(), - style_attribute, - smil_override, - animation_rules, - rule_inclusion, - &mut applicable_declarations, - &mut matching_context, - &mut set_selector_flags); + // Don't accumulate damage if we're in a restyle for reconstruction. + if context.shared.traversal_flags.for_reconstruct() { + return ChildCascadeRequirement::MustCascadeChildren; } - self.unset_dirty_style_attribute(); - let primary_rule_node = stylist.rule_tree().compute_rule_node( - &mut applicable_declarations, - &context.shared.guards + let new_primary_style = data.styles.primary.as_ref().unwrap(); + + let mut cascade_requirement = ChildCascadeRequirement::CanSkipCascade; + if self.is_root() && !self.is_native_anonymous() { + let device = context.shared.stylist.device(); + let new_font_size = new_primary_style.get_font().clone_font_size(); + + if old_styles.primary.as_ref().map_or(true, |s| s.get_font().clone_font_size() != new_font_size) { + debug_assert!(self.owner_doc_matches_for_testing(device)); + device.set_root_font_size(new_font_size); + // If the root font-size changed since last time, and something + // in the document did use rem units, ensure we recascade the + // entire tree. + if device.used_root_font_size() { + cascade_requirement = ChildCascadeRequirement::MustCascadeDescendants; + } + } + } + + // Also, don't do anything if there was no style. + let old_primary_style = match old_styles.primary { + Some(s) => s, + None => return ChildCascadeRequirement::MustCascadeChildren, + }; + + cascade_requirement = cmp::max( + cascade_requirement, + self.accumulate_damage_for( + context.shared, + &mut data.restyle, + &old_primary_style, + new_primary_style, + None, + ) ); - if log_enabled!(Trace) { - trace!("Matched rules:"); - for rn in primary_rule_node.self_and_ancestors() { - let source = rn.style_source(); - if source.is_some() { - trace!(" > {:?}", source); + if data.styles.pseudos.is_empty() && old_styles.pseudos.is_empty() { + return cascade_requirement; + } + + // If it matched a different number of pseudos, reconstruct. + if data.styles.pseudos.is_empty() != old_styles.pseudos.is_empty() { + data.restyle.damage |= RestyleDamage::reconstruct(); + return cascade_requirement; + } + + let pseudo_styles = + old_styles.pseudos.as_array().unwrap().iter().zip( + data.styles.pseudos.as_array().unwrap().iter()); + + for (i, (old, new)) in pseudo_styles.enumerate() { + match (old, new) { + (&Some(ref old), &Some(ref new)) => { + self.accumulate_damage_for( + context.shared, + &mut data.restyle, + old, + new, + Some(&PseudoElement::from_eager_index(i)), + ); + } + (&None, &None) => {}, + _ => { + data.restyle.damage |= RestyleDamage::reconstruct(); + return cascade_requirement; } } } - let important_rules_changed = - self.has_animations() && - data.has_styles() && - data.important_rules_are_different( - &primary_rule_node, - &context.shared.guards - ); - - let rules_changed = primary_inputs.set_rules(visited_handling, primary_rule_node); - - MatchingResults::new_from_context(rules_changed, - important_rules_changed, - matching_context) + cascade_requirement } - /// Runs selector matching to (re)compute eager pseudo-element rule nodes - /// for this element. - fn match_pseudos(&self, - context: &mut StyleContext, - data: &mut ElementData, - visited_handling: VisitedHandlingMode) - { - debug!("Match pseudos for {:?}, visited: {:?}", self, visited_handling); - - if self.implemented_pseudo_element().is_some() { - // Element pseudos can't have any other pseudo. - return; - } - - let mut applicable_declarations = ApplicableDeclarationList::new(); - - // Borrow the stuff we need here so the borrow checker doesn't get mad - // at us later in the closure. - let stylist = &context.shared.stylist; - let guards = &context.shared.guards; - - let rule_inclusion = if context.shared.traversal_flags.for_default_styles() { - RuleInclusion::DefaultOnly - } else { - RuleInclusion::All - }; - - // Compute rule nodes for eagerly-cascaded pseudo-elements. - let mut matches_different_pseudos = false; - SelectorImpl::each_eagerly_cascaded_pseudo_element(|pseudo| { - // For eager pseudo-elements, we only try to match visited rules if - // there are also unvisited rules. (This matches Gecko's behavior - // for probing pseudo-elements, and for eager pseudo-elements Gecko - // does not try to resolve style if the probe says there isn't any.) - if visited_handling == VisitedHandlingMode::RelevantLinkVisited && - !context.cascade_inputs().pseudos.has(&pseudo) { - return - } - - if self.may_generate_pseudo(&pseudo, data.styles.primary()) { - let bloom_filter = context.thread_local.bloom_filter.filter(); - - let mut matching_context = - MatchingContext::new_for_visited(MatchingMode::ForStatelessPseudoElement, - Some(bloom_filter), - visited_handling, - context.shared.quirks_mode); - - let map = &mut context.thread_local.selector_flags; - let mut set_selector_flags = |element: &Self, flags: ElementSelectorFlags| { - self.apply_selector_flags(map, element, flags); - }; - - debug_assert!(applicable_declarations.is_empty()); - // NB: We handle animation rules for ::before and ::after when - // traversing them. - stylist.push_applicable_declarations(self, - Some(&pseudo), - None, - None, - AnimationRules(None, None), - rule_inclusion, - &mut applicable_declarations, - &mut matching_context, - &mut set_selector_flags); - } - - let pseudos = &mut context.thread_local.current_element_info - .as_mut().unwrap() - .cascade_inputs.pseudos; - if !applicable_declarations.is_empty() { - let rules = stylist.rule_tree().compute_rule_node( - &mut applicable_declarations, - &guards - ); - matches_different_pseudos |= !data.styles.pseudos.has(&pseudo); - pseudos.add_rules( - &pseudo, - visited_handling, - rules - ); - } else { - matches_different_pseudos |= data.styles.pseudos.has(&pseudo); - pseudos.remove_rules( - &pseudo, - visited_handling - ); - data.styles.pseudos.take(&pseudo); - } - }); - - if matches_different_pseudos && data.restyle.is_restyle() { - // Any changes to the matched pseudo-elements trigger - // reconstruction. - data.restyle.damage |= RestyleDamage::reconstruct(); - } - } /// Applies selector flags to an element, deferring mutations of the parent /// until after the traversal. /// - /// TODO(emilio): This is somewhat inefficient, because of a variety of - /// reasons: - /// - /// * It doesn't coalesce flags. - /// * It doesn't look at flags already sent in a task for the main - /// thread to process. - /// * It doesn't take advantage of us knowing that the traversal is - /// sequential. - /// - /// I suspect (need to measure!) that we don't use to set flags on - /// a lot of different elements, but we could end up posting the same - /// flag over and over with this approach. - /// - /// If the number of elements is low, perhaps a small cache with the - /// flags already sent would be appropriate. - /// - /// The sequential task business for this is kind of sad :(. - /// - /// Anyway, let's do the obvious thing for now. + /// TODO(emilio): This is somewhat inefficient, because it doesn't take + /// advantage of us knowing that the traversal is sequential. fn apply_selector_flags(&self, map: &mut SelectorFlagsMap, element: &Self, @@ -1458,13 +641,22 @@ pub trait MatchMethods : TElement { &self, replacements: RestyleHint, context: &mut StyleContext, + cascade_inputs: &mut ElementCascadeInputs, ) -> bool { let mut result = false; - result |= self.replace_rules_internal(replacements, context, - CascadeVisitedMode::Unvisited); + result |= self.replace_rules_internal( + replacements, + context, + CascadeVisitedMode::Unvisited, + cascade_inputs, + ); if !context.shared.traversal_flags.for_animation_only() { - result |= self.replace_rules_internal(replacements, context, - CascadeVisitedMode::Visited); + result |= self.replace_rules_internal( + replacements, + context, + CascadeVisitedMode::Visited, + cascade_inputs + ); } result } @@ -1477,7 +669,8 @@ pub trait MatchMethods : TElement { &self, replacements: RestyleHint, context: &mut StyleContext, - cascade_visited: CascadeVisitedMode + cascade_visited: CascadeVisitedMode, + cascade_inputs: &mut ElementCascadeInputs, ) -> bool { use properties::PropertyDeclarationBlock; use shared_lock::Locked; @@ -1488,8 +681,13 @@ pub trait MatchMethods : TElement { let stylist = &context.shared.stylist; let guards = &context.shared.guards; - let mut primary_inputs = context.cascade_inputs_mut().primary_mut(); - let primary_rules = match cascade_visited.get_rules_mut(primary_inputs) { + let primary_rules = + match cascade_visited { + CascadeVisitedMode::Unvisited => cascade_inputs.primary.rules.as_mut(), + CascadeVisitedMode::Visited => cascade_inputs.primary.visited_rules.as_mut(), + }; + + let primary_rules = match primary_rules { Some(r) => r, None => return false, }; @@ -1518,6 +716,7 @@ pub trait MatchMethods : TElement { result |= replace_rule_node(CascadeLevel::StyleAttributeImportant, style_attribute, primary_rules); + // FIXME(emilio): Still a hack! self.unset_dirty_style_attribute(); } return result; @@ -1564,12 +763,12 @@ pub trait MatchMethods : TElement { /// Given the old and new style of this element, and whether it's a /// pseudo-element, compute the restyle damage used to determine which /// kind of layout or painting operations we'll need. - fn compute_style_difference(&self, - old_values: &ComputedValues, - new_values: &Arc, - pseudo: Option<&PseudoElement>) - -> StyleDifference - { + fn compute_style_difference( + &self, + old_values: &ComputedValues, + new_values: &Arc, + pseudo: Option<&PseudoElement> + ) -> StyleDifference { debug_assert!(pseudo.map_or(true, |p| p.is_eager())); if let Some(source) = self.existing_style_for_restyle_damage(old_values, pseudo) { return RestyleDamage::compute_style_difference(source, new_values) @@ -1642,55 +841,36 @@ pub trait MatchMethods : TElement { StyleDifference::new(damage, StyleChange::Changed) } - /// Performs the cascade for the element's eager pseudos. - fn cascade_pseudos(&self, - context: &mut StyleContext, - mut data: &mut ElementData, - cascade_visited: CascadeVisitedMode) - { - debug!("Cascade pseudos for {:?}, visited: {:?}", self, - cascade_visited); - // Note that we've already set up the map of matching pseudo-elements - // in match_pseudos (and handled the damage implications of changing - // which pseudos match), so now we can just iterate what we have. This - // does mean collecting owned pseudos, so that the borrow checker will - // let us pass the mutable |data| to the cascade function. - let matched_pseudos = context.cascade_inputs().pseudos.keys(); - for pseudo in matched_pseudos { - debug!("Cascade pseudo for {:?} {:?}", self, pseudo); - self.cascade_eager_pseudo(context, data, &pseudo, cascade_visited); - } - } - /// Returns computed values without animation and transition rules. - fn get_base_style(&self, - shared_context: &SharedStyleContext, - font_metrics_provider: &FontMetricsProvider, - primary_style: &Arc, - pseudo_style: Option<&Arc>) - -> Arc { - let relevant_style = pseudo_style.unwrap_or(primary_style); - let rule_node = relevant_style.rules(); + fn get_base_style( + &self, + context: &mut StyleContext, + style: &Arc, + ) -> Arc { + use style_resolver::StyleResolverForElement; + + let rule_node = style.rules.as_ref().unwrap(); let without_animation_rules = - shared_context.stylist.rule_tree().remove_animation_rules(rule_node); + context.shared.stylist.rule_tree().remove_animation_rules(rule_node); if without_animation_rules == *rule_node { - // Note that unwrapping here is fine, because the style is - // only incomplete during the styling process. - return relevant_style.clone(); + // Note that unwrapping here is fine, because the style is only + // incomplete during the styling process. + return style.clone(); } // This currently ignores visited styles, which seems acceptable, // as existing browsers don't appear to animate visited styles. - self.cascade_with_rules(shared_context, - font_metrics_provider, - &without_animation_rules, - Some(primary_style), - CascadeTarget::Normal, - CascadeVisitedMode::Unvisited, - /* parent_info = */ None, - None) - } + let inputs = + CascadeInputs { + rules: Some(without_animation_rules), + visited_rules: None, + }; + let style = + StyleResolverForElement::new(*self, context, RuleInclusion::All) + .cascade_style_and_visited_with_default_parents(inputs); + style + } } impl MatchMethods for E {} diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs index de94c5a0fca..58f0b3bcc68 100644 --- a/components/style/properties/properties.mako.rs +++ b/components/style/properties/properties.mako.rs @@ -2576,11 +2576,11 @@ pub fn cascade(device: &Device, flags: CascadeFlags, quirks_mode: QuirksMode) -> ComputedValues { - debug_assert_eq!(parent_style.is_some(), layout_parent_style.is_some()); + debug_assert!(layout_parent_style.is_none() || parent_style.is_some()); let (inherited_style, layout_parent_style) = match parent_style { Some(parent_style) => { (parent_style, - layout_parent_style.unwrap()) + layout_parent_style.unwrap_or(parent_style)) }, None => { (device.default_computed_values(), diff --git a/components/style/sharing/mod.rs b/components/style/sharing/mod.rs index 39ddd2faf89..c7c2c946cc8 100644 --- a/components/style/sharing/mod.rs +++ b/components/style/sharing/mod.rs @@ -75,7 +75,7 @@ use dom::{TElement, SendElement}; use matching::{ChildCascadeRequirement, MatchMethods}; use properties::ComputedValues; use selector_parser::RestyleDamage; -use selectors::matching::{ElementSelectorFlags, VisitedHandlingMode, StyleRelations}; +use selectors::matching::{ElementSelectorFlags, VisitedHandlingMode}; use smallvec::SmallVec; use std::mem; use std::ops::Deref; @@ -494,11 +494,8 @@ impl StyleSharingCandidateCache { pub fn insert_if_possible(&mut self, element: &E, style: &ComputedValues, - relations: StyleRelations, - mut validation_data: ValidationData, + validation_data: ValidationData, dom_depth: usize) { - use selectors::matching::AFFECTED_BY_PRESENTATIONAL_HINTS; - let parent = match element.traversal_parent() { Some(element) => element, None => { @@ -525,13 +522,6 @@ impl StyleSharingCandidateCache { return; } - // Take advantage of the information we've learned during - // selector-matching. - if !relations.intersects(AFFECTED_BY_PRESENTATIONAL_HINTS) { - debug_assert!(validation_data.pres_hints.as_ref().map_or(true, |v| v.is_empty())); - validation_data.pres_hints = Some(SmallVec::new()); - } - debug!("Inserting into cache: {:?} with parent {:?}", element, parent); if self.dom_depth != dom_depth { diff --git a/components/style/style_resolver.rs b/components/style/style_resolver.rs index e926ba69f95..1dc38baa975 100644 --- a/components/style/style_resolver.rs +++ b/components/style/style_resolver.rs @@ -6,7 +6,7 @@ use applicable_declarations::ApplicableDeclarationList; use cascade_info::CascadeInfo; -use context::StyleContext; +use context::{CascadeInputs, ElementCascadeInputs, StyleContext}; use data::{ElementStyles, EagerPseudoStyles}; use dom::TElement; use log::LogLevel::Trace; @@ -42,11 +42,37 @@ struct MatchingResults { pub struct PrimaryStyle { /// The style per se. pub style: Arc, +} - /// Whether a relevant link was found while computing this style. - /// - /// FIXME(emilio): Slightly out of place? - pub relevant_link_found: bool, +fn with_default_parent_styles(element: E, f: F) -> R +where + E: TElement, + F: FnOnce(Option<&ComputedValues>, Option<&ComputedValues>) -> R, +{ + let parent_el = element.inheritance_parent(); + let parent_data = parent_el.as_ref().and_then(|e| e.borrow_data()); + let parent_style = parent_data.as_ref().map(|d| { + // Sometimes Gecko eagerly styles things without processing + // pending restyles first. In general we'd like to avoid this, + // but there can be good reasons (for example, needing to + // construct a frame for some small piece of newly-added + // content in order to do something specific with that frame, + // but not wanting to flush all of layout). + debug_assert!(cfg!(feature = "gecko") || + parent_el.unwrap().has_current_styles(d)); + d.styles.primary() + }); + + let mut layout_parent_el = parent_el.clone(); + let layout_parent_data; + let mut layout_parent_style = parent_style; + if parent_style.map_or(false, |s| s.is_display_contents()) { + layout_parent_el = Some(layout_parent_el.unwrap().layout_parent()); + layout_parent_data = layout_parent_el.as_ref().unwrap().borrow_data().unwrap(); + layout_parent_style = Some(layout_parent_data.styles.primary()); + } + + f(parent_style.map(|s| &**s), layout_parent_style.map(|s| &**s)) } impl<'a, 'ctx, 'le, E> StyleResolverForElement<'a, 'ctx, 'le, E> @@ -95,7 +121,7 @@ where if should_compute_visited_style { visited_style = Some(self.cascade_style( - visited_rules.as_ref().unwrap_or(&primary_results.rule_node), + visited_rules.as_ref(), /* style_if_visited = */ None, parent_style, layout_parent_style, @@ -105,7 +131,7 @@ where } let style = self.cascade_style( - &primary_results.rule_node, + Some(&primary_results.rule_node), visited_style, parent_style, layout_parent_style, @@ -113,7 +139,7 @@ where /* pseudo = */ None, ); - PrimaryStyle { style, relevant_link_found, } + PrimaryStyle { style, } } @@ -137,7 +163,7 @@ where } } - { + if self.element.implemented_pseudo_element().is_none() { let layout_parent_style_for_pseudo = if primary_style.style.is_display_contents() { layout_parent_style @@ -163,6 +189,115 @@ where } } + /// Resolve an element's styles with the default inheritance parent/layout + /// parents. + pub fn resolve_style_with_default_parents(&mut self) -> ElementStyles { + with_default_parent_styles(self.element, |parent_style, layout_parent_style| { + self.resolve_style(parent_style, layout_parent_style) + }) + } + + /// Cascade a set of rules, using the default parent for inheritance. + pub fn cascade_style_and_visited_with_default_parents( + &mut self, + inputs: CascadeInputs, + ) -> Arc { + with_default_parent_styles(self.element, |parent_style, layout_parent_style| { + self.cascade_style_and_visited( + inputs, + parent_style, + layout_parent_style, + /* pseudo = */ None + ) + }) + } + + fn cascade_style_and_visited( + &mut self, + inputs: CascadeInputs, + parent_style: Option<&ComputedValues>, + layout_parent_style: Option<&ComputedValues>, + pseudo: Option<&PseudoElement>, + ) -> Arc { + let mut style_if_visited = None; + if parent_style.map_or(false, |s| s.get_visited_style().is_some()) || + inputs.visited_rules.is_some() { + style_if_visited = Some(self.cascade_style( + inputs.visited_rules.as_ref(), + /* style_if_visited = */ None, + parent_style, + layout_parent_style, + CascadeVisitedMode::Visited, + pseudo, + )); + } + self.cascade_style( + inputs.rules.as_ref(), + style_if_visited, + parent_style, + layout_parent_style, + CascadeVisitedMode::Unvisited, + pseudo, + ) + } + + /// Cascade the element and pseudo-element styles with the default parents. + pub fn cascade_styles_with_default_parents( + &mut self, + inputs: ElementCascadeInputs, + ) -> ElementStyles { + use properties::longhands::display::computed_value::T as display; + with_default_parent_styles(self.element, move |parent_style, layout_parent_style| { + let primary_style = PrimaryStyle { + style: self.cascade_style_and_visited( + inputs.primary, + parent_style, + layout_parent_style, + /* pseudo = */ None, + ), + }; + + let mut pseudo_styles = EagerPseudoStyles::default(); + let pseudo_array = inputs.pseudos.into_array(); + if pseudo_array.is_none() || + primary_style.style.get_box().clone_display() == display::none { + return ElementStyles { + primary: Some(primary_style.style), + pseudos: pseudo_styles, + } + } + + { + let layout_parent_style_for_pseudo = + if primary_style.style.is_display_contents() { + layout_parent_style + } else { + Some(&*primary_style.style) + }; + + for (i, mut inputs) in pseudo_array.unwrap().iter_mut().enumerate() { + if let Some(inputs) = inputs.take() { + let pseudo = PseudoElement::from_eager_index(i); + pseudo_styles.set( + &pseudo, + self.cascade_style_and_visited( + inputs, + Some(&*primary_style.style), + layout_parent_style_for_pseudo, + Some(&pseudo), + ) + ) + } + } + } + + ElementStyles { + primary: Some(primary_style.style), + pseudos: pseudo_styles, + } + }) + } + fn resolve_pseudo_style( &mut self, pseudo: &PseudoElement, @@ -179,33 +314,23 @@ where None => return None, }; - let mut visited_style = None; - if originating_element_style.relevant_link_found { - let visited_rules = self.match_pseudo( + let mut visited_rules = None; + if originating_element_style.style.get_visited_style().is_some() { + visited_rules = self.match_pseudo( &originating_element_style.style, pseudo, VisitedHandlingMode::RelevantLinkVisited, ); - - if let Some(ref rules) = visited_rules { - visited_style = Some(self.cascade_style( - rules, - /* style_if_visited = */ None, - Some(&originating_element_style.style), - layout_parent_style, - CascadeVisitedMode::Visited, - Some(pseudo), - )); - } } - Some(self.cascade_style( - &rules, - visited_style, + Some(self.cascade_style_and_visited( + CascadeInputs { + rules: Some(rules), + visited_rules + }, Some(&originating_element_style.style), layout_parent_style, - CascadeVisitedMode::Unvisited, - Some(pseudo) + Some(pseudo), )) } @@ -335,9 +460,9 @@ where fn cascade_style( &mut self, - rules: &StrongRuleNode, + rules: Option<&StrongRuleNode>, style_if_visited: Option>, - parent_style: Option<&ComputedValues>, + mut parent_style: Option<&ComputedValues>, layout_parent_style: Option<&ComputedValues>, cascade_visited: CascadeVisitedMode, pseudo: Option<&PseudoElement>, @@ -349,6 +474,9 @@ where cascade_flags.insert(SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP); } if cascade_visited.visited_dependent_only() { + parent_style = parent_style.map(|s| { + s.get_visited_style().map(|s| &**s).unwrap_or(s) + }); cascade_flags.insert(VISITED_DEPENDENT_ONLY); } if self.element.is_native_anonymous() || pseudo.is_some() { @@ -360,13 +488,12 @@ where let values = Arc::new(cascade( self.context.shared.stylist.device(), - rules, + rules.unwrap_or(self.context.shared.stylist.rule_tree().root()), &self.context.shared.guards, parent_style, layout_parent_style, style_if_visited, Some(&mut cascade_info), - &*self.context.shared.error_reporter, &self.context.thread_local.font_metrics_provider, cascade_flags, self.context.shared.quirks_mode diff --git a/components/style/stylist.rs b/components/style/stylist.rs index 0a7f6c105f8..dadcec02a1e 100644 --- a/components/style/stylist.rs +++ b/components/style/stylist.rs @@ -15,7 +15,6 @@ use font_metrics::FontMetricsProvider; use gecko_bindings::structs::{nsIAtom, StyleRuleInclusion}; use invalidation::element::invalidation_map::InvalidationMap; use invalidation::media_queries::{EffectiveMediaQueryResults, ToMediaListKey}; -use matching::CascadeVisitedMode; use media_queries::Device; use properties::{self, CascadeFlags, ComputedValues}; use properties::{AnimationRules, PropertyDeclarationBlock}; @@ -719,24 +718,30 @@ impl Stylist { { // We may have only visited rules in cases when we are actually // resolving, not probing, pseudo-element style. - if !inputs.has_rules() && !inputs.has_visited_rules() { + if inputs.rules.is_none() && inputs.visited_rules.is_none() { return None } // We need to compute visited values if we have visited rules or if our // parent has visited values. - let visited_values = if inputs.has_visited_rules() || parent_style.get_visited_style().is_some() { + let visited_values = if inputs.visited_rules.is_some() || parent_style.get_visited_style().is_some() { // Slightly annoying: we know that inputs has either rules or // visited rules, but we can't do inputs.rules() up front because // maybe it just has visited rules, so can't unwrap_or. - let rule_node = match inputs.get_visited_rules() { + let rule_node = match inputs.visited_rules.as_ref() { Some(rules) => rules, - None => inputs.rules() + None => inputs.rules.as_ref().unwrap(), }; // We want to use the visited bits (if any) from our parent style as // our parent. - let mode = CascadeVisitedMode::Visited; - let inherited_style = mode.values(parent_style); + let inherited_style = + parent_style.get_visited_style().unwrap_or(&*parent_style); + + // FIXME(emilio): The lack of layout_parent_style here could be + // worrying, but we're probably dropping the display fixup for + // pseudos other than before and after, so it's probably ok. + // + // (Though the flags don't indicate so!) let computed = properties::cascade(&self.device, rule_node, @@ -756,7 +761,7 @@ impl Stylist { // We may not have non-visited rules, if we only had visited ones. In // that case we want to use the root rulenode for our non-visited rules. - let rules = inputs.get_rules().unwrap_or(self.rule_tree.root()); + let rules = inputs.rules.as_ref().unwrap_or(self.rule_tree.root()); // Read the comment on `precomputed_values_for_pseudo` to see why it's // difficult to assert that display: contents nodes never arrive here @@ -849,10 +854,10 @@ impl Stylist { let rule_node = self.rule_tree.compute_rule_node(&mut declarations, guards); debug_assert!(rule_node != *self.rule_tree.root()); - inputs.set_rules(VisitedHandlingMode::AllLinksUnvisited, rule_node); + inputs.rules = Some(rule_node); } - if is_probe && !inputs.has_rules() { + if is_probe && inputs.rules.is_none() { // When probing, don't compute visited styles if we have no // unvisited styles. return inputs; @@ -880,8 +885,7 @@ impl Stylist { declarations.into_iter().map(|a| a.order_and_level()), guards); if rule_node != *self.rule_tree.root() { - inputs.set_rules(VisitedHandlingMode::RelevantLinkVisited, - rule_node); + inputs.visited_rules = Some(rule_node); } } } diff --git a/components/style/traversal.rs b/components/style/traversal.rs index d7b0835a991..59a568e31a7 100644 --- a/components/style/traversal.rs +++ b/components/style/traversal.rs @@ -10,8 +10,9 @@ use data::{ElementData, ElementStyles}; use dom::{NodeInfo, OpaqueNode, TElement, TNode}; use invalidation::element::restyle_hints::{RECASCADE_SELF, RECASCADE_DESCENDANTS, RestyleHint}; use matching::{ChildCascadeRequirement, MatchMethods}; -use sharing::{StyleSharingBehavior, StyleSharingTarget}; +use sharing::StyleSharingTarget; use smallvec::SmallVec; +use style_resolver::StyleResolverForElement; use stylist::RuleInclusion; /// A per-traversal-level chunk of data. This is sent down by the traversal, and @@ -765,7 +766,8 @@ where data.restyle.set_restyled(); } - match kind { + let mut important_rules_changed = false; + let new_styles = match kind { MatchAndCascade => { debug_assert!(!context.shared.traversal_flags.for_animation_only(), "MatchAndCascade shouldn't be processed during \ @@ -790,35 +792,62 @@ where context.thread_local.statistics.elements_matched += 1; + important_rules_changed = true; + // Perform the matching and cascading. - element.match_and_cascade( - context, - data, - StyleSharingBehavior::Allow - ) + let new_styles = + StyleResolverForElement::new(element, context, RuleInclusion::All) + .resolve_style_with_default_parents(); + + // If we previously tried to match this element against the cache, + // the revalidation match results will already be cached. Otherwise + // we'll have None, and compute them later on-demand. + // + // If we do have the results, grab them here to satisfy the borrow + // checker. + let validation_data = + context.thread_local + .current_element_info + .as_mut().unwrap() + .validation_data + .take(); + + let dom_depth = context.thread_local.bloom_filter.matching_depth(); + context.thread_local + .style_sharing_candidate_cache + .insert_if_possible( + &element, + new_styles.primary(), + validation_data, + dom_depth + ); + + new_styles } CascadeWithReplacements(flags) => { // Skipping full matching, load cascade inputs from previous values. - *context.cascade_inputs_mut() = + let mut cascade_inputs = ElementCascadeInputs::new_from_element_data(data); - let important_rules_changed = element.replace_rules(flags, context); - element.cascade_primary_and_pseudos( - context, - data, - important_rules_changed - ) + important_rules_changed = + element.replace_rules(flags, context, &mut cascade_inputs); + StyleResolverForElement::new(element, context, RuleInclusion::All) + .cascade_styles_with_default_parents(cascade_inputs) } CascadeOnly => { // Skipping full matching, load cascade inputs from previous values. - *context.cascade_inputs_mut() = + let cascade_inputs = ElementCascadeInputs::new_from_element_data(data); - element.cascade_primary_and_pseudos( - context, - data, - /* important_rules_changed = */ false - ) + StyleResolverForElement::new(element, context, RuleInclusion::All) + .cascade_styles_with_default_parents(cascade_inputs) } - } + }; + + element.finish_restyle( + context, + data, + new_styles, + important_rules_changed + ) } fn preprocess_children( diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs index 3e049e1da3d..cb848fecc65 100644 --- a/ports/geckolib/glue.rs +++ b/ports/geckolib/glue.rs @@ -664,32 +664,35 @@ pub extern "C" fn Servo_StyleSet_GetBaseComputedValuesForElement(raw_data: RawSe let doc_data = PerDocumentStyleData::from_ffi(raw_data).borrow(); let global_style_data = &*GLOBAL_STYLE_DATA; let guard = global_style_data.shared_lock.read(); - let shared_context = create_shared_context(&global_style_data, - &guard, - &doc_data, - TraversalFlags::empty(), - unsafe { &*snapshots }); + let element = GeckoElement(element); let element_data = element.borrow_data().unwrap(); let styles = &element_data.styles; - let pseudo = PseudoElement::from_pseudo_type(pseudo_type); - let pseudos = &styles.pseudos; - let pseudo_style = match pseudo { - Some(ref p) => { - let style = pseudos.get(p); - debug_assert!(style.is_some()); - style - } - None => None, + if let Some(pseudo) = PseudoElement::from_pseudo_type(pseudo_type) { + // This style already doesn't have animations. + return styles + .pseudos + .get(&pseudo) + .expect("GetBaseComputedValuesForElement for an unexisting pseudo?") + .clone().into_strong(); + } + + let shared = create_shared_context(&global_style_data, + &guard, + &doc_data, + TraversalFlags::empty(), + unsafe { &*snapshots }); + let mut tlc = ThreadLocalStyleContext::new(&shared); + let mut context = StyleContext { + shared: &shared, + thread_local: &mut tlc, }; - let provider = get_metrics_provider_for_product(); - element.get_base_style(&shared_context, - &provider, - styles.primary(), - pseudo_style) - .into_strong() + element.get_base_style( + &mut context, + styles.primary(), + ).into_strong() } #[no_mangle] From d15acc219e7ed1f6cad34579206d2c76fff433dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Mon, 10 Jul 2017 13:33:21 +0200 Subject: [PATCH 08/11] style: Allow calling GetBaseComputedStylesForElement for an unstyled element. Before this refactoring, getComputedStyle could have side effects, and left the style data in the element, so we could never arrive there without data. There are a few crashtests that caught this, but this was already broken if you called animate() on an element deep in a display: none subtree. MozReview-Commit-ID: 1AvOvhAyOP3 --- components/style/matching.rs | 31 --------------------------- ports/geckolib/glue.rs | 41 +++++++++++++++++++++++++++++------- 2 files changed, 33 insertions(+), 39 deletions(-) diff --git a/components/style/matching.rs b/components/style/matching.rs index 6b20226a620..bf31369ba3a 100644 --- a/components/style/matching.rs +++ b/components/style/matching.rs @@ -840,37 +840,6 @@ pub trait MatchMethods : TElement { // StyleChange::Changed conservatively. StyleDifference::new(damage, StyleChange::Changed) } - - /// Returns computed values without animation and transition rules. - fn get_base_style( - &self, - context: &mut StyleContext, - style: &Arc, - ) -> Arc { - use style_resolver::StyleResolverForElement; - - let rule_node = style.rules.as_ref().unwrap(); - let without_animation_rules = - context.shared.stylist.rule_tree().remove_animation_rules(rule_node); - if without_animation_rules == *rule_node { - // Note that unwrapping here is fine, because the style is only - // incomplete during the styling process. - return style.clone(); - } - - // This currently ignores visited styles, which seems acceptable, - // as existing browsers don't appear to animate visited styles. - let inputs = - CascadeInputs { - rules: Some(without_animation_rules), - visited_rules: None, - }; - - let style = - StyleResolverForElement::new(*self, context, RuleInclusion::All) - .cascade_style_and_visited_with_default_parents(inputs); - style - } } impl MatchMethods for E {} diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs index cb848fecc65..665d20716c0 100644 --- a/ports/geckolib/glue.rs +++ b/ports/geckolib/glue.rs @@ -654,19 +654,35 @@ pub extern "C" fn Servo_AnimationValue_Uncompute(value: RawServoAnimationValueBo #[no_mangle] pub extern "C" fn Servo_StyleSet_GetBaseComputedValuesForElement(raw_data: RawServoStyleSetBorrowed, element: RawGeckoElementBorrowed, + computed_values: ServoComputedValuesBorrowed, snapshots: *const ServoElementSnapshotTable, pseudo_type: CSSPseudoElementType) -> ServoComputedValuesStrong { - use style::matching::MatchMethods; + use style::style_resolver::StyleResolverForElement; + debug_assert!(!snapshots.is_null()); + let computed_values = ComputedValues::as_arc(&computed_values); + + let rules = match computed_values.rules { + None => return computed_values.clone().into_strong(), + Some(ref rules) => rules, + }; let doc_data = PerDocumentStyleData::from_ffi(raw_data).borrow(); - let global_style_data = &*GLOBAL_STYLE_DATA; - let guard = global_style_data.shared_lock.read(); + let without_animations = + doc_data.stylist.rule_tree().remove_animation_rules(rules); + + if without_animations == *rules { + return computed_values.clone().into_strong(); + } let element = GeckoElement(element); - let element_data = element.borrow_data().unwrap(); + + let element_data = match element.borrow_data() { + Some(data) => data, + None => return computed_values.clone().into_strong(), + }; let styles = &element_data.styles; if let Some(pseudo) = PseudoElement::from_pseudo_type(pseudo_type) { @@ -678,6 +694,8 @@ pub extern "C" fn Servo_StyleSet_GetBaseComputedValuesForElement(raw_data: RawSe .clone().into_strong(); } + let global_style_data = &*GLOBAL_STYLE_DATA; + let guard = global_style_data.shared_lock.read(); let shared = create_shared_context(&global_style_data, &guard, &doc_data, @@ -689,10 +707,17 @@ pub extern "C" fn Servo_StyleSet_GetBaseComputedValuesForElement(raw_data: RawSe thread_local: &mut tlc, }; - element.get_base_style( - &mut context, - styles.primary(), - ).into_strong() + // This currently ignores visited styles, which seems acceptable, as + // existing browsers don't appear to animate visited styles. + let inputs = + CascadeInputs { + rules: Some(without_animations), + visited_rules: None, + }; + + StyleResolverForElement::new(element, &mut context, RuleInclusion::All) + .cascade_style_and_visited_with_default_parents(inputs) + .into_strong() } #[no_mangle] From d3c88445495f8fd6b3d11fb1fda9640a1d924067 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Mon, 10 Jul 2017 14:31:44 +0200 Subject: [PATCH 09/11] style: Remove unnecessary TraversalFlags::FOR_DEFAULT_STYLES. Yay MozReview-Commit-ID: JiWTEz63AlE --- components/style/traversal.rs | 8 -------- ports/geckolib/glue.rs | 9 ++------- 2 files changed, 2 insertions(+), 15 deletions(-) diff --git a/components/style/traversal.rs b/components/style/traversal.rs index 59a568e31a7..70eb8ce5e84 100644 --- a/components/style/traversal.rs +++ b/components/style/traversal.rs @@ -42,8 +42,6 @@ bitflags! { /// Traverse and update all elements with CSS animations since /// @keyframes rules may have changed const FOR_CSS_RULE_CHANGES = 0x08, - /// Only include user agent style sheets when selector matching. - const FOR_DEFAULT_STYLES = 0x10, } } @@ -67,12 +65,6 @@ impl TraversalFlags { pub fn for_css_rule_changes(&self) -> bool { self.contains(FOR_CSS_RULE_CHANGES) } - - /// Returns true if the traversal is to compute the default computed styles - /// for an element. - pub fn for_default_styles(&self) -> bool { - self.contains(FOR_DEFAULT_STYLES) - } } /// This structure exists to enforce that callers invoke pre_traverse, and also diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs index 665d20716c0..baee4e4e490 100644 --- a/ports/geckolib/glue.rs +++ b/ports/geckolib/glue.rs @@ -113,7 +113,7 @@ use style::stylist::RuleInclusion; use style::thread_state; use style::timer::Timer; use style::traversal::{ANIMATION_ONLY, DomTraversal, FOR_CSS_RULE_CHANGES, FOR_RECONSTRUCT}; -use style::traversal::{FOR_DEFAULT_STYLES, TraversalDriver, TraversalFlags, UNSTYLED_CHILDREN_ONLY}; +use style::traversal::{TraversalDriver, TraversalFlags, UNSTYLED_CHILDREN_ONLY}; use style::traversal::resolve_style; use style::values::{CustomIdent, KeyframesName}; use style::values::computed::Context; @@ -2797,16 +2797,11 @@ pub extern "C" fn Servo_ResolveStyleLazily(element: RawGeckoElementBorrowed, } } - let traversal_flags = match rule_inclusion { - RuleInclusion::All => TraversalFlags::empty(), - RuleInclusion::DefaultOnly => FOR_DEFAULT_STYLES, - }; - // We don't have the style ready. Go ahead and compute it as necessary. let shared = create_shared_context(&global_style_data, &guard, &data, - traversal_flags, + TraversalFlags::empty(), unsafe { &*snapshots }); let mut tlc = ThreadLocalStyleContext::new(&shared); let mut context = StyleContext { From 6d6c80e79b9e62b38557125f509158a5fca75253 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Tue, 11 Jul 2017 16:29:49 +0200 Subject: [PATCH 10/11] style: Remove StyleRelations. They're unused now. We can add them back if needed. MozReview-Commit-ID: 92Y2Na0ZbVn --- components/selectors/context.rs | 18 ------------------ components/selectors/matching.rs | 2 -- components/style/stylist.rs | 17 +---------------- 3 files changed, 1 insertion(+), 36 deletions(-) diff --git a/components/selectors/context.rs b/components/selectors/context.rs index e27cd6811bb..6cf516b74fc 100644 --- a/components/selectors/context.rs +++ b/components/selectors/context.rs @@ -5,19 +5,6 @@ use attr::CaseSensitivity; use bloom::BloomFilter; -bitflags! { - /// Set of flags that determine the different kind of elements affected by - /// the selector matching process. - /// - /// This is used to implement efficient sharing. - #[derive(Default)] - pub flags StyleRelations: usize { - /// Whether this element is affected by presentational hints. This is - /// computed externally (that is, in Servo). - const AFFECTED_BY_PRESENTATIONAL_HINTS = 1 << 0, - } -} - /// What kind of selector matching mode we should use. /// /// There are two modes of selector matching. The difference is only noticeable @@ -87,9 +74,6 @@ impl QuirksMode { /// transient data that applies to only a single selector. #[derive(Clone)] pub struct MatchingContext<'a> { - /// Output that records certains relations between elements noticed during - /// matching (and also extended after matching). - pub relations: StyleRelations, /// Input with the matching mode we should use when matching selectors. pub matching_mode: MatchingMode, /// Input with the bloom filter used to fast-reject selectors. @@ -114,7 +98,6 @@ impl<'a> MatchingContext<'a> { -> Self { Self { - relations: StyleRelations::empty(), matching_mode: matching_mode, bloom_filter: bloom_filter, visited_handling: VisitedHandlingMode::AllLinksUnvisited, @@ -132,7 +115,6 @@ impl<'a> MatchingContext<'a> { -> Self { Self { - relations: StyleRelations::empty(), matching_mode: matching_mode, bloom_filter: bloom_filter, visited_handling: visited_handling, diff --git a/components/selectors/matching.rs b/components/selectors/matching.rs index 3d6e86671e3..9fc5b0815a1 100644 --- a/components/selectors/matching.rs +++ b/components/selectors/matching.rs @@ -714,8 +714,6 @@ fn matches_simple_selector( matches_last_child(element, flags_setter) } Component::Root => { - // We never share styles with an element with no parent, so no point - // in creating a new StyleRelation. element.is_root() } Component::Empty => { diff --git a/components/style/stylist.rs b/components/style/stylist.rs index dadcec02a1e..6c429a427bf 100644 --- a/components/style/stylist.rs +++ b/components/style/stylist.rs @@ -26,7 +26,7 @@ use selector_parser::{SelectorImpl, PseudoElement}; use selectors::attr::NamespaceConstraint; use selectors::bloom::BloomFilter; use selectors::matching::{ElementSelectorFlags, matches_selector, MatchingContext, MatchingMode}; -use selectors::matching::{VisitedHandlingMode, AFFECTED_BY_PRESENTATIONAL_HINTS}; +use selectors::matching::VisitedHandlingMode; use selectors::parser::{AncestorHashes, Combinator, Component, Selector, SelectorAndHashes}; use selectors::parser::{SelectorIter, SelectorMethods}; use selectors::sink::Push; @@ -1145,7 +1145,6 @@ impl Stylist { self.quirks_mode, flags_setter, CascadeLevel::UANormal); - debug!("UA normal: {:?}", context.relations); if pseudo_element.is_none() && !only_default_rules { // Step 2: Presentational hints. @@ -1160,12 +1159,7 @@ impl Stylist { assert_eq!(declaration.level(), CascadeLevel::PresHints); } } - // Note the existence of presentational attributes so that the - // style sharing cache can avoid re-querying them if they don't - // exist. - context.relations |= AFFECTED_BY_PRESENTATIONAL_HINTS; } - debug!("preshints: {:?}", context.relations); } // NB: the following condition, although it may look somewhat @@ -1185,7 +1179,6 @@ impl Stylist { self.quirks_mode, flags_setter, CascadeLevel::UserNormal); - debug!("user normal: {:?}", context.relations); } else { debug!("skipping user rules"); } @@ -1194,7 +1187,6 @@ impl Stylist { let cut_off_inheritance = element.get_declarations_from_xbl_bindings(pseudo_element, applicable_declarations); - debug!("XBL: {:?}", context.relations); if rule_hash_target.matches_user_and_author_rules() && !only_default_rules { // Gecko skips author normal rules if cutting off inheritance. @@ -1208,7 +1200,6 @@ impl Stylist { self.quirks_mode, flags_setter, CascadeLevel::AuthorNormal); - debug!("author normal: {:?}", context.relations); } else { debug!("skipping author normal rules due to cut off inheritance"); } @@ -1224,7 +1215,6 @@ impl Stylist { ApplicableDeclarationBlock::from_declarations(sa.clone(), CascadeLevel::StyleAttributeNormal)); } - debug!("style attr: {:?}", context.relations); // Step 5: SMIL override. // Declarations from SVG SMIL animation elements. @@ -1234,7 +1224,6 @@ impl Stylist { ApplicableDeclarationBlock::from_declarations(so.clone(), CascadeLevel::SMILOverride)); } - debug!("SMIL: {:?}", context.relations); // Step 6: Animations. // The animations sheet (CSS animations, script-generated animations, @@ -1245,7 +1234,6 @@ impl Stylist { ApplicableDeclarationBlock::from_declarations(anim.clone(), CascadeLevel::Animations)); } - debug!("animation: {:?}", context.relations); } else { debug!("skipping style attr and SMIL & animation rules"); } @@ -1264,12 +1252,9 @@ impl Stylist { ApplicableDeclarationBlock::from_declarations(anim.clone(), CascadeLevel::Transitions)); } - debug!("transition: {:?}", context.relations); } else { debug!("skipping transition rules"); } - - debug!("push_applicable_declarations: shareable: {:?}", context.relations); } /// Given an id, returns whether there might be any rules for that id in any From e24d81dbe7ed15112213a277219cd5b7687ceb17 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Wed, 12 Jul 2017 08:53:21 +0200 Subject: [PATCH 11/11] stylo: Update bindings. --- .../style/gecko/generated/atom_macro.rs | 8 + components/style/gecko/generated/bindings.rs | 2 + .../style/gecko/generated/structs_debug.rs | 4914 ++++++++--------- .../style/gecko/generated/structs_release.rs | 4113 +++++++------- 4 files changed, 4480 insertions(+), 4557 deletions(-) diff --git a/components/style/gecko/generated/atom_macro.rs b/components/style/gecko/generated/atom_macro.rs index 03614e69502..af882c0cb41 100644 --- a/components/style/gecko/generated/atom_macro.rs +++ b/components/style/gecko/generated/atom_macro.rs @@ -240,6 +240,8 @@ cfg_if! { pub static nsGkAtoms_arrow: *mut nsIAtom; #[link_name = "_ZN9nsGkAtoms7articleE"] pub static nsGkAtoms_article: *mut nsIAtom; + #[link_name = "_ZN9nsGkAtoms2asE"] + pub static nsGkAtoms_as: *mut nsIAtom; #[link_name = "_ZN9nsGkAtoms9ascendingE"] pub static nsGkAtoms_ascending: *mut nsIAtom; #[link_name = "_ZN9nsGkAtoms5asideE"] @@ -5367,6 +5369,8 @@ cfg_if! { pub static nsGkAtoms_arrow: *mut nsIAtom; #[link_name = "?article@nsGkAtoms@@2PEAVnsIAtom@@EA"] pub static nsGkAtoms_article: *mut nsIAtom; + #[link_name = "?as@nsGkAtoms@@2PEAVnsIAtom@@EA"] + pub static nsGkAtoms_as: *mut nsIAtom; #[link_name = "?ascending@nsGkAtoms@@2PEAVnsIAtom@@EA"] pub static nsGkAtoms_ascending: *mut nsIAtom; #[link_name = "?aside@nsGkAtoms@@2PEAVnsIAtom@@EA"] @@ -10494,6 +10498,8 @@ cfg_if! { pub static nsGkAtoms_arrow: *mut nsIAtom; #[link_name = "\x01?article@nsGkAtoms@@2PAVnsIAtom@@A"] pub static nsGkAtoms_article: *mut nsIAtom; + #[link_name = "\x01?as@nsGkAtoms@@2PAVnsIAtom@@A"] + pub static nsGkAtoms_as: *mut nsIAtom; #[link_name = "\x01?ascending@nsGkAtoms@@2PAVnsIAtom@@A"] pub static nsGkAtoms_ascending: *mut nsIAtom; #[link_name = "\x01?aside@nsGkAtoms@@2PAVnsIAtom@@A"] @@ -15624,6 +15630,8 @@ macro_rules! atom { { unsafe { $crate::string_cache::atom_macro::atom_from_static($crate::string_cache::atom_macro::nsGkAtoms_arrow as *mut _) } }; ("article") => { unsafe { $crate::string_cache::atom_macro::atom_from_static($crate::string_cache::atom_macro::nsGkAtoms_article as *mut _) } }; +("as") => + { unsafe { $crate::string_cache::atom_macro::atom_from_static($crate::string_cache::atom_macro::nsGkAtoms_as as *mut _) } }; ("ascending") => { unsafe { $crate::string_cache::atom_macro::atom_from_static($crate::string_cache::atom_macro::nsGkAtoms_ascending as *mut _) } }; ("aside") => diff --git a/components/style/gecko/generated/bindings.rs b/components/style/gecko/generated/bindings.rs index 55c6b46474e..4f5693e3b9f 100644 --- a/components/style/gecko/generated/bindings.rs +++ b/components/style/gecko/generated/bindings.rs @@ -2752,6 +2752,8 @@ extern "C" { RawServoStyleSetBorrowed, element: RawGeckoElementBorrowed, + existing_style: + ServoComputedValuesBorrowed, snapshots: *const ServoElementSnapshotTable, pseudo_type: diff --git a/components/style/gecko/generated/structs_debug.rs b/components/style/gecko/generated/structs_debug.rs index b9dc576e2b8..2376b088bab 100644 --- a/components/style/gecko/generated/structs_debug.rs +++ b/components/style/gecko/generated/structs_debug.rs @@ -981,6 +981,9 @@ pub mod root { pub const CSS_PSEUDO_ELEMENT_UA_SHEET_ONLY: ::std::os::raw::c_uint = 16; pub const CSS_PSEUDO_ELEMENT_IS_JS_CREATED_NAC: ::std::os::raw::c_uint = 32; + pub const CSS_PSEUDO_ELEMENT_IS_FLEX_OR_GRID_ITEM: ::std::os::raw::c_uint + = + 64; pub const kNameSpaceID_Unknown: ::std::os::raw::c_int = -1; pub const kNameSpaceID_XMLNS: ::std::os::raw::c_uint = 1; pub const kNameSpaceID_XML: ::std::os::raw::c_uint = 2; @@ -1033,6 +1036,16 @@ pub mod root { use self::super::super::root; #[repr(C)] #[derive(Debug, Copy, Clone)] + pub struct __is_swappable { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct __is_nothrow_swappable { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Copy, Clone)] pub struct pair<_T1, _T2> { pub first: _T1, pub second: _T2, @@ -1041,19 +1054,8 @@ pub mod root { } pub type pair_first_type<_T1> = _T1; pub type pair_second_type<_T2> = _T2; - pub type pair__EnableB = u8; - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct pair__CheckArgs { - pub _address: u8, - } - pub type pair__CheckArgsDep = u8; - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct pair__CheckTupleLikeConstructor { - pub _address: u8, - } - pub type pair__CheckTLC = u8; + pub type pair__PCCP = u8; + pub type pair__PCCFP = u8; #[repr(C)] #[derive(Debug, Copy)] pub struct input_iterator_tag { @@ -1073,101 +1075,54 @@ pub mod root { fn clone(&self) -> Self { *self } } #[repr(C)] - #[derive(Debug, Copy)] - pub struct forward_iterator_tag { + #[derive(Debug, Copy, Clone)] + pub struct iterator { pub _address: u8, } - #[test] - fn bindgen_test_layout_forward_iterator_tag() { - assert_eq!(::std::mem::size_of::() , 1usize - , concat ! ( - "Size of: " , stringify ! ( forward_iterator_tag ) )); - assert_eq! (::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of " , stringify ! ( forward_iterator_tag ) - )); - } - impl Clone for forward_iterator_tag { - fn clone(&self) -> Self { *self } - } + pub type iterator_iterator_category<_Category> = _Category; + pub type iterator_value_type<_Tp> = _Tp; + pub type iterator_difference_type<_Distance> = _Distance; + pub type iterator_pointer<_Pointer> = _Pointer; + pub type iterator_reference<_Reference> = _Reference; #[repr(C)] - #[derive(Debug, Copy)] - pub struct bidirectional_iterator_tag { + #[derive(Debug, Copy, Clone)] + pub struct __iterator_traits { pub _address: u8, } - #[test] - fn bindgen_test_layout_bidirectional_iterator_tag() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of: " , stringify ! ( bidirectional_iterator_tag - ) )); - assert_eq! (::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of " , stringify ! ( - bidirectional_iterator_tag ) )); - } - impl Clone for bidirectional_iterator_tag { - fn clone(&self) -> Self { *self } - } - #[repr(C)] - #[derive(Debug, Copy)] - pub struct random_access_iterator_tag { - pub _address: u8, - } - #[test] - fn bindgen_test_layout_random_access_iterator_tag() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of: " , stringify ! ( random_access_iterator_tag - ) )); - assert_eq! (::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of " , stringify ! ( - random_access_iterator_tag ) )); - } - impl Clone for random_access_iterator_tag { - fn clone(&self) -> Self { *self } - } #[repr(C)] + #[derive(Debug, Copy, Clone)] pub struct iterator_traits { pub _address: u8, } #[repr(C)] #[derive(Debug, Copy, Clone)] - pub struct iterator { - pub _address: u8, + pub struct reverse_iterator<_Iterator> { + pub current: _Iterator, + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iterator>>, } - pub type iterator_value_type<_Tp> = _Tp; - pub type iterator_difference_type<_Distance> = _Distance; - pub type iterator_pointer<_Pointer> = _Pointer; - pub type iterator_reference<_Reference> = _Reference; - pub type iterator_iterator_category<_Category> = _Category; - #[repr(C)] - pub struct reverse_iterator<_Iter> { - pub __t: _Iter, - pub current: _Iter, - pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iter>>, - } - pub type reverse_iterator_iterator_type<_Iter> = _Iter; + pub type reverse_iterator___traits_type = root::std::iterator_traits; + pub type reverse_iterator_iterator_type<_Iterator> = _Iterator; pub type reverse_iterator_difference_type = - root::std::iterator_traits; - pub type reverse_iterator_reference = root::std::iterator_traits; - pub type reverse_iterator_pointer = root::std::iterator_traits; + root::std::reverse_iterator___traits_type; + pub type reverse_iterator_pointer = + root::std::reverse_iterator___traits_type; + pub type reverse_iterator_reference = + root::std::reverse_iterator___traits_type; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atomic { } - pub type atomic___base = u8; - #[repr(C)] - pub struct __bit_const_reference { - pub __seg_: root::std::__bit_const_reference___storage_pointer, - pub __mask_: root::std::__bit_const_reference___storage_type, + pub mod chrono { + #[allow(unused_imports)] + use self::super::super::super::root; } - pub type __bit_const_reference___storage_type = [u8; 0usize]; - pub type __bit_const_reference___storage_pointer = [u8; 0usize]; } - pub type __int64_t = ::std::os::raw::c_longlong; - pub type __darwin_off_t = root::__int64_t; + pub mod __gnu_cxx { + #[allow(unused_imports)] + use self::super::super::root; + } + pub type __off_t = ::std::os::raw::c_long; + pub type __off64_t = ::std::os::raw::c_long; pub mod mozilla { #[allow(unused_imports)] use self::super::super::root; @@ -1197,7 +1152,8 @@ pub mod root { pub struct nsStringRepr { pub mData: *mut root::mozilla::detail::nsStringRepr_char_type, pub mLength: root::mozilla::detail::nsStringRepr_size_type, - pub mFlags: u32, + pub mDataFlags: root::mozilla::detail::nsStringRepr_DataFlags, + pub mClassFlags: root::mozilla::detail::nsStringRepr_ClassFlags, } pub type nsStringRepr_fallible_t = root::mozilla::fallible_t; pub type nsStringRepr_char_type = u16; @@ -1220,42 +1176,10 @@ pub mod root { *const root::mozilla::detail::nsStringRepr_char_type; pub type nsStringRepr_index_type = u32; pub type nsStringRepr_size_type = u32; - pub const nsStringRepr_F_NONE: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_NONE; - pub const nsStringRepr_F_TERMINATED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_TERMINATED; - pub const nsStringRepr_F_VOIDED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_VOIDED; - pub const nsStringRepr_F_SHARED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_SHARED; - pub const nsStringRepr_F_OWNED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_OWNED; - pub const nsStringRepr_F_FIXED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_FIXED; - pub const nsStringRepr_F_LITERAL: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_LITERAL; - pub const nsStringRepr_F_CLASS_FIXED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_CLASS_FIXED; - #[repr(u32)] - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum nsStringRepr__bindgen_ty_1 { - F_NONE = 0, - F_TERMINATED = 1, - F_VOIDED = 2, - F_SHARED = 4, - F_OWNED = 8, - F_FIXED = 16, - F_LITERAL = 32, - F_CLASS_FIXED = 65536, - } + pub use self::super::super::super::root::mozilla::detail::StringDataFlags + as nsStringRepr_DataFlags; + pub use self::super::super::super::root::mozilla::detail::StringClassFlags + as nsStringRepr_ClassFlags; #[test] fn bindgen_test_layout_nsStringRepr() { assert_eq!(::std::mem::size_of::() , 16usize , @@ -1276,10 +1200,18 @@ pub mod root { nsStringRepr ) , "::" , stringify ! ( mLength ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsStringRepr ) ) . mFlags as - * const _ as usize } , 12usize , concat ! ( + & ( * ( 0 as * const nsStringRepr ) ) . mDataFlags + as * const _ as usize } , 12usize , concat ! ( "Alignment of field: " , stringify ! ( - nsStringRepr ) , "::" , stringify ! ( mFlags ) )); + nsStringRepr ) , "::" , stringify ! ( mDataFlags ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const nsStringRepr ) ) . + mClassFlags as * const _ as usize } , 14usize , + concat ! ( + "Alignment of field: " , stringify ! ( + nsStringRepr ) , "::" , stringify ! ( mClassFlags + ) )); } impl Clone for nsStringRepr { fn clone(&self) -> Self { *self } @@ -1289,7 +1221,8 @@ pub mod root { pub struct nsCStringRepr { pub mData: *mut root::mozilla::detail::nsCStringRepr_char_type, pub mLength: root::mozilla::detail::nsCStringRepr_size_type, - pub mFlags: u32, + pub mDataFlags: root::mozilla::detail::nsCStringRepr_DataFlags, + pub mClassFlags: root::mozilla::detail::nsCStringRepr_ClassFlags, } pub type nsCStringRepr_fallible_t = root::mozilla::fallible_t; pub type nsCStringRepr_char_type = ::std::os::raw::c_char; @@ -1313,42 +1246,10 @@ pub mod root { *const root::mozilla::detail::nsCStringRepr_char_type; pub type nsCStringRepr_index_type = u32; pub type nsCStringRepr_size_type = u32; - pub const nsCStringRepr_F_NONE: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_NONE; - pub const nsCStringRepr_F_TERMINATED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_TERMINATED; - pub const nsCStringRepr_F_VOIDED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_VOIDED; - pub const nsCStringRepr_F_SHARED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_SHARED; - pub const nsCStringRepr_F_OWNED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_OWNED; - pub const nsCStringRepr_F_FIXED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_FIXED; - pub const nsCStringRepr_F_LITERAL: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_LITERAL; - pub const nsCStringRepr_F_CLASS_FIXED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_CLASS_FIXED; - #[repr(u32)] - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum nsCStringRepr__bindgen_ty_1 { - F_NONE = 0, - F_TERMINATED = 1, - F_VOIDED = 2, - F_SHARED = 4, - F_OWNED = 8, - F_FIXED = 16, - F_LITERAL = 32, - F_CLASS_FIXED = 65536, - } + pub use self::super::super::super::root::mozilla::detail::StringDataFlags + as nsCStringRepr_DataFlags; + pub use self::super::super::super::root::mozilla::detail::StringClassFlags + as nsCStringRepr_ClassFlags; #[test] fn bindgen_test_layout_nsCStringRepr() { assert_eq!(::std::mem::size_of::() , 16usize , @@ -1370,11 +1271,19 @@ pub mod root { nsCStringRepr ) , "::" , stringify ! ( mLength ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsCStringRepr ) ) . mFlags as - * const _ as usize } , 12usize , concat ! ( + & ( * ( 0 as * const nsCStringRepr ) ) . + mDataFlags as * const _ as usize } , 12usize , + concat ! ( "Alignment of field: " , stringify ! ( - nsCStringRepr ) , "::" , stringify ! ( mFlags ) - )); + nsCStringRepr ) , "::" , stringify ! ( mDataFlags + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const nsCStringRepr ) ) . + mClassFlags as * const _ as usize } , 14usize , + concat ! ( + "Alignment of field: " , stringify ! ( + nsCStringRepr ) , "::" , stringify ! ( mClassFlags + ) )); } impl Clone for nsCStringRepr { fn clone(&self) -> Self { *self } @@ -1384,6 +1293,19 @@ pub mod root { pub struct AllocPolicyBasedFreePolicy { pub _address: u8, } + #[repr(u16)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum StringDataFlags { + TERMINATED = 1, + VOIDED = 2, + SHARED = 4, + OWNED = 8, + FIXED = 16, + LITERAL = 32, + } + #[repr(u16)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum StringClassFlags { FIXED = 1, } /** * LinkedList supports refcounted elements using this adapter class. Clients * using LinkedList> will get a data structure that holds a strong @@ -1452,7 +1374,7 @@ pub mod root { #[repr(C)] #[derive(Debug)] pub struct MutexImpl { - pub platformData_: [*mut ::std::os::raw::c_void; 8usize], + pub platformData_: [*mut ::std::os::raw::c_void; 5usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -1461,7 +1383,7 @@ pub mod root { } #[test] fn bindgen_test_layout_MutexImpl() { - assert_eq!(::std::mem::size_of::() , 64usize , + assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( "Size of: " , stringify ! ( MutexImpl ) )); assert_eq! (::std::mem::align_of::() , 8usize , @@ -2385,7 +2307,7 @@ pub mod root { } } #[repr(C)] - #[derive(Debug, Copy)] + #[derive(Debug)] pub struct ThreadSafeAutoRefCnt { pub mValue: u64, } @@ -2406,9 +2328,6 @@ pub mod root { ThreadSafeAutoRefCnt ) , "::" , stringify ! ( mValue ) )); } - impl Clone for ThreadSafeAutoRefCnt { - fn clone(&self) -> Self { *self } - } #[repr(C)] #[derive(Debug)] pub struct OwningNonNull { @@ -3627,7 +3546,8 @@ pub mod root { pub struct FakeString { pub mData: *mut root::mozilla::detail::nsStringRepr_char_type, pub mLength: root::mozilla::detail::nsStringRepr_size_type, - pub mFlags: u32, + pub mDataFlags: root::mozilla::detail::nsStringRepr_DataFlags, + pub mClassFlags: root::mozilla::detail::nsStringRepr_ClassFlags, pub mInlineStorage: [root::mozilla::detail::nsStringRepr_char_type; 64usize], } #[repr(C)] @@ -3669,11 +3589,19 @@ pub mod root { FakeString ) , "::" , stringify ! ( mLength ) )); assert_eq! (unsafe { - & ( * ( 0 as * const FakeString ) ) . mFlags - as * const _ as usize } , 12usize , concat ! ( + & ( * ( 0 as * const FakeString ) ) . + mDataFlags as * const _ as usize } , 12usize , + concat ! ( "Alignment of field: " , stringify ! ( - FakeString ) , "::" , stringify ! ( mFlags ) - )); + FakeString ) , "::" , stringify ! ( mDataFlags + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const FakeString ) ) . + mClassFlags as * const _ as usize } , 14usize + , concat ! ( + "Alignment of field: " , stringify ! ( + FakeString ) , "::" , stringify ! ( + mClassFlags ) )); assert_eq! (unsafe { & ( * ( 0 as * const FakeString ) ) . mInlineStorage as * const _ as usize } , @@ -9009,7 +8937,7 @@ pub mod root { } #[test] fn bindgen_test_layout_OffTheBooksMutex() { - assert_eq!(::std::mem::size_of::() , 96usize , + assert_eq!(::std::mem::size_of::() , 72usize , concat ! ( "Size of: " , stringify ! ( OffTheBooksMutex ) )); assert_eq! (::std::mem::align_of::() , 8usize , @@ -9017,7 +8945,7 @@ pub mod root { "Alignment of " , stringify ! ( OffTheBooksMutex ) )); assert_eq! (unsafe { & ( * ( 0 as * const OffTheBooksMutex ) ) . - mOwningThread as * const _ as usize } , 88usize , + mOwningThread as * const _ as usize } , 64usize , concat ! ( "Alignment of field: " , stringify ! ( OffTheBooksMutex ) , "::" , stringify ! ( @@ -9035,7 +8963,7 @@ pub mod root { } #[test] fn bindgen_test_layout_Mutex() { - assert_eq!(::std::mem::size_of::() , 96usize , concat ! ( + assert_eq!(::std::mem::size_of::() , 72usize , concat ! ( "Size of: " , stringify ! ( Mutex ) )); assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( "Alignment of " , stringify ! ( Mutex ) )); @@ -11769,194 +11697,196 @@ pub mod root { pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell>, } } - pub type va_list = root::__builtin_va_list; - pub type fpos_t = root::__darwin_off_t; #[repr(C)] #[derive(Debug, Copy)] - pub struct __sbuf { - pub _base: *mut ::std::os::raw::c_uchar, - pub _size: ::std::os::raw::c_int, + pub struct _IO_FILE { + pub _flags: ::std::os::raw::c_int, + pub _IO_read_ptr: *mut ::std::os::raw::c_char, + pub _IO_read_end: *mut ::std::os::raw::c_char, + pub _IO_read_base: *mut ::std::os::raw::c_char, + pub _IO_write_base: *mut ::std::os::raw::c_char, + pub _IO_write_ptr: *mut ::std::os::raw::c_char, + pub _IO_write_end: *mut ::std::os::raw::c_char, + pub _IO_buf_base: *mut ::std::os::raw::c_char, + pub _IO_buf_end: *mut ::std::os::raw::c_char, + pub _IO_save_base: *mut ::std::os::raw::c_char, + pub _IO_backup_base: *mut ::std::os::raw::c_char, + pub _IO_save_end: *mut ::std::os::raw::c_char, + pub _markers: *mut root::_IO_marker, + pub _chain: *mut root::_IO_FILE, + pub _fileno: ::std::os::raw::c_int, + pub _flags2: ::std::os::raw::c_int, + pub _old_offset: root::__off_t, + pub _cur_column: ::std::os::raw::c_ushort, + pub _vtable_offset: ::std::os::raw::c_schar, + pub _shortbuf: [::std::os::raw::c_char; 1usize], + pub _lock: *mut root::_IO_lock_t, + pub _offset: root::__off64_t, + pub __pad1: *mut ::std::os::raw::c_void, + pub __pad2: *mut ::std::os::raw::c_void, + pub __pad3: *mut ::std::os::raw::c_void, + pub __pad4: *mut ::std::os::raw::c_void, + pub __pad5: usize, + pub _mode: ::std::os::raw::c_int, + pub _unused2: [::std::os::raw::c_char; 20usize], } #[test] - fn bindgen_test_layout___sbuf() { - assert_eq!(::std::mem::size_of::<__sbuf>() , 16usize , concat ! ( - "Size of: " , stringify ! ( __sbuf ) )); - assert_eq! (::std::mem::align_of::<__sbuf>() , 8usize , concat ! ( - "Alignment of " , stringify ! ( __sbuf ) )); + fn bindgen_test_layout__IO_FILE() { + assert_eq!(::std::mem::size_of::<_IO_FILE>() , 216usize , concat ! ( + "Size of: " , stringify ! ( _IO_FILE ) )); + assert_eq! (::std::mem::align_of::<_IO_FILE>() , 8usize , concat ! ( + "Alignment of " , stringify ! ( _IO_FILE ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sbuf ) ) . _base as * const _ as + & ( * ( 0 as * const _IO_FILE ) ) . _flags as * const _ as usize } , 0usize , concat ! ( - "Alignment of field: " , stringify ! ( __sbuf ) , "::" , - stringify ! ( _base ) )); - assert_eq! (unsafe { - & ( * ( 0 as * const __sbuf ) ) . _size as * const _ as - usize } , 8usize , concat ! ( - "Alignment of field: " , stringify ! ( __sbuf ) , "::" , - stringify ! ( _size ) )); - } - impl Clone for __sbuf { - fn clone(&self) -> Self { *self } - } - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct __sFILEX { - _unused: [u8; 0], - } - #[repr(C)] - #[derive(Debug, Copy)] - pub struct __sFILE { - pub _p: *mut ::std::os::raw::c_uchar, - pub _r: ::std::os::raw::c_int, - pub _w: ::std::os::raw::c_int, - pub _flags: ::std::os::raw::c_short, - pub _file: ::std::os::raw::c_short, - pub _bf: root::__sbuf, - pub _lbfsize: ::std::os::raw::c_int, - pub _cookie: *mut ::std::os::raw::c_void, - pub _close: ::std::option::Option ::std::os::raw::c_int>, - pub _read: ::std::option::Option ::std::os::raw::c_int>, - pub _seek: ::std::option::Option root::fpos_t>, - pub _write: ::std::option::Option ::std::os::raw::c_int>, - pub _ub: root::__sbuf, - pub _extra: *mut root::__sFILEX, - pub _ur: ::std::os::raw::c_int, - pub _ubuf: [::std::os::raw::c_uchar; 3usize], - pub _nbuf: [::std::os::raw::c_uchar; 1usize], - pub _lb: root::__sbuf, - pub _blksize: ::std::os::raw::c_int, - pub _offset: root::fpos_t, - } - #[test] - fn bindgen_test_layout___sFILE() { - assert_eq!(::std::mem::size_of::<__sFILE>() , 152usize , concat ! ( - "Size of: " , stringify ! ( __sFILE ) )); - assert_eq! (::std::mem::align_of::<__sFILE>() , 8usize , concat ! ( - "Alignment of " , stringify ! ( __sFILE ) )); - assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _p as * const _ as - usize } , 0usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _p ) )); - assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _r as * const _ as - usize } , 8usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _r ) )); - assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _w as * const _ as - usize } , 12usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _w ) )); - assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _flags as * const _ as - usize } , 16usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , stringify ! ( _flags ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _file as * const _ as - usize } , 18usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _file ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_read_ptr as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_read_ptr ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _bf as * const _ as - usize } , 24usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _bf ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_read_end as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_read_end ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _lbfsize as * const _ - as usize } , 40usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _lbfsize ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_read_base as * + const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_read_base ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _cookie as * const _ as - usize } , 48usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _cookie ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_write_base as * + const _ as usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_write_base ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _close as * const _ as - usize } , 56usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _close ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_write_ptr as * + const _ as usize } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_write_ptr ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _read as * const _ as - usize } , 64usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _read ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_write_end as * + const _ as usize } , 48usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_write_end ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _seek as * const _ as - usize } , 72usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _seek ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_buf_base as * + const _ as usize } , 56usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_buf_base ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _write as * const _ as - usize } , 80usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _write ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_buf_end as * const + _ as usize } , 64usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_buf_end ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _ub as * const _ as - usize } , 88usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _ub ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _IO_save_base as * + const _ as usize } , 72usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_save_base ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _extra as * const _ as + & ( * ( 0 as * const _IO_FILE ) ) . _IO_backup_base as * + const _ as usize } , 80usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_backup_base ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _IO_save_end as * + const _ as usize } , 88usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _IO_save_end ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _markers as * const _ + as usize } , 96usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _markers ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _chain as * const _ as usize } , 104usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _extra ) )); + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _chain ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _ur as * const _ as - usize } , 112usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _ur ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _fileno as * const _ + as usize } , 112usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _fileno ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _ubuf as * const _ as - usize } , 116usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _ubuf ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _flags2 as * const _ + as usize } , 116usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _flags2 ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _nbuf as * const _ as - usize } , 119usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _nbuf ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _old_offset as * const + _ as usize } , 120usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _old_offset ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _lb as * const _ as - usize } , 120usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _lb ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _cur_column as * const + _ as usize } , 128usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _cur_column ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _blksize as * const _ - as usize } , 136usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , - stringify ! ( _blksize ) )); + & ( * ( 0 as * const _IO_FILE ) ) . _vtable_offset as * + const _ as usize } , 130usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _vtable_offset ) )); assert_eq! (unsafe { - & ( * ( 0 as * const __sFILE ) ) . _offset as * const _ as - usize } , 144usize , concat ! ( - "Alignment of field: " , stringify ! ( __sFILE ) , "::" , + & ( * ( 0 as * const _IO_FILE ) ) . _shortbuf as * const _ + as usize } , 131usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _shortbuf ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _lock as * const _ as + usize } , 136usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _lock ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _offset as * const _ + as usize } , 144usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , stringify ! ( _offset ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . __pad1 as * const _ as + usize } , 152usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( __pad1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . __pad2 as * const _ as + usize } , 160usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( __pad2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . __pad3 as * const _ as + usize } , 168usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( __pad3 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . __pad4 as * const _ as + usize } , 176usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( __pad4 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . __pad5 as * const _ as + usize } , 184usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( __pad5 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _mode as * const _ as + usize } , 192usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _mode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_FILE ) ) . _unused2 as * const _ + as usize } , 196usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" , + stringify ! ( _unused2 ) )); } - impl Clone for __sFILE { + impl Clone for _IO_FILE { fn clone(&self) -> Self { *self } } - pub type FILE = root::__sFILE; + pub type FILE = root::_IO_FILE; + pub type va_list = root::__builtin_va_list; #[repr(C)] #[derive(Debug, Copy)] pub struct InfallibleAllocPolicy { @@ -12513,6 +12443,39 @@ pub mod root { NS_OK_NO_NAME_CLAUSE_HANDLED = 7864354, } pub type nsrefcnt = root::MozRefCountType; + pub type _IO_lock_t = ::std::os::raw::c_void; + #[repr(C)] + #[derive(Debug, Copy)] + pub struct _IO_marker { + pub _next: *mut root::_IO_marker, + pub _sbuf: *mut root::_IO_FILE, + pub _pos: ::std::os::raw::c_int, + } + #[test] + fn bindgen_test_layout__IO_marker() { + assert_eq!(::std::mem::size_of::<_IO_marker>() , 24usize , concat ! ( + "Size of: " , stringify ! ( _IO_marker ) )); + assert_eq! (::std::mem::align_of::<_IO_marker>() , 8usize , concat ! ( + "Alignment of " , stringify ! ( _IO_marker ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_marker ) ) . _next as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_marker ) , "::" + , stringify ! ( _next ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_marker ) ) . _sbuf as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_marker ) , "::" + , stringify ! ( _sbuf ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const _IO_marker ) ) . _pos as * const _ as + usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( _IO_marker ) , "::" + , stringify ! ( _pos ) )); + } + impl Clone for _IO_marker { + fn clone(&self) -> Self { *self } + } #[repr(C)] pub struct nsQueryFrame__bindgen_vtable(::std::os::raw::c_void); #[repr(C)] @@ -18324,14 +18287,14 @@ pub mod root { /** * This structure precedes the string buffers "we" allocate. It may be the * case that nsTAString::mData does not point to one of these special - * buffers. The mFlags member variable distinguishes the buffer type. + * buffers. The mDataFlags member variable distinguishes the buffer type. * * When this header is in use, it enables reference counting, and capacity * tracking. NOTE: A string buffer can be modified only if its reference * count is 1. */ #[repr(C)] - #[derive(Debug, Copy)] + #[derive(Debug)] pub struct nsStringBuffer { pub mRefCount: u32, pub mStorageSize: u32, @@ -18353,9 +18316,6 @@ pub mod root { "Alignment of field: " , stringify ! ( nsStringBuffer ) , "::" , stringify ! ( mStorageSize ) )); } - impl Clone for nsStringBuffer { - fn clone(&self) -> Self { *self } - } #[repr(C)] #[derive(Debug, Copy)] pub struct nsIAtom { @@ -26908,57 +26868,57 @@ pub mod root { pub struct nsDOMMutationObserver { _unused: [u8; 0], } - pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_LISTENERMANAGER; - pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_PROPERTIES; - pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_ANONYMOUS_ROOT; - pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE; - pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_NATIVE_ANONYMOUS_ROOT; - pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_FORCE_XBL_BINDINGS; - pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_MAY_BE_IN_BINDING_MNGR; - pub const NODE_IS_EDITABLE: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_EDITABLE; - pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_NATIVE_ANONYMOUS; - pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_IN_SHADOW_TREE; - pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_EMPTY_SELECTOR; - pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_SLOW_SELECTOR; - pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_EDGE_CHILD_SELECTOR; - pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS; - pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_ALL_SELECTOR_FLAGS; - pub const NODE_NEEDS_FRAME: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_NEEDS_FRAME; - pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_DESCENDANTS_NEED_FRAMES; - pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_ACCESSKEY; - pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_DIRECTION_RTL; - pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_DIRECTION_LTR; - pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_ALL_DIRECTION_FLAGS; - pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_CHROME_ONLY_ACCESS; - pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS; - pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_TYPE_SPECIFIC_BITS_OFFSET; + pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_LISTENERMANAGER; + pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_PROPERTIES; + pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_ANONYMOUS_ROOT; + pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE; + pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_NATIVE_ANONYMOUS_ROOT; + pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_FORCE_XBL_BINDINGS; + pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_MAY_BE_IN_BINDING_MNGR; + pub const NODE_IS_EDITABLE: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_EDITABLE; + pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_NATIVE_ANONYMOUS; + pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_IN_SHADOW_TREE; + pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_EMPTY_SELECTOR; + pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_SLOW_SELECTOR; + pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_EDGE_CHILD_SELECTOR; + pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS; + pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_ALL_SELECTOR_FLAGS; + pub const NODE_NEEDS_FRAME: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_NEEDS_FRAME; + pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_DESCENDANTS_NEED_FRAMES; + pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_ACCESSKEY; + pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_DIRECTION_RTL; + pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_HAS_DIRECTION_LTR; + pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_ALL_DIRECTION_FLAGS; + pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_CHROME_ONLY_ACCESS; + pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS; + pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_83 = + _bindgen_ty_83::NODE_TYPE_SPECIFIC_BITS_OFFSET; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum _bindgen_ty_18 { + pub enum _bindgen_ty_83 { NODE_HAS_LISTENERMANAGER = 4, NODE_HAS_PROPERTIES = 8, NODE_IS_ANONYMOUS_ROOT = 16, @@ -33518,7 +33478,7 @@ pub mod root { pub type imgRequest_HasThreadSafeRefCnt = root::mozilla::TrueType; #[test] fn bindgen_test_layout_imgRequest() { - assert_eq!(::std::mem::size_of::() , 448usize , concat ! ( + assert_eq!(::std::mem::size_of::() , 424usize , concat ! ( "Size of: " , stringify ! ( imgRequest ) )); assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( "Alignment of " , stringify ! ( imgRequest ) )); @@ -35091,7 +35051,7 @@ pub mod root { ) , "::" , stringify ! ( mQuotePairs ) )); } #[test] - fn __bindgen_test_layout_StaticRefPtr_instantiation_21() { + fn __bindgen_test_layout_StaticRefPtr_instantiation_86() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -35102,7 +35062,7 @@ pub mod root { root::mozilla::StaticRefPtr ) )); } #[test] - fn __bindgen_test_layout_StaticRefPtr_instantiation_22() { + fn __bindgen_test_layout_StaticRefPtr_instantiation_87() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38251,48 +38211,48 @@ pub mod root { pub struct nsAttrValueOrString { _unused: [u8; 0], } - pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_1; - pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_2; - pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_3; - pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_4; - pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_1; + pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_1; + pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_2; + pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_3; + pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_4; + pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_1; pub const ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO: - root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_2; - pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_3; - pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_4; - pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_1; - pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_2; - pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_20 + root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_2; + pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_3; + pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_4; + pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_1; + pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_2; + pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_85 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_3; + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_3; pub const ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT: - root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_4; - pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR; - pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_PENDING_RESTYLE_FLAGS; - pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS; - pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_ALL_RESTYLE_FLAGS; - pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_HAS_SCROLLGRAB; - pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET; + root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_SHARED_RESTYLE_BIT_4; + pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR; + pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_PENDING_RESTYLE_FLAGS; + pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS; + pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_ALL_RESTYLE_FLAGS; + pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_HAS_SCROLLGRAB; + pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_85 = + _bindgen_ty_85::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum _bindgen_ty_20 { + pub enum _bindgen_ty_85 { ELEMENT_SHARED_RESTYLE_BIT_1 = 8388608, ELEMENT_SHARED_RESTYLE_BIT_2 = 16777216, ELEMENT_SHARED_RESTYLE_BIT_3 = 33554432, @@ -38614,8 +38574,8 @@ pub mod root { impl Clone for GeckoFontMetrics { fn clone(&self) -> Self { *self } } - pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after: u32 = 1; - pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before: u32 = 1; + pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after: u32 = 65; + pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before: u32 = 65; pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_backdrop: u32 = 0; pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_cue: u32 = 36; pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLetter: u32 = 3; @@ -38843,6 +38803,22 @@ pub mod root { } #[repr(C)] #[derive(Debug, Copy)] + pub struct _bindgen_ty_29 { + pub _address: u8, + } + impl Clone for _bindgen_ty_29 { + fn clone(&self) -> Self { *self } + } + #[repr(C)] + #[derive(Debug, Copy)] + pub struct _bindgen_ty_30 { + pub _address: u8, + } + impl Clone for _bindgen_ty_30 { + fn clone(&self) -> Self { *self } + } + #[repr(C)] + #[derive(Debug, Copy)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, @@ -38881,7 +38857,7 @@ pub mod root { } pub type __builtin_va_list = [root::__va_list_tag; 1usize]; #[test] - fn __bindgen_test_layout_IntegralConstant_instantiation_23() { + fn __bindgen_test_layout_IntegralConstant_instantiation_88() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -38890,7 +38866,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_IntegralConstant_instantiation_24() { + fn __bindgen_test_layout_IntegralConstant_instantiation_89() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -38899,7 +38875,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_25() { + fn __bindgen_test_layout_nsCharTraits_instantiation_90() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38910,7 +38886,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout_nsReadingIterator_instantiation_26() { + fn __bindgen_test_layout_nsReadingIterator_instantiation_91() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38923,7 +38899,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsWritingIterator_instantiation_27() { + fn __bindgen_test_layout_nsWritingIterator_instantiation_92() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38936,7 +38912,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_28() { + fn __bindgen_test_layout_nsCharTraits_instantiation_93() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38947,7 +38923,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout_nsReadingIterator_instantiation_29() { + fn __bindgen_test_layout_nsReadingIterator_instantiation_94() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38960,7 +38936,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsWritingIterator_instantiation_30() { + fn __bindgen_test_layout_nsWritingIterator_instantiation_95() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38973,7 +38949,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_31() { + fn __bindgen_test_layout_nsCharTraits_instantiation_96() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38984,7 +38960,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_32() { + fn __bindgen_test_layout_nsCharTraits_instantiation_97() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38995,7 +38971,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout__bindgen_ty_id_190112_instantiation_33() { + fn __bindgen_test_layout__bindgen_ty_id_191545_instantiation_98() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -39004,7 +38980,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout__bindgen_ty_id_190148_instantiation_34() { + fn __bindgen_test_layout__bindgen_ty_id_191581_instantiation_99() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -39013,7 +38989,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_35() { + fn __bindgen_test_layout_nsTArray_instantiation_100() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39024,7 +39000,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_36() { + fn __bindgen_test_layout_Handle_instantiation_101() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39035,7 +39011,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_37() { + fn __bindgen_test_layout_Handle_instantiation_102() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39046,7 +39022,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_38() { + fn __bindgen_test_layout_Handle_instantiation_103() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39057,7 +39033,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_39() { + fn __bindgen_test_layout_MutableHandle_instantiation_104() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39068,7 +39044,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Rooted_instantiation_40() { + fn __bindgen_test_layout_Rooted_instantiation_105() { assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39079,7 +39055,7 @@ pub mod root { [u64; 3usize] ) )); } #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_41() { + fn __bindgen_test_layout_DeletePolicy_instantiation_106() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39090,7 +39066,7 @@ pub mod root { root::JS::DeletePolicy ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_42() { + fn __bindgen_test_layout_nsTArray_instantiation_107() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39101,7 +39077,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_43() { + fn __bindgen_test_layout_nsTArray_instantiation_108() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39112,7 +39088,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_44() { + fn __bindgen_test_layout_nsTArray_instantiation_109() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39123,7 +39099,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_45() { + fn __bindgen_test_layout_nsTArray_instantiation_110() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39134,7 +39110,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_PointTyped_instantiation_46() { + fn __bindgen_test_layout_PointTyped_instantiation_111() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39145,7 +39121,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_IntPointTyped_instantiation_47() { + fn __bindgen_test_layout_IntPointTyped_instantiation_112() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39156,7 +39132,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_SizeTyped_instantiation_48() { + fn __bindgen_test_layout_SizeTyped_instantiation_113() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39167,7 +39143,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_RectTyped_instantiation_49() { + fn __bindgen_test_layout_RectTyped_instantiation_114() { assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39178,7 +39154,7 @@ pub mod root { [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_IntPointTyped_instantiation_50() { + fn __bindgen_test_layout_IntPointTyped_instantiation_115() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39189,7 +39165,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_IntSizeTyped_instantiation_51() { + fn __bindgen_test_layout_IntSizeTyped_instantiation_116() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39200,7 +39176,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_IntRectTyped_instantiation_52() { + fn __bindgen_test_layout_IntRectTyped_instantiation_117() { assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39211,7 +39187,7 @@ pub mod root { [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_MarginTyped_instantiation_53() { + fn __bindgen_test_layout_MarginTyped_instantiation_118() { assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39222,7 +39198,7 @@ pub mod root { [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_RectTyped_instantiation_54() { + fn __bindgen_test_layout_RectTyped_instantiation_119() { assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39233,7 +39209,7 @@ pub mod root { [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_IntRectTyped_instantiation_55() { + fn __bindgen_test_layout_IntRectTyped_instantiation_120() { assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39244,7 +39220,7 @@ pub mod root { [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_ScaleFactor_instantiation_56() { + fn __bindgen_test_layout_ScaleFactor_instantiation_121() { assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( "Size of template specialization: " , stringify ! ( u32 ) )); @@ -39253,7 +39229,7 @@ pub mod root { u32 ) )); } #[test] - fn __bindgen_test_layout_ScaleFactors2D_instantiation_57() { + fn __bindgen_test_layout_ScaleFactors2D_instantiation_122() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39264,7 +39240,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_ScaleFactors2D_instantiation_58() { + fn __bindgen_test_layout_ScaleFactors2D_instantiation_123() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39275,7 +39251,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_ScaleFactors2D_instantiation_59() { + fn __bindgen_test_layout_ScaleFactors2D_instantiation_124() { assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39286,7 +39262,7 @@ pub mod root { [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_BaseTimeDuration_instantiation_60() { + fn __bindgen_test_layout_BaseTimeDuration_instantiation_125() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39297,7 +39273,7 @@ pub mod root { root::mozilla::BaseTimeDuration ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_61() { + fn __bindgen_test_layout_already_AddRefed_instantiation_126() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39308,7 +39284,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_62() { + fn __bindgen_test_layout_already_AddRefed_instantiation_127() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39319,7 +39295,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_63() { + fn __bindgen_test_layout_RefPtr_instantiation_128() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39330,7 +39306,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_64() { + fn __bindgen_test_layout_nsTArray_instantiation_129() { assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39343,7 +39319,7 @@ pub mod root { )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_65() { + fn __bindgen_test_layout_RefPtr_instantiation_130() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39354,7 +39330,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_66() { + fn __bindgen_test_layout_nsTArray_instantiation_131() { assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39367,7 +39343,7 @@ pub mod root { )); } #[test] - fn __bindgen_test_layout_WeakPtr_instantiation_67() { + fn __bindgen_test_layout_WeakPtr_instantiation_132() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -39376,7 +39352,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_68() { + fn __bindgen_test_layout_nsPtrHashKey_instantiation_133() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39387,7 +39363,7 @@ pub mod root { root::nsPtrHashKey<::std::os::raw::c_void> ) )); } #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_69() { + fn __bindgen_test_layout_nsPtrHashKey_instantiation_134() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39398,7 +39374,7 @@ pub mod root { root::nsPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_70() { + fn __bindgen_test_layout_nsTArray_instantiation_135() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39409,7 +39385,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_TErrorResult_instantiation_71() { + fn __bindgen_test_layout_TErrorResult_instantiation_136() { assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39420,7 +39396,7 @@ pub mod root { root::mozilla::binding_danger::TErrorResult ) )); } #[test] - fn __bindgen_test_layout_TErrorResult_instantiation_72() { + fn __bindgen_test_layout_TErrorResult_instantiation_137() { assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39431,7 +39407,7 @@ pub mod root { root::mozilla::binding_danger::TErrorResult ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_73() { + fn __bindgen_test_layout_already_AddRefed_instantiation_138() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39442,7 +39418,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_74() { + fn __bindgen_test_layout_Handle_instantiation_139() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39453,7 +39429,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_75() { + fn __bindgen_test_layout_MutableHandle_instantiation_140() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39464,7 +39440,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_76() { + fn __bindgen_test_layout_Handle_instantiation_141() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39475,7 +39451,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_77() { + fn __bindgen_test_layout_nsTArray_instantiation_142() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39486,7 +39462,7 @@ pub mod root { root::nsTArray<*mut root::mozilla::StyleSheet> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_78() { + fn __bindgen_test_layout_Handle_instantiation_143() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39497,7 +39473,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_79() { + fn __bindgen_test_layout_RefPtr_instantiation_144() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39508,731 +39484,6 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_80() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_81() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_82() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_83() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_84() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_85() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_86() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_87() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_88() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_89() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_90() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_91() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_92() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_93() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_94() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_95() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_96() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_97() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_iterator_instantiation_98() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::std::iterator ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::std::iterator ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_99() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_100() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_101() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_102() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_103() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_104() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_105() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_106() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_107() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_Heap_instantiation_108() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Heap ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Heap ) )); - } - #[test] - fn __bindgen_test_layout_Heap_instantiation_109() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Heap<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Heap<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_TenuredHeap_instantiation_110() { - assert_eq!(::std::mem::size_of::() , 8usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::TenuredHeap ) )); - assert_eq!(::std::mem::align_of::() , 8usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::TenuredHeap ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_111() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_112() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) - )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_113() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_114() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_115() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_116() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_117() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_118() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_119() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_120() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_121() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_122() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_123() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_124() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_125() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_126() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_127() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_128() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_129() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_130() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_131() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_132() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_133() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_134() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_135() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_136() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_137() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_138() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_139() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::mozilla::StyleSheet> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::mozilla::StyleSheet> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_140() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_141() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_142() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_143() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_144() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] fn __bindgen_test_layout_Handle_instantiation_145() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( @@ -40255,396 +39506,40 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_147() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_147() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_148() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( + fn __bindgen_test_layout_already_AddRefed_instantiation_148() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey - ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey - ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsDataHashtable_instantiation_149() { - assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! - ( + fn __bindgen_test_layout_already_AddRefed_instantiation_149() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! - ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - [u64; 6usize] ) )); + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_Handle_instantiation_150() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_151() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_152() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_153() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_154() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_SupportsWeakPtr_instantiation_155() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( u64 ) - )); - assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - u64 ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_156() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_157() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_158() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_159() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_160() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_161() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_162() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_163() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_164() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_165() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_166() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_167() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_168() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_169() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_170() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_171() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_172() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsPIDOMWindow_instantiation_173() { - assert_eq!(::std::mem::size_of::<[u64; 31usize]>() , 248usize , concat - ! ( - "Size of template specialization: " , stringify ! ( - [u64; 31usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 31usize]>() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - [u64; 31usize] ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_174() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_175() { - assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_176() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_177() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_178() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_179() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_180() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_181() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_182() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40655,29 +39550,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_183() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_184() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_185() { + fn __bindgen_test_layout_MutableHandle_instantiation_151() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40688,81 +39561,463 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_186() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_MutableHandle_instantiation_152() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_153() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_154() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_155() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_156() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_157() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_158() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_159() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_160() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_161() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_162() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_iterator_instantiation_163() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::std::iterator ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::std::iterator ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_164() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_165() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_166() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_167() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_168() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_169() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_170() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_171() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() , + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); + root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_187() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_188() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_nsTArray_instantiation_172() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() , + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); + root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_189() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_Heap_instantiation_173() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + root::JS::Heap ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); + root::JS::Heap ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_190() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_Heap_instantiation_174() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::JS::Heap<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); + root::JS::Heap<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_191() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_TenuredHeap_instantiation_175() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + root::JS::TenuredHeap ) )); + assert_eq!(::std::mem::align_of::() , 8usize , + concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); + root::JS::TenuredHeap ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_192() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_176() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_177() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) + )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_178() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_179() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_180() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_181() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_182() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_183() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_184() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_185() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_186() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_187() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_188() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_189() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_190() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_191() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_192() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_MutableHandle_instantiation_193() { @@ -40776,7 +40031,728 @@ pub mod root { root::JS::MutableHandle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_194() { + fn __bindgen_test_layout_already_AddRefed_instantiation_194() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_195() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_196() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_197() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_198() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_199() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_200() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_201() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_202() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_203() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_204() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::mozilla::StyleSheet> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::mozilla::StyleSheet> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_205() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_206() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_207() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_208() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_209() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_210() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_211() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_212() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_213() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsRefPtrHashKey + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsRefPtrHashKey + ) )); + } + #[test] + fn __bindgen_test_layout_nsDataHashtable_instantiation_214() { + assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 6usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 6usize] ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_215() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_216() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIContent> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIContent> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_217() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIContent> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIContent> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_218() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_219() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_SupportsWeakPtr_instantiation_220() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( u64 ) + )); + assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + u64 ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_221() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_222() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_223() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsPresContext_Encoding> + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsPresContext_Encoding> + ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_224() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsPresContext_Encoding> + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsPresContext_Encoding> + ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_225() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_226() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_227() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_228() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_229() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_230() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_231() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_232() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_233() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_234() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_235() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_236() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_237() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsPIDOMWindow_instantiation_238() { + assert_eq!(::std::mem::size_of::<[u64; 31usize]>() , 248usize , concat + ! ( + "Size of template specialization: " , stringify ! ( + [u64; 31usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 31usize]>() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + [u64; 31usize] ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_239() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_240() { + assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 6usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 6usize] ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_241() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_242() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_243() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_244() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_245() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_246() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_247() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_248() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_249() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_250() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_251() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_252() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_253() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_254() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_255() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_256() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_257() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_258() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_259() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40787,7 +40763,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_195() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_260() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40798,7 +40774,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_196() { + fn __bindgen_test_layout_nsPtrHashKey_instantiation_261() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40809,7 +40785,7 @@ pub mod root { root::nsPtrHashKey<::std::os::raw::c_void> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_197() { + fn __bindgen_test_layout_already_AddRefed_instantiation_262() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40820,7 +40796,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_198() { + fn __bindgen_test_layout_already_AddRefed_instantiation_263() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40831,7 +40807,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_NotNull_instantiation_199() { + fn __bindgen_test_layout_NotNull_instantiation_264() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40844,7 +40820,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_200() { + fn __bindgen_test_layout_already_AddRefed_instantiation_265() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40855,7 +40831,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_201() { + fn __bindgen_test_layout_already_AddRefed_instantiation_266() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40866,7 +40842,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_202() { + fn __bindgen_test_layout_already_AddRefed_instantiation_267() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40877,7 +40853,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsPIDOMWindow_instantiation_203() { + fn __bindgen_test_layout_nsPIDOMWindow_instantiation_268() { assert_eq!(::std::mem::size_of::<[u64; 31usize]>() , 248usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40888,7 +40864,7 @@ pub mod root { [u64; 31usize] ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_204() { + fn __bindgen_test_layout_MutableHandle_instantiation_269() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40899,7 +40875,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_205() { + fn __bindgen_test_layout_MutableHandle_instantiation_270() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40910,7 +40886,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_206() { + fn __bindgen_test_layout_already_AddRefed_instantiation_271() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40921,731 +40897,6 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_207() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_208() { - assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - } - #[test] - fn __bindgen_test_layout_Rooted_instantiation_209() { - assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - } - #[test] - fn __bindgen_test_layout_Rooted_instantiation_210() { - assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_211() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_212() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_213() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_214() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIParser_Encoding> ) - )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIParser_Encoding> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_215() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_216() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_217() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_218() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_219() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_220() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_221() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_222() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_223() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_224() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_225() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_226() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_227() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_228() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_229() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_230() { - assert_eq!(::std::mem::size_of::>() , 8usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , 8usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_231() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr - ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_232() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_233() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr - ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_234() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_235() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_236() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_237() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_238() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_239() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_240() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsDataHashtable_instantiation_241() { - assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 6usize] ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_242() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull - ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_243() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_244() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_245() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_246() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_247() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_248() { - assert_eq!(::std::mem::size_of::>() - , 40usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsMainThreadPtrHolder ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsMainThreadPtrHolder ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_249() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_250() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_251() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_252() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_253() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_254() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsPtrHashKey ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_255() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_256() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_257() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_258() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_259() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_260() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_SupportsWeakPtr_instantiation_261() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( u64 ) - )); - assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - u64 ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_262() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_263() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_264() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_265() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Maybe_instantiation_266() { - assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 3usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 3usize] ) )); - } - #[test] - fn __bindgen_test_layout_Maybe_instantiation_267() { - assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 3usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 3usize] ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_268() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_269() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_270() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_271() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] fn __bindgen_test_layout_DefaultDelete_instantiation_272() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( @@ -41657,18 +40908,231 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_273() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_273() { + assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + [u64; 6usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); + [u64; 6usize] ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_274() { + fn __bindgen_test_layout_Rooted_instantiation_274() { + assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + } + #[test] + fn __bindgen_test_layout_Rooted_instantiation_275() { + assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_276() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_277() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_278() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_279() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIParser_Encoding> ) + )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIParser_Encoding> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_280() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_281() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_282() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_283() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_284() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_285() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_286() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_287() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_288() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_289() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_290() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_291() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_292() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_293() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41679,7 +41143,420 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_275() { + fn __bindgen_test_layout_Handle_instantiation_294() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_295() { + assert_eq!(::std::mem::size_of::>() , 8usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_296() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr + ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_297() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_298() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr + ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_299() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_300() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_301() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_302() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_303() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_304() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_305() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsDataHashtable_instantiation_306() { + assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 6usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 6usize] ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_307() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull + ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_308() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_309() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_310() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_311() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_312() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_313() { + assert_eq!(::std::mem::size_of::>() + , 40usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsMainThreadPtrHolder ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsMainThreadPtrHolder ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_314() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_315() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_316() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_317() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_318() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsPtrHashKey_instantiation_319() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsPtrHashKey ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_320() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_321() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_322() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_323() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_324() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_325() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_SupportsWeakPtr_instantiation_326() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( u64 ) + )); + assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + u64 ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_327() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_328() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_329() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_330() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_Maybe_instantiation_331() { assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41690,7 +41567,40 @@ pub mod root { [u32; 3usize] ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_276() { + fn __bindgen_test_layout_Maybe_instantiation_332() { + assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u32; 3usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u32; 3usize] ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_333() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_334() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_335() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41701,7 +41611,18 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_277() { + fn __bindgen_test_layout_UniquePtr_instantiation_336() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_337() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41712,7 +41633,62 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_pair_instantiation_278() { + fn __bindgen_test_layout_UniquePtr_instantiation_338() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_339() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_Maybe_instantiation_340() { + assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u32; 3usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u32; 3usize] ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_341() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_342() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_pair_instantiation_343() { assert_eq!(::std::mem::size_of::>() , 32usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41723,7 +41699,7 @@ pub mod root { root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_279() { + fn __bindgen_test_layout_nsTArray_instantiation_344() { assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( @@ -41738,7 +41714,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_280() { + fn __bindgen_test_layout_already_AddRefed_instantiation_345() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41749,7 +41725,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_281() { + fn __bindgen_test_layout_nsTArray_instantiation_346() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41760,7 +41736,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_282() { + fn __bindgen_test_layout_nsTArray_instantiation_347() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41771,7 +41747,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_283() { + fn __bindgen_test_layout_nsTArray_instantiation_348() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41782,7 +41758,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_284() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_349() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41793,7 +41769,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_285() { + fn __bindgen_test_layout_RefPtr_instantiation_350() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41804,7 +41780,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsStyleAutoArray_instantiation_286() { + fn __bindgen_test_layout_nsStyleAutoArray_instantiation_351() { assert_eq!(::std::mem::size_of::>() , 64usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41815,7 +41791,7 @@ pub mod root { root::nsStyleAutoArray ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_287() { + fn __bindgen_test_layout_DefaultDelete_instantiation_352() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41826,7 +41802,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_288() { + fn __bindgen_test_layout_UniquePtr_instantiation_353() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41837,7 +41813,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_289() { + fn __bindgen_test_layout_DefaultDelete_instantiation_354() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41848,7 +41824,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_290() { + fn __bindgen_test_layout_UniquePtr_instantiation_355() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41859,7 +41835,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_291() { + fn __bindgen_test_layout_RefPtr_instantiation_356() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41870,7 +41846,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_292() { + fn __bindgen_test_layout_RefPtr_instantiation_357() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41881,7 +41857,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_NonNull_instantiation_293() { + fn __bindgen_test_layout_NonNull_instantiation_358() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41894,7 +41870,7 @@ pub mod root { )); } #[test] - fn __bindgen_test_layout_NonNull_instantiation_294() { + fn __bindgen_test_layout_NonNull_instantiation_359() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41907,7 +41883,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_295() { + fn __bindgen_test_layout_Handle_instantiation_360() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41918,7 +41894,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_296() { + fn __bindgen_test_layout_MutableHandle_instantiation_361() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41929,7 +41905,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_297() { + fn __bindgen_test_layout_Maybe_instantiation_362() { assert_eq!(::std::mem::size_of::<[u64; 18usize]>() , 144usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41940,7 +41916,7 @@ pub mod root { [u64; 18usize] ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_298() { + fn __bindgen_test_layout_Maybe_instantiation_363() { assert_eq!(::std::mem::size_of::<[u64; 18usize]>() , 144usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41951,7 +41927,7 @@ pub mod root { [u64; 18usize] ) )); } #[test] - fn __bindgen_test_layout_BaseTimeDuration_instantiation_299() { + fn __bindgen_test_layout_BaseTimeDuration_instantiation_364() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41962,7 +41938,7 @@ pub mod root { root::mozilla::BaseTimeDuration ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_300() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_365() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41973,7 +41949,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_301() { + fn __bindgen_test_layout_already_AddRefed_instantiation_366() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41984,7 +41960,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_302() { + fn __bindgen_test_layout_already_AddRefed_instantiation_367() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41995,7 +41971,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_303() { + fn __bindgen_test_layout_nsTArray_instantiation_368() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42006,7 +41982,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_304() { + fn __bindgen_test_layout_nsTArray_instantiation_369() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42017,7 +41993,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_305() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_370() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42028,7 +42004,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_306() { + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_371() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42041,7 +42017,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_307() { + fn __bindgen_test_layout_already_AddRefed_instantiation_372() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42052,7 +42028,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_308() { + fn __bindgen_test_layout_nsTArray_instantiation_373() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42065,7 +42041,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_309() { + fn __bindgen_test_layout_Handle_instantiation_374() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42076,7 +42052,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_310() { + fn __bindgen_test_layout_Handle_instantiation_375() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42087,7 +42063,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_311() { + fn __bindgen_test_layout_RefPtr_instantiation_376() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42098,7 +42074,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_312() { + fn __bindgen_test_layout_Handle_instantiation_377() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42109,7 +42085,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_313() { + fn __bindgen_test_layout_MutableHandle_instantiation_378() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42120,7 +42096,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Sequence_instantiation_314() { + fn __bindgen_test_layout_Sequence_instantiation_379() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -42129,7 +42105,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_315() { + fn __bindgen_test_layout_Handle_instantiation_380() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42140,7 +42116,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Sequence_instantiation_316() { + fn __bindgen_test_layout_Sequence_instantiation_381() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -42149,7 +42125,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_Sequence_instantiation_317() { + fn __bindgen_test_layout_Sequence_instantiation_382() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -42158,7 +42134,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_318() { + fn __bindgen_test_layout_Handle_instantiation_383() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42169,7 +42145,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_319() { + fn __bindgen_test_layout_Handle_instantiation_384() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42180,7 +42156,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_320() { + fn __bindgen_test_layout_MutableHandle_instantiation_385() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42191,7 +42167,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_321() { + fn __bindgen_test_layout_Handle_instantiation_386() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42202,7 +42178,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_322() { + fn __bindgen_test_layout_MutableHandle_instantiation_387() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42213,7 +42189,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_323() { + fn __bindgen_test_layout_Handle_instantiation_388() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42224,7 +42200,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_324() { + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_389() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42235,7 +42211,7 @@ pub mod root { root::nsRefPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_nsClassHashtable_instantiation_325() { + fn __bindgen_test_layout_nsClassHashtable_instantiation_390() { assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42246,7 +42222,7 @@ pub mod root { [u64; 6usize] ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_326() { + fn __bindgen_test_layout_Handle_instantiation_391() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42257,7 +42233,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_327() { + fn __bindgen_test_layout_nsTArray_instantiation_392() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42268,7 +42244,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_328() { + fn __bindgen_test_layout_nsTArray_instantiation_393() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42279,7 +42255,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_329() { + fn __bindgen_test_layout_nsTArray_instantiation_394() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42290,7 +42266,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_330() { + fn __bindgen_test_layout_already_AddRefed_instantiation_395() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42301,7 +42277,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_331() { + fn __bindgen_test_layout_Handle_instantiation_396() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42312,7 +42288,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_332() { + fn __bindgen_test_layout_nsTArray_instantiation_397() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -42323,7 +42299,7 @@ pub mod root { root::nsTArray<*mut root::mozilla::css::DocumentRule> ) )); } #[test] - fn __bindgen_test_layout_nsAutoPtr_instantiation_333() { + fn __bindgen_test_layout_nsAutoPtr_instantiation_398() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( diff --git a/components/style/gecko/generated/structs_release.rs b/components/style/gecko/generated/structs_release.rs index 361ce6f7a61..b24581cd3a3 100644 --- a/components/style/gecko/generated/structs_release.rs +++ b/components/style/gecko/generated/structs_release.rs @@ -981,6 +981,9 @@ pub mod root { pub const CSS_PSEUDO_ELEMENT_UA_SHEET_ONLY: ::std::os::raw::c_uint = 16; pub const CSS_PSEUDO_ELEMENT_IS_JS_CREATED_NAC: ::std::os::raw::c_uint = 32; + pub const CSS_PSEUDO_ELEMENT_IS_FLEX_OR_GRID_ITEM: ::std::os::raw::c_uint + = + 64; pub const kNameSpaceID_Unknown: ::std::os::raw::c_int = -1; pub const kNameSpaceID_XMLNS: ::std::os::raw::c_uint = 1; pub const kNameSpaceID_XML: ::std::os::raw::c_uint = 2; @@ -1033,6 +1036,16 @@ pub mod root { use self::super::super::root; #[repr(C)] #[derive(Debug, Copy, Clone)] + pub struct __is_swappable { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct __is_nothrow_swappable { + pub _address: u8, + } + #[repr(C)] + #[derive(Debug, Copy, Clone)] pub struct pair<_T1, _T2> { pub first: _T1, pub second: _T2, @@ -1041,19 +1054,8 @@ pub mod root { } pub type pair_first_type<_T1> = _T1; pub type pair_second_type<_T2> = _T2; - pub type pair__EnableB = u8; - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct pair__CheckArgs { - pub _address: u8, - } - pub type pair__CheckArgsDep = u8; - #[repr(C)] - #[derive(Debug, Copy, Clone)] - pub struct pair__CheckTupleLikeConstructor { - pub _address: u8, - } - pub type pair__CheckTLC = u8; + pub type pair__PCCP = u8; + pub type pair__PCCFP = u8; #[repr(C)] #[derive(Debug, Copy)] pub struct input_iterator_tag { @@ -1073,98 +1075,47 @@ pub mod root { fn clone(&self) -> Self { *self } } #[repr(C)] - #[derive(Debug, Copy)] - pub struct forward_iterator_tag { + #[derive(Debug, Copy, Clone)] + pub struct iterator { pub _address: u8, } - #[test] - fn bindgen_test_layout_forward_iterator_tag() { - assert_eq!(::std::mem::size_of::() , 1usize - , concat ! ( - "Size of: " , stringify ! ( forward_iterator_tag ) )); - assert_eq! (::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of " , stringify ! ( forward_iterator_tag ) - )); - } - impl Clone for forward_iterator_tag { - fn clone(&self) -> Self { *self } - } + pub type iterator_iterator_category<_Category> = _Category; + pub type iterator_value_type<_Tp> = _Tp; + pub type iterator_difference_type<_Distance> = _Distance; + pub type iterator_pointer<_Pointer> = _Pointer; + pub type iterator_reference<_Reference> = _Reference; #[repr(C)] - #[derive(Debug, Copy)] - pub struct bidirectional_iterator_tag { + #[derive(Debug, Copy, Clone)] + pub struct __iterator_traits { pub _address: u8, } - #[test] - fn bindgen_test_layout_bidirectional_iterator_tag() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of: " , stringify ! ( bidirectional_iterator_tag - ) )); - assert_eq! (::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of " , stringify ! ( - bidirectional_iterator_tag ) )); - } - impl Clone for bidirectional_iterator_tag { - fn clone(&self) -> Self { *self } - } - #[repr(C)] - #[derive(Debug, Copy)] - pub struct random_access_iterator_tag { - pub _address: u8, - } - #[test] - fn bindgen_test_layout_random_access_iterator_tag() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of: " , stringify ! ( random_access_iterator_tag - ) )); - assert_eq! (::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of " , stringify ! ( - random_access_iterator_tag ) )); - } - impl Clone for random_access_iterator_tag { - fn clone(&self) -> Self { *self } - } #[repr(C)] + #[derive(Debug, Copy, Clone)] pub struct iterator_traits { pub _address: u8, } #[repr(C)] #[derive(Debug, Copy, Clone)] - pub struct iterator { - pub _address: u8, + pub struct reverse_iterator<_Iterator> { + pub current: _Iterator, + pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iterator>>, } - pub type iterator_value_type<_Tp> = _Tp; - pub type iterator_difference_type<_Distance> = _Distance; - pub type iterator_pointer<_Pointer> = _Pointer; - pub type iterator_reference<_Reference> = _Reference; - pub type iterator_iterator_category<_Category> = _Category; - #[repr(C)] - pub struct reverse_iterator<_Iter> { - pub __t: _Iter, - pub current: _Iter, - pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iter>>, - } - pub type reverse_iterator_iterator_type<_Iter> = _Iter; + pub type reverse_iterator___traits_type = root::std::iterator_traits; + pub type reverse_iterator_iterator_type<_Iterator> = _Iterator; pub type reverse_iterator_difference_type = - root::std::iterator_traits; - pub type reverse_iterator_reference = root::std::iterator_traits; - pub type reverse_iterator_pointer = root::std::iterator_traits; + root::std::reverse_iterator___traits_type; + pub type reverse_iterator_pointer = + root::std::reverse_iterator___traits_type; + pub type reverse_iterator_reference = + root::std::reverse_iterator___traits_type; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct atomic { } - pub type atomic___base = u8; - #[repr(C)] - pub struct __bit_const_reference { - pub __seg_: root::std::__bit_const_reference___storage_pointer, - pub __mask_: root::std::__bit_const_reference___storage_type, - } - pub type __bit_const_reference___storage_type = [u8; 0usize]; - pub type __bit_const_reference___storage_pointer = [u8; 0usize]; + } + pub mod __gnu_cxx { + #[allow(unused_imports)] + use self::super::super::root; } pub mod mozilla { #[allow(unused_imports)] @@ -1195,7 +1146,8 @@ pub mod root { pub struct nsStringRepr { pub mData: *mut root::mozilla::detail::nsStringRepr_char_type, pub mLength: root::mozilla::detail::nsStringRepr_size_type, - pub mFlags: u32, + pub mDataFlags: root::mozilla::detail::nsStringRepr_DataFlags, + pub mClassFlags: root::mozilla::detail::nsStringRepr_ClassFlags, } pub type nsStringRepr_fallible_t = root::mozilla::fallible_t; pub type nsStringRepr_char_type = u16; @@ -1218,42 +1170,10 @@ pub mod root { *const root::mozilla::detail::nsStringRepr_char_type; pub type nsStringRepr_index_type = u32; pub type nsStringRepr_size_type = u32; - pub const nsStringRepr_F_NONE: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_NONE; - pub const nsStringRepr_F_TERMINATED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_TERMINATED; - pub const nsStringRepr_F_VOIDED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_VOIDED; - pub const nsStringRepr_F_SHARED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_SHARED; - pub const nsStringRepr_F_OWNED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_OWNED; - pub const nsStringRepr_F_FIXED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_FIXED; - pub const nsStringRepr_F_LITERAL: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_LITERAL; - pub const nsStringRepr_F_CLASS_FIXED: - root::mozilla::detail::nsStringRepr__bindgen_ty_1 = - nsStringRepr__bindgen_ty_1::F_CLASS_FIXED; - #[repr(u32)] - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum nsStringRepr__bindgen_ty_1 { - F_NONE = 0, - F_TERMINATED = 1, - F_VOIDED = 2, - F_SHARED = 4, - F_OWNED = 8, - F_FIXED = 16, - F_LITERAL = 32, - F_CLASS_FIXED = 65536, - } + pub use self::super::super::super::root::mozilla::detail::StringDataFlags + as nsStringRepr_DataFlags; + pub use self::super::super::super::root::mozilla::detail::StringClassFlags + as nsStringRepr_ClassFlags; #[test] fn bindgen_test_layout_nsStringRepr() { assert_eq!(::std::mem::size_of::() , 16usize , @@ -1274,10 +1194,18 @@ pub mod root { nsStringRepr ) , "::" , stringify ! ( mLength ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsStringRepr ) ) . mFlags as - * const _ as usize } , 12usize , concat ! ( + & ( * ( 0 as * const nsStringRepr ) ) . mDataFlags + as * const _ as usize } , 12usize , concat ! ( "Alignment of field: " , stringify ! ( - nsStringRepr ) , "::" , stringify ! ( mFlags ) )); + nsStringRepr ) , "::" , stringify ! ( mDataFlags ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const nsStringRepr ) ) . + mClassFlags as * const _ as usize } , 14usize , + concat ! ( + "Alignment of field: " , stringify ! ( + nsStringRepr ) , "::" , stringify ! ( mClassFlags + ) )); } impl Clone for nsStringRepr { fn clone(&self) -> Self { *self } @@ -1287,7 +1215,8 @@ pub mod root { pub struct nsCStringRepr { pub mData: *mut root::mozilla::detail::nsCStringRepr_char_type, pub mLength: root::mozilla::detail::nsCStringRepr_size_type, - pub mFlags: u32, + pub mDataFlags: root::mozilla::detail::nsCStringRepr_DataFlags, + pub mClassFlags: root::mozilla::detail::nsCStringRepr_ClassFlags, } pub type nsCStringRepr_fallible_t = root::mozilla::fallible_t; pub type nsCStringRepr_char_type = ::std::os::raw::c_char; @@ -1311,42 +1240,10 @@ pub mod root { *const root::mozilla::detail::nsCStringRepr_char_type; pub type nsCStringRepr_index_type = u32; pub type nsCStringRepr_size_type = u32; - pub const nsCStringRepr_F_NONE: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_NONE; - pub const nsCStringRepr_F_TERMINATED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_TERMINATED; - pub const nsCStringRepr_F_VOIDED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_VOIDED; - pub const nsCStringRepr_F_SHARED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_SHARED; - pub const nsCStringRepr_F_OWNED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_OWNED; - pub const nsCStringRepr_F_FIXED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_FIXED; - pub const nsCStringRepr_F_LITERAL: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_LITERAL; - pub const nsCStringRepr_F_CLASS_FIXED: - root::mozilla::detail::nsCStringRepr__bindgen_ty_1 = - nsCStringRepr__bindgen_ty_1::F_CLASS_FIXED; - #[repr(u32)] - #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum nsCStringRepr__bindgen_ty_1 { - F_NONE = 0, - F_TERMINATED = 1, - F_VOIDED = 2, - F_SHARED = 4, - F_OWNED = 8, - F_FIXED = 16, - F_LITERAL = 32, - F_CLASS_FIXED = 65536, - } + pub use self::super::super::super::root::mozilla::detail::StringDataFlags + as nsCStringRepr_DataFlags; + pub use self::super::super::super::root::mozilla::detail::StringClassFlags + as nsCStringRepr_ClassFlags; #[test] fn bindgen_test_layout_nsCStringRepr() { assert_eq!(::std::mem::size_of::() , 16usize , @@ -1368,15 +1265,36 @@ pub mod root { nsCStringRepr ) , "::" , stringify ! ( mLength ) )); assert_eq! (unsafe { - & ( * ( 0 as * const nsCStringRepr ) ) . mFlags as - * const _ as usize } , 12usize , concat ! ( + & ( * ( 0 as * const nsCStringRepr ) ) . + mDataFlags as * const _ as usize } , 12usize , + concat ! ( "Alignment of field: " , stringify ! ( - nsCStringRepr ) , "::" , stringify ! ( mFlags ) - )); + nsCStringRepr ) , "::" , stringify ! ( mDataFlags + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const nsCStringRepr ) ) . + mClassFlags as * const _ as usize } , 14usize , + concat ! ( + "Alignment of field: " , stringify ! ( + nsCStringRepr ) , "::" , stringify ! ( mClassFlags + ) )); } impl Clone for nsCStringRepr { fn clone(&self) -> Self { *self } } + #[repr(u16)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum StringDataFlags { + TERMINATED = 1, + VOIDED = 2, + SHARED = 4, + OWNED = 8, + FIXED = 16, + LITERAL = 32, + } + #[repr(u16)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum StringClassFlags { FIXED = 1, } /** * LinkedList supports refcounted elements using this adapter class. Clients * using LinkedList> will get a data structure that holds a strong @@ -1398,7 +1316,7 @@ pub mod root { #[repr(C)] #[derive(Debug)] pub struct MutexImpl { - pub platformData_: [*mut ::std::os::raw::c_void; 8usize], + pub platformData_: [*mut ::std::os::raw::c_void; 5usize], } #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -1407,7 +1325,7 @@ pub mod root { } #[test] fn bindgen_test_layout_MutexImpl() { - assert_eq!(::std::mem::size_of::() , 64usize , + assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( "Size of: " , stringify ! ( MutexImpl ) )); assert_eq! (::std::mem::align_of::() , 8usize , @@ -2284,7 +2202,7 @@ pub mod root { } } #[repr(C)] - #[derive(Debug, Copy)] + #[derive(Debug)] pub struct ThreadSafeAutoRefCnt { pub mValue: u64, } @@ -2305,9 +2223,6 @@ pub mod root { ThreadSafeAutoRefCnt ) , "::" , stringify ! ( mValue ) )); } - impl Clone for ThreadSafeAutoRefCnt { - fn clone(&self) -> Self { *self } - } #[repr(C)] #[derive(Debug)] pub struct OwningNonNull { @@ -3525,7 +3440,8 @@ pub mod root { pub struct FakeString { pub mData: *mut root::mozilla::detail::nsStringRepr_char_type, pub mLength: root::mozilla::detail::nsStringRepr_size_type, - pub mFlags: u32, + pub mDataFlags: root::mozilla::detail::nsStringRepr_DataFlags, + pub mClassFlags: root::mozilla::detail::nsStringRepr_ClassFlags, pub mInlineStorage: [root::mozilla::detail::nsStringRepr_char_type; 64usize], } #[repr(C)] @@ -3567,11 +3483,19 @@ pub mod root { FakeString ) , "::" , stringify ! ( mLength ) )); assert_eq! (unsafe { - & ( * ( 0 as * const FakeString ) ) . mFlags - as * const _ as usize } , 12usize , concat ! ( + & ( * ( 0 as * const FakeString ) ) . + mDataFlags as * const _ as usize } , 12usize , + concat ! ( "Alignment of field: " , stringify ! ( - FakeString ) , "::" , stringify ! ( mFlags ) - )); + FakeString ) , "::" , stringify ! ( mDataFlags + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const FakeString ) ) . + mClassFlags as * const _ as usize } , 14usize + , concat ! ( + "Alignment of field: " , stringify ! ( + FakeString ) , "::" , stringify ! ( + mClassFlags ) )); assert_eq! (unsafe { & ( * ( 0 as * const FakeString ) ) . mInlineStorage as * const _ as usize } , @@ -8753,7 +8677,7 @@ pub mod root { } #[test] fn bindgen_test_layout_OffTheBooksMutex() { - assert_eq!(::std::mem::size_of::() , 64usize , + assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( "Size of: " , stringify ! ( OffTheBooksMutex ) )); assert_eq! (::std::mem::align_of::() , 8usize , @@ -8772,7 +8696,7 @@ pub mod root { } #[test] fn bindgen_test_layout_Mutex() { - assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( "Size of: " , stringify ! ( Mutex ) )); assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( "Alignment of " , stringify ! ( Mutex ) )); @@ -17979,14 +17903,14 @@ pub mod root { /** * This structure precedes the string buffers "we" allocate. It may be the * case that nsTAString::mData does not point to one of these special - * buffers. The mFlags member variable distinguishes the buffer type. + * buffers. The mDataFlags member variable distinguishes the buffer type. * * When this header is in use, it enables reference counting, and capacity * tracking. NOTE: A string buffer can be modified only if its reference * count is 1. */ #[repr(C)] - #[derive(Debug, Copy)] + #[derive(Debug)] pub struct nsStringBuffer { pub mRefCount: u32, pub mStorageSize: u32, @@ -18008,9 +17932,6 @@ pub mod root { "Alignment of field: " , stringify ! ( nsStringBuffer ) , "::" , stringify ! ( mStorageSize ) )); } - impl Clone for nsStringBuffer { - fn clone(&self) -> Self { *self } - } #[repr(C)] #[derive(Debug, Copy)] pub struct nsIAtom { @@ -26403,57 +26324,57 @@ pub mod root { pub struct nsDOMMutationObserver { _unused: [u8; 0], } - pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_LISTENERMANAGER; - pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_PROPERTIES; - pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_ANONYMOUS_ROOT; - pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE; - pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_NATIVE_ANONYMOUS_ROOT; - pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_FORCE_XBL_BINDINGS; - pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_MAY_BE_IN_BINDING_MNGR; - pub const NODE_IS_EDITABLE: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_EDITABLE; - pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_NATIVE_ANONYMOUS; - pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_IN_SHADOW_TREE; - pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_EMPTY_SELECTOR; - pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_SLOW_SELECTOR; - pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_EDGE_CHILD_SELECTOR; - pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS; - pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_ALL_SELECTOR_FLAGS; - pub const NODE_NEEDS_FRAME: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_NEEDS_FRAME; - pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_DESCENDANTS_NEED_FRAMES; - pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_ACCESSKEY; - pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_DIRECTION_RTL; - pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_HAS_DIRECTION_LTR; - pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_ALL_DIRECTION_FLAGS; - pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_CHROME_ONLY_ACCESS; - pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS; - pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_18 = - _bindgen_ty_18::NODE_TYPE_SPECIFIC_BITS_OFFSET; + pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_LISTENERMANAGER; + pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_PROPERTIES; + pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_ANONYMOUS_ROOT; + pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE; + pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_NATIVE_ANONYMOUS_ROOT; + pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_FORCE_XBL_BINDINGS; + pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_MAY_BE_IN_BINDING_MNGR; + pub const NODE_IS_EDITABLE: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_EDITABLE; + pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_NATIVE_ANONYMOUS; + pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_IN_SHADOW_TREE; + pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_EMPTY_SELECTOR; + pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_SLOW_SELECTOR; + pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_EDGE_CHILD_SELECTOR; + pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS; + pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_ALL_SELECTOR_FLAGS; + pub const NODE_NEEDS_FRAME: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_NEEDS_FRAME; + pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_DESCENDANTS_NEED_FRAMES; + pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_ACCESSKEY; + pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_DIRECTION_RTL; + pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_HAS_DIRECTION_LTR; + pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_ALL_DIRECTION_FLAGS; + pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_CHROME_ONLY_ACCESS; + pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS; + pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_77 = + _bindgen_ty_77::NODE_TYPE_SPECIFIC_BITS_OFFSET; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum _bindgen_ty_18 { + pub enum _bindgen_ty_77 { NODE_HAS_LISTENERMANAGER = 4, NODE_HAS_PROPERTIES = 8, NODE_IS_ANONYMOUS_ROOT = 16, @@ -32882,7 +32803,7 @@ pub mod root { pub type imgRequest_HasThreadSafeRefCnt = root::mozilla::TrueType; #[test] fn bindgen_test_layout_imgRequest() { - assert_eq!(::std::mem::size_of::() , 408usize , concat ! ( + assert_eq!(::std::mem::size_of::() , 384usize , concat ! ( "Size of: " , stringify ! ( imgRequest ) )); assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( "Alignment of " , stringify ! ( imgRequest ) )); @@ -34455,7 +34376,7 @@ pub mod root { ) , "::" , stringify ! ( mQuotePairs ) )); } #[test] - fn __bindgen_test_layout_StaticRefPtr_instantiation_21() { + fn __bindgen_test_layout_StaticRefPtr_instantiation_80() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -34466,7 +34387,7 @@ pub mod root { root::mozilla::StaticRefPtr ) )); } #[test] - fn __bindgen_test_layout_StaticRefPtr_instantiation_22() { + fn __bindgen_test_layout_StaticRefPtr_instantiation_81() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -37615,48 +37536,48 @@ pub mod root { pub struct nsAttrValueOrString { _unused: [u8; 0], } - pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_1; - pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_2; - pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_3; - pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_4; - pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_1; + pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_1; + pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_2; + pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_3; + pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_4; + pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_1; pub const ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO: - root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_2; - pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_3; - pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_4; - pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_1; - pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_2; - pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_20 + root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_2; + pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_3; + pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_4; + pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_1; + pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_2; + pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_79 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_3; + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_3; pub const ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT: - root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_SHARED_RESTYLE_BIT_4; - pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR; - pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_PENDING_RESTYLE_FLAGS; - pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS; - pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_ALL_RESTYLE_FLAGS; - pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_HAS_SCROLLGRAB; - pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_20 = - _bindgen_ty_20::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET; + root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_4; + pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR; + pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_PENDING_RESTYLE_FLAGS; + pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS; + pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_ALL_RESTYLE_FLAGS; + pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_HAS_SCROLLGRAB; + pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_79 = + _bindgen_ty_79::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] - pub enum _bindgen_ty_20 { + pub enum _bindgen_ty_79 { ELEMENT_SHARED_RESTYLE_BIT_1 = 8388608, ELEMENT_SHARED_RESTYLE_BIT_2 = 16777216, ELEMENT_SHARED_RESTYLE_BIT_3 = 33554432, @@ -37978,8 +37899,8 @@ pub mod root { impl Clone for GeckoFontMetrics { fn clone(&self) -> Self { *self } } - pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after: u32 = 1; - pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before: u32 = 1; + pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after: u32 = 65; + pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before: u32 = 65; pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_backdrop: u32 = 0; pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_cue: u32 = 36; pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLetter: u32 = 3; @@ -38207,6 +38128,22 @@ pub mod root { } #[repr(C)] #[derive(Debug, Copy)] + pub struct _bindgen_ty_29 { + pub _address: u8, + } + impl Clone for _bindgen_ty_29 { + fn clone(&self) -> Self { *self } + } + #[repr(C)] + #[derive(Debug, Copy)] + pub struct _bindgen_ty_30 { + pub _address: u8, + } + impl Clone for _bindgen_ty_30 { + fn clone(&self) -> Self { *self } + } + #[repr(C)] + #[derive(Debug, Copy)] pub struct __va_list_tag { pub gp_offset: ::std::os::raw::c_uint, pub fp_offset: ::std::os::raw::c_uint, @@ -38245,7 +38182,7 @@ pub mod root { } pub type __builtin_va_list = [root::__va_list_tag; 1usize]; #[test] - fn __bindgen_test_layout_IntegralConstant_instantiation_23() { + fn __bindgen_test_layout_IntegralConstant_instantiation_82() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -38254,7 +38191,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_IntegralConstant_instantiation_24() { + fn __bindgen_test_layout_IntegralConstant_instantiation_83() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -38263,7 +38200,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_25() { + fn __bindgen_test_layout_nsCharTraits_instantiation_84() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38274,7 +38211,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout_nsReadingIterator_instantiation_26() { + fn __bindgen_test_layout_nsReadingIterator_instantiation_85() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38287,7 +38224,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsWritingIterator_instantiation_27() { + fn __bindgen_test_layout_nsWritingIterator_instantiation_86() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38300,7 +38237,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_28() { + fn __bindgen_test_layout_nsCharTraits_instantiation_87() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38311,7 +38248,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout_nsReadingIterator_instantiation_29() { + fn __bindgen_test_layout_nsReadingIterator_instantiation_88() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38324,7 +38261,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsWritingIterator_instantiation_30() { + fn __bindgen_test_layout_nsWritingIterator_instantiation_89() { assert_eq!(::std::mem::size_of::>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38337,7 +38274,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_31() { + fn __bindgen_test_layout_nsCharTraits_instantiation_90() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38348,7 +38285,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout_nsCharTraits_instantiation_32() { + fn __bindgen_test_layout_nsCharTraits_instantiation_91() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38359,7 +38296,7 @@ pub mod root { root::nsCharTraits ) )); } #[test] - fn __bindgen_test_layout__bindgen_ty_id_187769_instantiation_33() { + fn __bindgen_test_layout__bindgen_ty_id_187468_instantiation_92() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -38368,7 +38305,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout__bindgen_ty_id_187805_instantiation_34() { + fn __bindgen_test_layout__bindgen_ty_id_187504_instantiation_93() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( u8 ) )); @@ -38377,7 +38314,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_35() { + fn __bindgen_test_layout_nsTArray_instantiation_94() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38388,7 +38325,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_36() { + fn __bindgen_test_layout_Handle_instantiation_95() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38399,7 +38336,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_37() { + fn __bindgen_test_layout_Handle_instantiation_96() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38410,7 +38347,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_38() { + fn __bindgen_test_layout_Handle_instantiation_97() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38421,7 +38358,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_39() { + fn __bindgen_test_layout_MutableHandle_instantiation_98() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38432,7 +38369,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Rooted_instantiation_40() { + fn __bindgen_test_layout_Rooted_instantiation_99() { assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -38443,655 +38380,6 @@ pub mod root { [u64; 3usize] ) )); } #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_41() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_42() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_43() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_44() { - assert_eq!(::std::mem::size_of::>() , 8usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , 8usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_45() { - assert_eq!(::std::mem::size_of::>() , 8usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , 8usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_PointTyped_instantiation_46() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_IntPointTyped_instantiation_47() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_SizeTyped_instantiation_48() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_RectTyped_instantiation_49() { - assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - } - #[test] - fn __bindgen_test_layout_IntPointTyped_instantiation_50() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_IntSizeTyped_instantiation_51() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_IntRectTyped_instantiation_52() { - assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - } - #[test] - fn __bindgen_test_layout_MarginTyped_instantiation_53() { - assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - } - #[test] - fn __bindgen_test_layout_RectTyped_instantiation_54() { - assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - } - #[test] - fn __bindgen_test_layout_IntRectTyped_instantiation_55() { - assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 4usize] ) )); - } - #[test] - fn __bindgen_test_layout_ScaleFactor_instantiation_56() { - assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( - "Size of template specialization: " , stringify ! ( u32 ) - )); - assert_eq!(::std::mem::align_of::() , 4usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - u32 ) )); - } - #[test] - fn __bindgen_test_layout_ScaleFactors2D_instantiation_57() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_ScaleFactors2D_instantiation_58() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_ScaleFactors2D_instantiation_59() { - assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u32; 2usize] ) )); - } - #[test] - fn __bindgen_test_layout_BaseTimeDuration_instantiation_60() { - assert_eq!(::std::mem::size_of::() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::BaseTimeDuration ) )); - assert_eq!(::std::mem::align_of::() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::BaseTimeDuration ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_61() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_62() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_63() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_64() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_65() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_66() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_WeakPtr_instantiation_67() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( u64 ) - )); - assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - u64 ) )); - } - #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_68() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsPtrHashKey ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_69() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_TErrorResult_instantiation_70() { - assert_eq!(::std::mem::size_of::() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::binding_danger::TErrorResult ) )); - assert_eq!(::std::mem::align_of::() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::binding_danger::TErrorResult ) )); - } - #[test] - fn __bindgen_test_layout_TErrorResult_instantiation_71() { - assert_eq!(::std::mem::size_of::() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::binding_danger::TErrorResult ) )); - assert_eq!(::std::mem::align_of::() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::binding_danger::TErrorResult ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_72() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_73() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_74() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_75() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_76() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::mozilla::StyleSheet> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::mozilla::StyleSheet> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_77() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_78() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_79() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_80() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_81() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_82() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_83() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_84() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_85() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_86() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_87() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_88() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_89() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_90() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_91() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_92() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_93() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_94() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_95() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_96() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] - fn __bindgen_test_layout_iterator_instantiation_97() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::std::iterator ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::std::iterator ) )); - } - #[test] - fn __bindgen_test_layout_DeletePolicy_instantiation_98() { - assert_eq!(::std::mem::size_of::() , 1usize , - concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - assert_eq!(::std::mem::align_of::() , 1usize , - concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::DeletePolicy ) )); - } - #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_99() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - } - #[test] fn __bindgen_test_layout_DeletePolicy_instantiation_100() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( @@ -39103,143 +38391,236 @@ pub mod root { root::JS::DeletePolicy ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_101() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_nsTArray_instantiation_101() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); + root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_102() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! + fn __bindgen_test_layout_nsTArray_instantiation_102() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_103() { + assert_eq!(::std::mem::size_of::>() , 8usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_104() { + assert_eq!(::std::mem::size_of::>() , 8usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_PointTyped_instantiation_105() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); + [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_103() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_IntPointTyped_instantiation_106() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); + [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_104() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_SizeTyped_instantiation_107() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); + [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_105() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( + fn __bindgen_test_layout_RectTyped_instantiation_108() { + assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( + [u32; 4usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); + [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_106() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( + fn __bindgen_test_layout_IntPointTyped_instantiation_109() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); + [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_Heap_instantiation_107() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( + fn __bindgen_test_layout_IntSizeTyped_instantiation_110() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::JS::Heap ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::JS::Heap ) )); + [u32; 2usize] ) )); } #[test] - fn __bindgen_test_layout_Heap_instantiation_108() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_IntRectTyped_instantiation_111() { + assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::JS::Heap<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + [u32; 4usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::JS::Heap<*mut root::JSObject> ) )); + [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_TenuredHeap_instantiation_109() { - assert_eq!(::std::mem::size_of::() , 8usize , - concat ! ( + fn __bindgen_test_layout_MarginTyped_instantiation_112() { + assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::JS::TenuredHeap ) )); - assert_eq!(::std::mem::align_of::() , 8usize , - concat ! ( + [u32; 4usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::JS::TenuredHeap ) )); + [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_110() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_RectTyped_instantiation_113() { + assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + [u32; 4usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! + ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + [u32; 4usize] ) )); } #[test] - fn __bindgen_test_layout_NotNull_instantiation_111() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_IntRectTyped_instantiation_114() { + assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat ! + ( "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) + [u32; 4usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u32; 4usize] ) )); + } + #[test] + fn __bindgen_test_layout_ScaleFactor_instantiation_115() { + assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( + "Size of template specialization: " , stringify ! ( u32 ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + assert_eq!(::std::mem::align_of::() , 4usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) - )); + u32 ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_112() { - assert_eq!(::std::mem::size_of::>>() + fn __bindgen_test_layout_ScaleFactors2D_instantiation_116() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u32; 2usize] ) )); + } + #[test] + fn __bindgen_test_layout_ScaleFactors2D_instantiation_117() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u32; 2usize] ) )); + } + #[test] + fn __bindgen_test_layout_ScaleFactors2D_instantiation_118() { + assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u32; 2usize] ) )); + assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u32; 2usize] ) )); + } + #[test] + fn __bindgen_test_layout_BaseTimeDuration_instantiation_119() { + assert_eq!(::std::mem::size_of::() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::BaseTimeDuration ) )); + assert_eq!(::std::mem::align_of::() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::BaseTimeDuration ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_120() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray> - ) )); - assert_eq!(::std::mem::align_of::>>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray> - ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_113() { + fn __bindgen_test_layout_already_AddRefed_instantiation_121() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_122() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39250,7 +38631,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_114() { + fn __bindgen_test_layout_nsTArray_instantiation_123() { assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39263,107 +38644,6 @@ pub mod root { )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_115() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_116() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_117() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_118() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_119() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_120() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_121() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_122() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_123() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] fn __bindgen_test_layout_RefPtr_instantiation_124() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( @@ -39376,80 +38656,80 @@ pub mod root { } #[test] fn __bindgen_test_layout_nsTArray_instantiation_125() { - assert_eq!(::std::mem::size_of::>() + assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); - assert_eq!(::std::mem::align_of::>() + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIDocument_Element> ) )); + root::nsTArray> ) + )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_126() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_WeakPtr_instantiation_126() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( u64 ) + )); + assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + u64 ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_127() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_nsPtrHashKey_instantiation_127() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::nsPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle<*mut root::JSObject> ) )); + root::nsPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_128() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_nsTArray_instantiation_128() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_129() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_TErrorResult_instantiation_129() { + assert_eq!(::std::mem::size_of::() + , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::mozilla::binding_danger::TErrorResult ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::mozilla::binding_danger::TErrorResult ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_130() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( + fn __bindgen_test_layout_TErrorResult_instantiation_130() { + assert_eq!(::std::mem::size_of::() + , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::mozilla::binding_danger::TErrorResult ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::mozilla::binding_danger::TErrorResult ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_131() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_131() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_Handle_instantiation_132() { @@ -39463,40 +38743,51 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_133() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_MutableHandle_instantiation_133() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_134() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_Handle_instantiation_134() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_135() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! - ( + fn __bindgen_test_layout_nsTArray_instantiation_135() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( + root::nsTArray<*mut root::mozilla::StyleSheet> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); + root::nsTArray<*mut root::mozilla::StyleSheet> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_136() { + fn __bindgen_test_layout_Handle_instantiation_136() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_137() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -39507,28 +38798,15 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_137() { - assert_eq!(::std::mem::size_of::>>() + fn __bindgen_test_layout_Handle_instantiation_138() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - assert_eq!(::std::mem::align_of::>>() + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_138() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::mozilla::StyleSheet> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::mozilla::StyleSheet> ) )); + root::JS::Handle<*mut root::JSObject> ) )); } #[test] fn __bindgen_test_layout_Handle_instantiation_139() { @@ -39542,462 +38820,40 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_140() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( + fn __bindgen_test_layout_already_AddRefed_instantiation_140() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_141() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_141() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::mozilla::UniquePtr ) )); + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_already_AddRefed_instantiation_142() { - assert_eq!(::std::mem::size_of::>() + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_143() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_144() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_145() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_146() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_147() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey - ) )); - } - #[test] - fn __bindgen_test_layout_nsDataHashtable_instantiation_148() { - assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 5usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 5usize] ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_149() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_150() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_151() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<*mut root::nsIContent> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_152() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_153() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_SupportsWeakPtr_instantiation_154() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( u64 ) - )); - assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - u64 ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_155() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_156() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_157() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_158() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsPresContext_Encoding> - ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_159() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_160() { - assert_eq!(::std::mem::size_of::() , - 1usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - assert_eq!(::std::mem::align_of::() , - 1usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::DefaultDelete ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_161() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsRefPtrHashKey ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_162() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_163() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_164() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_165() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_166() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_167() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_168() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_169() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_170() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_171() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsPIDOMWindow_instantiation_172() { - assert_eq!(::std::mem::size_of::<[u64; 30usize]>() , 240usize , concat - ! ( - "Size of template specialization: " , stringify ! ( - [u64; 30usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 30usize]>() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - [u64; 30usize] ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_173() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_174() { - assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 5usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 5usize] ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_175() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_176() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_177() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_178() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_179() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - } - #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_180() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::OwningNonNull ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_181() { + fn __bindgen_test_layout_Handle_instantiation_143() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40008,29 +38864,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_182() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_183() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_184() { + fn __bindgen_test_layout_MutableHandle_instantiation_144() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40041,70 +38875,518 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_185() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_MutableHandle_instantiation_145() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_146() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_147() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_148() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_149() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_150() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_151() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_152() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_153() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_154() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_155() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_iterator_instantiation_156() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::std::iterator ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::std::iterator ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_157() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_158() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_DeletePolicy_instantiation_159() { + assert_eq!(::std::mem::size_of::() , 1usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + assert_eq!(::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::DeletePolicy ) )); + } + #[test] + fn __bindgen_test_layout_UniquePtr_instantiation_160() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_161() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_162() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_163() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_164() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() , + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_165() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_Heap_instantiation_166() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Heap ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Heap ) )); + } + #[test] + fn __bindgen_test_layout_Heap_instantiation_167() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Heap<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Heap<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_TenuredHeap_instantiation_168() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::TenuredHeap ) )); + assert_eq!(::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::TenuredHeap ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_169() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_170() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) + )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIDocument_Encoding> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_171() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_172() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_173() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_174() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_175() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_176() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_177() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_178() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_179() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_180() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_181() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_182() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_183() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_184() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIDocument_Element> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_185() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_MutableHandle_instantiation_186() { - assert_eq!(::std::mem::size_of::>() + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() + root::JS::MutableHandle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); + root::JS::MutableHandle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_187() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( + fn __bindgen_test_layout_already_AddRefed_instantiation_187() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_188() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_188() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_189() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_189() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_190() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_RefPtr_instantiation_190() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); + root::RefPtr ) )); } #[test] fn __bindgen_test_layout_Handle_instantiation_191() { @@ -40118,26 +39400,26 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_192() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_192() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle<*mut root::JSObject> ) )); + root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_193() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_already_AddRefed_instantiation_193() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_nsCOMPtr_instantiation_194() { @@ -40151,130 +39433,53 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_195() { - assert_eq!(::std::mem::size_of::>() - , 16usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsPtrHashKey<::std::os::raw::c_void> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsPtrHashKey<::std::os::raw::c_void> ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_196() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_RefPtr_instantiation_195() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_197() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_nsTArray_instantiation_196() { + assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::nsTArray> ) + )); + assert_eq!(::std::mem::align_of::>>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::nsTArray> ) + )); } #[test] - fn __bindgen_test_layout_NotNull_instantiation_198() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_nsTArray_instantiation_197() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsLanguageAtomService_Encoding> - ) )); - assert_eq!(::std::mem::align_of::>() + root::nsTArray<*mut root::mozilla::StyleSheet> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsLanguageAtomService_Encoding> - ) )); + root::nsTArray<*mut root::mozilla::StyleSheet> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_199() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_Handle_instantiation_198() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_200() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_201() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsPIDOMWindow_instantiation_202() { - assert_eq!(::std::mem::size_of::<[u64; 30usize]>() , 240usize , concat - ! ( - "Size of template specialization: " , stringify ! ( - [u64; 30usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 30usize]>() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - [u64; 30usize] ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_203() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_204() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_205() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_206() { + fn __bindgen_test_layout_DefaultDelete_instantiation_199() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40285,7 +39490,86 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_207() { + fn __bindgen_test_layout_UniquePtr_instantiation_200() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::UniquePtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_201() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_202() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_203() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_204() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_205() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_206() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsRefPtrHashKey + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsRefPtrHashKey + ) )); + } + #[test] + fn __bindgen_test_layout_nsDataHashtable_instantiation_207() { assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40296,108 +39580,7 @@ pub mod root { [u64; 5usize] ) )); } #[test] - fn __bindgen_test_layout_Rooted_instantiation_208() { - assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - } - #[test] - fn __bindgen_test_layout_Rooted_instantiation_209() { - assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! - ( - "Alignment of template specialization: " , stringify ! ( - [u64; 3usize] ) )); - } - #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_210() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_211() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_212() { - assert_eq!(::std::mem::size_of::() , 8usize , concat ! - ( - "Size of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - assert_eq!(::std::mem::align_of::() , 8usize , concat - ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsCOMPtr ) )); - } - #[test] - fn __bindgen_test_layout_NotNull_instantiation_213() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIParser_Encoding> ) - )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::mozilla::NotNull<*const root::nsIParser_Encoding> ) - )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_214() { - assert_eq!(::std::mem::size_of::>() , - 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , - 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_215() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::Handle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle ) )); - } - #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_216() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - } - #[test] - fn __bindgen_test_layout_Handle_instantiation_217() { + fn __bindgen_test_layout_Handle_instantiation_208() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40408,94 +39591,193 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_218() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_nsTArray_instantiation_209() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); - assert_eq!(::std::mem::align_of::>() + root::nsTArray<*mut root::nsIContent> ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::JS::MutableHandle ) )); + root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_219() { - assert_eq!(::std::mem::size_of::>() , + fn __bindgen_test_layout_nsTArray_instantiation_210() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIContent> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<*mut root::nsIContent> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_211() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_212() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_SupportsWeakPtr_instantiation_213() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( u64 ) + )); + assert_eq!(::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + u64 ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_214() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_215() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); - assert_eq!(::std::mem::align_of::>() , + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray<::nsstring::nsStringRepr> ) )); + root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_220() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_NotNull_instantiation_216() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::JS::Handle<*mut root::JSObject> ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_221() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_222() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_RefPtr_instantiation_223() { - assert_eq!(::std::mem::size_of::>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() - , 8usize , concat ! ( - "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); - } - #[test] - fn __bindgen_test_layout_nsTArray_instantiation_224() { - assert_eq!(::std::mem::size_of::>>() - , 8usize , concat ! ( - "Size of template specialization: " , stringify ! ( - root::nsTArray> + root::mozilla::NotNull<*const root::nsPresContext_Encoding> ) )); - assert_eq!(::std::mem::align_of::>>() + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::nsTArray> + root::mozilla::NotNull<*const root::nsPresContext_Encoding> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_225() { - assert_eq!(::std::mem::size_of::>() + fn __bindgen_test_layout_NotNull_instantiation_217() { + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::RefPtr ) )); - assert_eq!(::std::mem::align_of::>() + root::mozilla::NotNull<*const root::nsPresContext_Encoding> + ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::RefPtr ) )); + root::mozilla::NotNull<*const root::nsPresContext_Encoding> + ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_218() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_219() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_220() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsRefPtrHashKey ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_221() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_222() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_223() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_224() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_225() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_already_AddRefed_instantiation_226() { @@ -40510,14 +39792,14 @@ pub mod root { } #[test] fn __bindgen_test_layout_already_AddRefed_instantiation_227() { - assert_eq!(::std::mem::size_of::>() + assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( - root::already_AddRefed ) )); - assert_eq!(::std::mem::align_of::>() + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() , 8usize , concat ! ( "Alignment of template specialization: " , stringify ! ( - root::already_AddRefed ) )); + root::already_AddRefed ) )); } #[test] fn __bindgen_test_layout_Handle_instantiation_228() { @@ -40531,7 +39813,662 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_229() { + fn __bindgen_test_layout_Handle_instantiation_229() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_230() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsPIDOMWindow_instantiation_231() { + assert_eq!(::std::mem::size_of::<[u64; 30usize]>() , 240usize , concat + ! ( + "Size of template specialization: " , stringify ! ( + [u64; 30usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 30usize]>() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + [u64; 30usize] ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_232() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_233() { + assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 5usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 5usize] ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_234() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_235() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_236() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_237() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_238() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + } + #[test] + fn __bindgen_test_layout_OwningNonNull_instantiation_239() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::OwningNonNull ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_240() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_241() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_242() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_243() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_244() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_245() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_246() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_247() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_248() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_249() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_250() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_251() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_252() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_253() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsPtrHashKey_instantiation_254() { + assert_eq!(::std::mem::size_of::>() + , 16usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsPtrHashKey<::std::os::raw::c_void> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsPtrHashKey<::std::os::raw::c_void> ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_255() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_256() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_257() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsLanguageAtomService_Encoding> + ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsLanguageAtomService_Encoding> + ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_258() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_259() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_260() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsPIDOMWindow_instantiation_261() { + assert_eq!(::std::mem::size_of::<[u64; 30usize]>() , 240usize , concat + ! ( + "Size of template specialization: " , stringify ! ( + [u64; 30usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 30usize]>() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + [u64; 30usize] ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_262() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_263() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_264() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_DefaultDelete_instantiation_265() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + assert_eq!(::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::DefaultDelete ) )); + } + #[test] + fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_266() { + assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 5usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 5usize] ) )); + } + #[test] + fn __bindgen_test_layout_Rooted_instantiation_267() { + assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + } + #[test] + fn __bindgen_test_layout_Rooted_instantiation_268() { + assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat ! + ( + "Alignment of template specialization: " , stringify ! ( + [u64; 3usize] ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_269() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_270() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsCOMPtr_instantiation_271() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! + ( + "Size of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + assert_eq!(::std::mem::align_of::() , 8usize , concat + ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsCOMPtr ) )); + } + #[test] + fn __bindgen_test_layout_NotNull_instantiation_272() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIParser_Encoding> ) + )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::mozilla::NotNull<*const root::nsIParser_Encoding> ) + )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_273() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_274() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_275() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_276() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_MutableHandle_instantiation_277() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::MutableHandle ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_278() { + assert_eq!(::std::mem::size_of::>() , + 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + assert_eq!(::std::mem::align_of::>() , + 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray<::nsstring::nsStringRepr> ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_279() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_280() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_281() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_282() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_283() { + assert_eq!(::std::mem::size_of::>>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + assert_eq!(::std::mem::align_of::>>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::nsTArray> + ) )); + } + #[test] + fn __bindgen_test_layout_RefPtr_instantiation_284() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::RefPtr ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::RefPtr ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_285() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_already_AddRefed_instantiation_286() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::already_AddRefed ) )); + } + #[test] + fn __bindgen_test_layout_Handle_instantiation_287() { + assert_eq!(::std::mem::size_of::>() + , 8usize , concat ! ( + "Size of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + assert_eq!(::std::mem::align_of::>() + , 8usize , concat ! ( + "Alignment of template specialization: " , stringify ! ( + root::JS::Handle<*mut root::JSObject> ) )); + } + #[test] + fn __bindgen_test_layout_nsTArray_instantiation_288() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40542,7 +40479,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_230() { + fn __bindgen_test_layout_RefPtr_instantiation_289() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40555,7 +40492,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_231() { + fn __bindgen_test_layout_nsTArray_instantiation_290() { assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40568,7 +40505,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_232() { + fn __bindgen_test_layout_RefPtr_instantiation_291() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40581,7 +40518,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_233() { + fn __bindgen_test_layout_UniquePtr_instantiation_292() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40592,7 +40529,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_234() { + fn __bindgen_test_layout_nsTArray_instantiation_293() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40603,7 +40540,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_235() { + fn __bindgen_test_layout_Handle_instantiation_294() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40614,7 +40551,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_236() { + fn __bindgen_test_layout_MutableHandle_instantiation_295() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40625,7 +40562,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_237() { + fn __bindgen_test_layout_Handle_instantiation_296() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40636,7 +40573,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_238() { + fn __bindgen_test_layout_MutableHandle_instantiation_297() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40647,7 +40584,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_239() { + fn __bindgen_test_layout_already_AddRefed_instantiation_298() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40658,7 +40595,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsDataHashtable_instantiation_240() { + fn __bindgen_test_layout_nsDataHashtable_instantiation_299() { assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40669,7 +40606,7 @@ pub mod root { [u64; 5usize] ) )); } #[test] - fn __bindgen_test_layout_OwningNonNull_instantiation_241() { + fn __bindgen_test_layout_OwningNonNull_instantiation_300() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40682,7 +40619,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_242() { + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_301() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40693,7 +40630,7 @@ pub mod root { root::nsRefPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_243() { + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_302() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40704,7 +40641,7 @@ pub mod root { root::nsRefPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_244() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_303() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40715,7 +40652,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_245() { + fn __bindgen_test_layout_DefaultDelete_instantiation_304() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40726,7 +40663,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_246() { + fn __bindgen_test_layout_already_AddRefed_instantiation_305() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40737,7 +40674,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_247() { + fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_306() { assert_eq!(::std::mem::size_of::>() , 40usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40748,7 +40685,7 @@ pub mod root { root::nsMainThreadPtrHolder ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_248() { + fn __bindgen_test_layout_already_AddRefed_instantiation_307() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40759,7 +40696,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_249() { + fn __bindgen_test_layout_already_AddRefed_instantiation_308() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40770,7 +40707,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_250() { + fn __bindgen_test_layout_already_AddRefed_instantiation_309() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40781,7 +40718,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_251() { + fn __bindgen_test_layout_already_AddRefed_instantiation_310() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40792,7 +40729,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_252() { + fn __bindgen_test_layout_already_AddRefed_instantiation_311() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40803,7 +40740,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsPtrHashKey_instantiation_253() { + fn __bindgen_test_layout_nsPtrHashKey_instantiation_312() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40814,7 +40751,7 @@ pub mod root { root::nsPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_254() { + fn __bindgen_test_layout_already_AddRefed_instantiation_313() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40825,7 +40762,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_255() { + fn __bindgen_test_layout_DefaultDelete_instantiation_314() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40836,7 +40773,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_256() { + fn __bindgen_test_layout_UniquePtr_instantiation_315() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40847,7 +40784,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_257() { + fn __bindgen_test_layout_DefaultDelete_instantiation_316() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40858,7 +40795,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_258() { + fn __bindgen_test_layout_UniquePtr_instantiation_317() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40869,7 +40806,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_259() { + fn __bindgen_test_layout_already_AddRefed_instantiation_318() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40880,7 +40817,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_SupportsWeakPtr_instantiation_260() { + fn __bindgen_test_layout_SupportsWeakPtr_instantiation_319() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -40889,7 +40826,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_261() { + fn __bindgen_test_layout_nsTArray_instantiation_320() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40900,7 +40837,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_262() { + fn __bindgen_test_layout_nsTArray_instantiation_321() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40911,7 +40848,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_263() { + fn __bindgen_test_layout_already_AddRefed_instantiation_322() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40922,7 +40859,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_264() { + fn __bindgen_test_layout_already_AddRefed_instantiation_323() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40933,7 +40870,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_265() { + fn __bindgen_test_layout_Maybe_instantiation_324() { assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40944,7 +40881,7 @@ pub mod root { [u32; 3usize] ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_266() { + fn __bindgen_test_layout_Maybe_instantiation_325() { assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40955,7 +40892,7 @@ pub mod root { [u32; 3usize] ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_267() { + fn __bindgen_test_layout_already_AddRefed_instantiation_326() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40966,7 +40903,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_268() { + fn __bindgen_test_layout_already_AddRefed_instantiation_327() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40977,7 +40914,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_269() { + fn __bindgen_test_layout_DefaultDelete_instantiation_328() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40988,7 +40925,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_270() { + fn __bindgen_test_layout_UniquePtr_instantiation_329() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -40999,7 +40936,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_271() { + fn __bindgen_test_layout_DefaultDelete_instantiation_330() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41010,7 +40947,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_272() { + fn __bindgen_test_layout_UniquePtr_instantiation_331() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41021,7 +40958,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_273() { + fn __bindgen_test_layout_already_AddRefed_instantiation_332() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41032,7 +40969,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_274() { + fn __bindgen_test_layout_Maybe_instantiation_333() { assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41043,7 +40980,7 @@ pub mod root { [u32; 3usize] ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_275() { + fn __bindgen_test_layout_DefaultDelete_instantiation_334() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41054,7 +40991,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_276() { + fn __bindgen_test_layout_DefaultDelete_instantiation_335() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41065,7 +41002,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_pair_instantiation_277() { + fn __bindgen_test_layout_pair_instantiation_336() { assert_eq!(::std::mem::size_of::>() , 32usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41076,7 +41013,7 @@ pub mod root { root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_278() { + fn __bindgen_test_layout_nsTArray_instantiation_337() { assert_eq!(::std::mem::size_of::>>() , 8usize , concat ! ( @@ -41091,7 +41028,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_279() { + fn __bindgen_test_layout_already_AddRefed_instantiation_338() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41102,7 +41039,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_280() { + fn __bindgen_test_layout_nsTArray_instantiation_339() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41113,7 +41050,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_281() { + fn __bindgen_test_layout_nsTArray_instantiation_340() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41124,7 +41061,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_282() { + fn __bindgen_test_layout_nsTArray_instantiation_341() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41135,7 +41072,7 @@ pub mod root { root::nsTArray ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_283() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_342() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41146,7 +41083,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_284() { + fn __bindgen_test_layout_RefPtr_instantiation_343() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41157,7 +41094,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_nsStyleAutoArray_instantiation_285() { + fn __bindgen_test_layout_nsStyleAutoArray_instantiation_344() { assert_eq!(::std::mem::size_of::>() , 64usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41168,7 +41105,7 @@ pub mod root { root::nsStyleAutoArray ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_286() { + fn __bindgen_test_layout_DefaultDelete_instantiation_345() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41179,7 +41116,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_287() { + fn __bindgen_test_layout_UniquePtr_instantiation_346() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41190,7 +41127,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_DefaultDelete_instantiation_288() { + fn __bindgen_test_layout_DefaultDelete_instantiation_347() { assert_eq!(::std::mem::size_of::() , 1usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41201,7 +41138,7 @@ pub mod root { root::mozilla::DefaultDelete ) )); } #[test] - fn __bindgen_test_layout_UniquePtr_instantiation_289() { + fn __bindgen_test_layout_UniquePtr_instantiation_348() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41212,7 +41149,7 @@ pub mod root { root::mozilla::UniquePtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_290() { + fn __bindgen_test_layout_RefPtr_instantiation_349() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41223,7 +41160,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_291() { + fn __bindgen_test_layout_RefPtr_instantiation_350() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41234,7 +41171,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_NonNull_instantiation_292() { + fn __bindgen_test_layout_NonNull_instantiation_351() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41247,7 +41184,7 @@ pub mod root { )); } #[test] - fn __bindgen_test_layout_NonNull_instantiation_293() { + fn __bindgen_test_layout_NonNull_instantiation_352() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41260,7 +41197,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_294() { + fn __bindgen_test_layout_Handle_instantiation_353() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41271,7 +41208,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_295() { + fn __bindgen_test_layout_MutableHandle_instantiation_354() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41282,7 +41219,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_296() { + fn __bindgen_test_layout_Maybe_instantiation_355() { assert_eq!(::std::mem::size_of::<[u64; 18usize]>() , 144usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41293,7 +41230,7 @@ pub mod root { [u64; 18usize] ) )); } #[test] - fn __bindgen_test_layout_Maybe_instantiation_297() { + fn __bindgen_test_layout_Maybe_instantiation_356() { assert_eq!(::std::mem::size_of::<[u64; 18usize]>() , 144usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41304,7 +41241,7 @@ pub mod root { [u64; 18usize] ) )); } #[test] - fn __bindgen_test_layout_BaseTimeDuration_instantiation_298() { + fn __bindgen_test_layout_BaseTimeDuration_instantiation_357() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41315,7 +41252,7 @@ pub mod root { root::mozilla::BaseTimeDuration ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_299() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_358() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41326,7 +41263,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_300() { + fn __bindgen_test_layout_already_AddRefed_instantiation_359() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41337,7 +41274,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_301() { + fn __bindgen_test_layout_already_AddRefed_instantiation_360() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41348,7 +41285,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_302() { + fn __bindgen_test_layout_nsTArray_instantiation_361() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41359,7 +41296,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_303() { + fn __bindgen_test_layout_nsTArray_instantiation_362() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41370,7 +41307,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsCOMPtr_instantiation_304() { + fn __bindgen_test_layout_nsCOMPtr_instantiation_363() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41381,7 +41318,7 @@ pub mod root { root::nsCOMPtr ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_305() { + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_364() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41394,7 +41331,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_306() { + fn __bindgen_test_layout_already_AddRefed_instantiation_365() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41405,7 +41342,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_307() { + fn __bindgen_test_layout_nsTArray_instantiation_366() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41418,7 +41355,7 @@ pub mod root { ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_308() { + fn __bindgen_test_layout_Handle_instantiation_367() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41429,7 +41366,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_309() { + fn __bindgen_test_layout_Handle_instantiation_368() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41440,7 +41377,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_RefPtr_instantiation_310() { + fn __bindgen_test_layout_RefPtr_instantiation_369() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41451,7 +41388,7 @@ pub mod root { root::RefPtr ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_311() { + fn __bindgen_test_layout_Handle_instantiation_370() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41462,7 +41399,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_312() { + fn __bindgen_test_layout_MutableHandle_instantiation_371() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41473,7 +41410,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Sequence_instantiation_313() { + fn __bindgen_test_layout_Sequence_instantiation_372() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -41482,7 +41419,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_314() { + fn __bindgen_test_layout_Handle_instantiation_373() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41493,7 +41430,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Sequence_instantiation_315() { + fn __bindgen_test_layout_Sequence_instantiation_374() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -41502,7 +41439,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_Sequence_instantiation_316() { + fn __bindgen_test_layout_Sequence_instantiation_375() { assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( u64 ) )); @@ -41511,7 +41448,7 @@ pub mod root { u64 ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_317() { + fn __bindgen_test_layout_Handle_instantiation_376() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41522,7 +41459,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_318() { + fn __bindgen_test_layout_Handle_instantiation_377() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41533,7 +41470,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_319() { + fn __bindgen_test_layout_MutableHandle_instantiation_378() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41544,7 +41481,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_320() { + fn __bindgen_test_layout_Handle_instantiation_379() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41555,7 +41492,7 @@ pub mod root { root::JS::Handle ) )); } #[test] - fn __bindgen_test_layout_MutableHandle_instantiation_321() { + fn __bindgen_test_layout_MutableHandle_instantiation_380() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41566,7 +41503,7 @@ pub mod root { root::JS::MutableHandle ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_322() { + fn __bindgen_test_layout_Handle_instantiation_381() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41577,7 +41514,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_323() { + fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_382() { assert_eq!(::std::mem::size_of::>() , 16usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41588,7 +41525,7 @@ pub mod root { root::nsRefPtrHashKey ) )); } #[test] - fn __bindgen_test_layout_nsClassHashtable_instantiation_324() { + fn __bindgen_test_layout_nsClassHashtable_instantiation_383() { assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41599,7 +41536,7 @@ pub mod root { [u64; 5usize] ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_325() { + fn __bindgen_test_layout_Handle_instantiation_384() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41610,7 +41547,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_326() { + fn __bindgen_test_layout_nsTArray_instantiation_385() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41621,7 +41558,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_327() { + fn __bindgen_test_layout_nsTArray_instantiation_386() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41632,7 +41569,7 @@ pub mod root { root::nsTArray<*mut root::nsIContent> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_328() { + fn __bindgen_test_layout_nsTArray_instantiation_387() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41643,7 +41580,7 @@ pub mod root { root::nsTArray<::nsstring::nsStringRepr> ) )); } #[test] - fn __bindgen_test_layout_already_AddRefed_instantiation_329() { + fn __bindgen_test_layout_already_AddRefed_instantiation_388() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41654,7 +41591,7 @@ pub mod root { root::already_AddRefed ) )); } #[test] - fn __bindgen_test_layout_Handle_instantiation_330() { + fn __bindgen_test_layout_Handle_instantiation_389() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41665,7 +41602,7 @@ pub mod root { root::JS::Handle<*mut root::JSObject> ) )); } #[test] - fn __bindgen_test_layout_nsTArray_instantiation_331() { + fn __bindgen_test_layout_nsTArray_instantiation_390() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! ( @@ -41676,7 +41613,7 @@ pub mod root { root::nsTArray<*mut root::mozilla::css::DocumentRule> ) )); } #[test] - fn __bindgen_test_layout_nsAutoPtr_instantiation_332() { + fn __bindgen_test_layout_nsAutoPtr_instantiation_391() { assert_eq!(::std::mem::size_of::>() , 8usize , concat ! ( "Size of template specialization: " , stringify ! (