mirror of
https://github.com/servo/servo
synced 2026-04-26 01:25:32 +02:00
c4ae451612
Servo has a lot of comments like this: ```rust // https://example-spec.com/#do-the-thing fn do_the_thing() {} ``` and I keep turning these into doc comments whenever I'm working close to one of them. Doing so allows me to hover over a function call in an IDE and open its specification without having to jump to the function definition first. This change fixes all of these comments at once. This was done using `find components -name '*.rs' -exec perl -i -0777 -pe 's|^([ \t]*)// (https?://.*)\n\1(fn )|\1/// <$2>\n\1$3|mg' {} +`. Note that these comments should be doc comments even within trait `impl` blocks, because rustdoc will use them as fallback documentation when the method definition on the trait does not have documentation. Testing: Comments only, no testing required Preparation for https://github.com/servo/servo/pull/39552 --------- Signed-off-by: Simon Wülker <simon.wuelker@arcor.de>
108 lines
3.8 KiB
Rust
108 lines
3.8 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
use dom_struct::dom_struct;
|
|
use servo_arc::Arc;
|
|
use style::shared_lock::{Locked, SharedRwLock, SharedRwLockReadGuard};
|
|
use style::stylesheets::{CssRuleType, CssRuleTypes, CssRules};
|
|
|
|
use super::cssconditionrule::CSSConditionRule;
|
|
use super::csslayerblockrule::CSSLayerBlockRule;
|
|
use super::cssrule::CSSRule;
|
|
use super::cssrulelist::{CSSRuleList, RulesSource};
|
|
use super::cssstylerule::CSSStyleRule;
|
|
use super::cssstylesheet::CSSStyleSheet;
|
|
use crate::dom::bindings::codegen::Bindings::CSSGroupingRuleBinding::CSSGroupingRuleMethods;
|
|
use crate::dom::bindings::error::{ErrorResult, Fallible};
|
|
use crate::dom::bindings::inheritance::Castable;
|
|
use crate::dom::bindings::reflector::DomGlobal;
|
|
use crate::dom::bindings::root::{DomRoot, MutNullableDom};
|
|
use crate::dom::bindings::str::DOMString;
|
|
use crate::script_runtime::CanGc;
|
|
|
|
#[dom_struct]
|
|
pub(crate) struct CSSGroupingRule {
|
|
cssrule: CSSRule,
|
|
rulelist: MutNullableDom<CSSRuleList>,
|
|
}
|
|
|
|
impl CSSGroupingRule {
|
|
pub(crate) fn new_inherited(parent_stylesheet: &CSSStyleSheet) -> CSSGroupingRule {
|
|
CSSGroupingRule {
|
|
cssrule: CSSRule::new_inherited(parent_stylesheet),
|
|
rulelist: MutNullableDom::new(None),
|
|
}
|
|
}
|
|
|
|
fn rulelist(&self, can_gc: CanGc) -> DomRoot<CSSRuleList> {
|
|
let parent_stylesheet = self.upcast::<CSSRule>().parent_stylesheet();
|
|
self.rulelist.or_init(|| {
|
|
let rules = if let Some(rule) = self.downcast::<CSSConditionRule>() {
|
|
rule.clone_rules()
|
|
} else if let Some(rule) = self.downcast::<CSSLayerBlockRule>() {
|
|
rule.clone_rules()
|
|
} else if let Some(rule) = self.downcast::<CSSStyleRule>() {
|
|
rule.ensure_rules()
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
CSSRuleList::new(
|
|
self.global().as_window(),
|
|
parent_stylesheet,
|
|
RulesSource::Rules(rules),
|
|
can_gc,
|
|
)
|
|
})
|
|
}
|
|
|
|
pub(crate) fn parent_stylesheet(&self) -> &CSSStyleSheet {
|
|
self.cssrule.parent_stylesheet()
|
|
}
|
|
|
|
pub(crate) fn shared_lock(&self) -> &SharedRwLock {
|
|
self.cssrule.shared_lock()
|
|
}
|
|
|
|
pub(crate) fn update_rules(
|
|
&self,
|
|
rules: &Arc<Locked<CssRules>>,
|
|
guard: &SharedRwLockReadGuard,
|
|
) {
|
|
if let Some(rulelist) = self.rulelist.get() {
|
|
rulelist.update_rules(RulesSource::Rules(rules.clone()), guard);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl CSSGroupingRuleMethods<crate::DomTypeHolder> for CSSGroupingRule {
|
|
/// <https://drafts.csswg.org/cssom/#dom-cssgroupingrule-cssrules>
|
|
fn CssRules(&self, can_gc: CanGc) -> DomRoot<CSSRuleList> {
|
|
// XXXManishearth check origin clean flag
|
|
self.rulelist(can_gc)
|
|
}
|
|
|
|
/// <https://drafts.csswg.org/cssom/#dom-cssgroupingrule-insertrule>
|
|
fn InsertRule(&self, rule: DOMString, index: u32, can_gc: CanGc) -> Fallible<u32> {
|
|
// TODO: this should accumulate the rule types of all ancestors.
|
|
let rule_type = self.cssrule.as_specific().ty();
|
|
let containing_rule_types = CssRuleTypes::from(rule_type);
|
|
let parse_relative_rule_type = match rule_type {
|
|
CssRuleType::Style | CssRuleType::Scope => Some(rule_type),
|
|
_ => None,
|
|
};
|
|
self.rulelist(can_gc).insert_rule(
|
|
&rule,
|
|
index,
|
|
containing_rule_types,
|
|
parse_relative_rule_type,
|
|
can_gc,
|
|
)
|
|
}
|
|
|
|
/// <https://drafts.csswg.org/cssom/#dom-cssgroupingrule-deleterule>
|
|
fn DeleteRule(&self, index: u32, can_gc: CanGc) -> ErrorResult {
|
|
self.rulelist(can_gc).remove_rule(index)
|
|
}
|
|
}
|