shadowfacts/grass
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Keep parser context with bitflags

Browse Source
This commit is contained in:
Ivan Tham 2020-07-05 19:16:44 +08:00 committed by Connor Skees
parent 85a5b005cb
commit 85ec26001a
11 changed files with 57 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -60,6 +60,7 @@ codemap = "0.1.3"
peekmore = "0.5.2"
wasm-bindgen = { version = "0.2.63", optional = true }
beef = "0.4.4"
bitflags = "1.2.1"
# criterion is not a dev-dependency because it makes tests take too
# long to compile, and you cannot make dev-dependencies optional
criterion = { version = "0.3.2", optional = true }

4
src/builtin/meta.rs
View File

@ -6,7 +6,7 @@ use crate::{
args::CallArgs,
common::QuoteKind,
error::SassResult,
parse::Parser,
parse::{Flags, Parser},
unit::Unit,
value::{SassFunction, Value},
};
@ -232,7 +232,7 @@ fn call(mut args: CallArgs, parser: &mut Parser<'_>) -> SassResult<Value> {
#[allow(clippy::needless_pass_by_value)]
fn content_exists(args: CallArgs, parser: &mut Parser<'_>) -> SassResult<Value> {
args.max_args(0)?;
if !parser.in_mixin {
if !parser.flags.contains(Flags::IN_MIXIN) {
return Err((
"content-exists() may only be called within a mixin.",
parser.span_before,

17
src/lib.rs
View File

@ -94,7 +94,7 @@ pub(crate) use crate::token::Token;
use crate::{
lexer::Lexer,
output::Css,
parse::{common::NeverEmptyVec, Parser},
parse::{common::NeverEmptyVec, Flags, Parser},
scope::Scope,
selector::{Extender, Selector},
};
@ -149,13 +149,10 @@ pub fn from_path(p: &str) -> Result<String> {
super_selectors: &mut NeverEmptyVec::new(Selector::new(empty_span)),
span_before: empty_span,
content: &mut Vec::new(),
in_mixin: false,
in_function: false,
in_control_flow: false,
flags: Flags::empty(),
at_root: true,
at_root_has_selector: false,
extender: &mut Extender::new(empty_span),
in_keyframes: false,
}
.parse()
.map_err(|e| raw_to_parse_error(&map, *e))?;
@ -194,13 +191,10 @@ pub fn from_string(p: String) -> Result<String> {
super_selectors: &mut NeverEmptyVec::new(Selector::new(empty_span)),
span_before: empty_span,
content: &mut Vec::new(),
in_mixin: false,
in_function: false,
in_control_flow: false,
flags: Flags::empty(),
at_root: true,
at_root_has_selector: false,
extender: &mut Extender::new(empty_span),
in_keyframes: false,
}
.parse()
.map_err(|e| raw_to_parse_error(&map, *e))?;
@ -230,13 +224,10 @@ pub fn from_string(p: String) -> std::result::Result<String, JsValue> {
super_selectors: &mut NeverEmptyVec::new(Selector::new(empty_span)),
span_before: empty_span,
content: &mut Vec::new(),
in_mixin: false,
in_function: false,
in_control_flow: false,
flags: Flags::empty(),
at_root: true,
at_root_has_selector: false,
extender: &mut Extender::new(empty_span),
in_keyframes: false,
}
.parse()
.map_err(|e| raw_to_parse_error(&map, *e).to_string())?;

11
src/parse/function.rs
View File

@ -11,7 +11,7 @@ use crate::{
Token,
};
use super::{NeverEmptyVec, Parser, Stmt};
use super::{Flags, NeverEmptyVec, Parser, Stmt};
/// Names that functions are not allowed to have
const FORBIDDEN_IDENTIFIERS: [&str; 7] =
@ -22,11 +22,11 @@ impl<'a> Parser<'a> {
self.whitespace_or_comment();
let Spanned { node: name, span } = self.parse_identifier()?;
if self.in_mixin {
if self.flags.contains(Flags::IN_MIXIN) {
return Err(("Mixins may not contain function declarations.", span).into());
}
if self.in_control_flow {
if self.flags.contains(Flags::IN_CONTROL_FLOW) {
return Err(("Functions may not be declared in control directives.", span).into());
}
@ -88,13 +88,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: true,
in_control_flow: self.in_control_flow,
flags: self.flags | Flags::IN_FUNCTION,
at_root: false,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?;

5
src/parse/import.rs
View File

@ -83,13 +83,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: file.span.subspan(0, 0),
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse();
}

12
src/parse/keyframes.rs
View File

@ -10,7 +10,7 @@ use crate::{
Token,
};
use super::Parser;
use super::{Flags, Parser};
impl fmt::Display for KeyframesSelector {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@ -160,13 +160,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
})
.parse_keyframes_selector()?;
@ -192,11 +189,8 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags | Flags::IN_KEYFRAMES,
at_root: false,
in_keyframes: true,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
}

14
src/parse/mixin.rs
View File

@ -10,7 +10,7 @@ use crate::{
Token,
};
use super::{NeverEmptyVec, Parser, Stmt};
use super::{Flags, NeverEmptyVec, Parser, Stmt};
impl<'a> Parser<'a> {
pub(super) fn parse_mixin(&mut self) -> SassResult<()> {
@ -127,14 +127,11 @@ impl<'a> Parser<'a> {
global_scope: self.global_scope,
super_selectors: self.super_selectors,
span_before: self.span_before,
in_mixin: true,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags | Flags::IN_MIXIN,
content: self.content,
at_root: false,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?;
@ -144,7 +141,7 @@ impl<'a> Parser<'a> {
}
pub(super) fn parse_content_rule(&mut self) -> SassResult<Vec<Stmt>> {
if self.in_mixin {
if self.flags.contains(Flags::IN_MIXIN) {
let mut scope = self
.content
.last()
@ -175,14 +172,11 @@ impl<'a> Parser<'a> {
global_scope: self.global_scope,
super_selectors: self.super_selectors,
span_before: self.span_before,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
content: self.content,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?
} else {

98
src/parse/mod.rs
View File

@ -66,11 +66,21 @@ pub(crate) enum Stmt {
KeyframesRuleSet(Box<KeyframesRuleSet>),
}
bitflags::bitflags! {
// todo: try to remove the flag IN_CONTROL_FLOW
/// Flags to indicate the context during parsing.
pub struct Flags: u8 {
const IN_MIXIN = 1;
const IN_FUNCTION = 1 << 1;
const IN_CONTROL_FLOW = 1 << 2;
const IN_KEYFRAMES = 1 << 3;
}
}
/// We could use a generic for the toks, but it makes the API
/// much simpler to work with if it isn't generic. The performance
/// hit (if there is one) is not important for now.
// todo: refactor `in_mixin`, in_function`, and `at_root` into state machine enum
#[allow(clippy::struct_excessive_bools)]
// todo: merge at_root and at_root_has_selector into an enum
pub(crate) struct Parser<'a> {
pub toks: &'a mut PeekMoreIterator<IntoIter<Token>>,
pub map: &'a mut CodeMap,
@ -80,10 +90,7 @@ pub(crate) struct Parser<'a> {
pub super_selectors: &'a mut NeverEmptyVec<Selector>,
pub span_before: Span,
pub content: &'a mut Vec<Content>,
pub in_mixin: bool,
pub in_function: bool,
pub in_control_flow: bool,
pub in_keyframes: bool,
pub flags: Flags,
/// Whether this parser is at the root of the document
/// E.g. not inside a style, mixin, or function
pub at_root: bool,
@ -98,7 +105,7 @@ impl<'a> Parser<'a> {
let mut stmts = Vec::new();
while self.toks.peek().is_some() {
stmts.append(&mut self.parse_stmt()?);
if self.in_function && !stmts.is_empty() {
if self.flags.contains(Flags::IN_FUNCTION) && !stmts.is_empty() {
return Ok(stmts);
}
self.at_root = true;
@ -109,7 +116,7 @@ impl<'a> Parser<'a> {
fn parse_stmt(&mut self) -> SassResult<Vec<Stmt>> {
let mut stmts = Vec::new();
while let Some(Token { kind, pos }) = self.toks.peek() {
if self.in_function && !stmts.is_empty() {
if self.flags.contains(Flags::IN_FUNCTION) && !stmts.is_empty() {
return Ok(stmts);
}
self.span_before = *pos;
@ -125,7 +132,7 @@ impl<'a> Parser<'a> {
AtRuleKind::Include => stmts.append(&mut self.parse_include()?),
AtRuleKind::Function => self.parse_function()?,
AtRuleKind::Return => {
if self.in_function {
if self.flags.contains(Flags::IN_FUNCTION) {
return Ok(vec![Stmt::Return(self.parse_return()?)]);
} else {
return Err((
@ -235,7 +242,7 @@ impl<'a> Parser<'a> {
// dart-sass seems to special-case the error message here?
'!' | '{' => return Err(("expected \"}\".", *pos).into()),
_ => {
if self.in_keyframes {
if self.flags.contains(Flags::IN_KEYFRAMES) {
match self.is_selector_or_style()? {
SelectorOrStyle::Style(property, value) => {
if let Some(value) = value {
@ -375,13 +382,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
},
allows_parent,
true,
@ -607,13 +611,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse();
}
@ -630,13 +631,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()
}
@ -764,7 +762,7 @@ impl<'a> Parser<'a> {
span: var.span,
},
);
if self.in_function {
if self.flags.contains(Flags::IN_FUNCTION) {
let these_stmts = Parser {
toks: &mut body.clone().into_iter().peekmore(),
map: self.map,
@ -774,13 +772,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?;
if !these_stmts.is_empty() {
@ -797,13 +792,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?,
);
@ -838,7 +830,7 @@ impl<'a> Parser<'a> {
let mut val = self.parse_value_from_vec(cond.clone())?;
self.scopes.push(self.scopes.last().clone());
while val.node.is_true() {
if self.in_function {
if self.flags.contains(Flags::IN_FUNCTION) {
let these_stmts = Parser {
toks: &mut body.clone().into_iter().peekmore(),
map: self.map,
@ -848,13 +840,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?;
if !these_stmts.is_empty() {
@ -871,13 +860,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?,
);
@ -972,7 +958,7 @@ impl<'a> Parser<'a> {
}
}
if self.in_function {
if self.flags.contains(Flags::IN_FUNCTION) {
let these_stmts = Parser {
toks: &mut body.clone().into_iter().peekmore(),
map: self.map,
@ -982,13 +968,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?;
if !these_stmts.is_empty() {
@ -1005,13 +988,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: true,
flags: self.flags | Flags::IN_CONTROL_FLOW,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?,
);
@ -1102,13 +1082,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: false,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse_stmt()?;
@ -1171,13 +1148,10 @@ impl<'a> Parser<'a> {
super_selectors: &mut NeverEmptyVec::new(at_rule_selector.clone()),
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: true,
at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?
.into_iter()
@ -1213,13 +1187,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse_selector(false, true, String::new())?;
@ -1292,13 +1263,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: false,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse()?;

5
src/parse/value/parse.rs
View File

@ -188,13 +188,10 @@ impl<'a> Parser<'a> {
super_selectors: self.super_selectors,
span_before: self.span_before,
content: self.content,
in_mixin: self.in_mixin,
in_function: self.in_function,
in_control_flow: self.in_control_flow,
flags: self.flags,
at_root: self.at_root,
at_root_has_selector: self.at_root_has_selector,
extender: self.extender,
in_keyframes: self.in_keyframes,
}
.parse_value()
}

6
src/parse/variable.rs
View File

@ -11,7 +11,7 @@ use crate::{
Token,
};
use super::Parser;
use super::{Flags, Parser};
#[derive(Debug)]
struct VariableValue {
@ -46,7 +46,7 @@ impl<'a> Parser<'a> {
}
if value.default {
if self.at_root && !self.in_control_flow {
if self.at_root && !self.flags.contains(Flags::IN_CONTROL_FLOW) {
if !self.global_scope.var_exists_no_global(&ident) {
self.global_scope.insert_var(ident, value.value);
}
@ -60,7 +60,7 @@ impl<'a> Parser<'a> {
}
}
} else if self.at_root {
if self.in_control_flow {
if self.flags.contains(Flags::IN_CONTROL_FLOW) {
if self.global_scope.var_exists_no_global(&ident) {
self.global_scope.insert_var(ident, value.value);
} else {

5
src/value/mod.rs
View File

@ -335,13 +335,10 @@ impl Value {
super_selectors: parser.super_selectors,
span_before: parser.span_before,
content: parser.content,
in_mixin: parser.in_mixin,
in_function: parser.in_function,
in_control_flow: parser.in_control_flow,
flags: parser.flags,
at_root: parser.at_root,
at_root_has_selector: parser.at_root_has_selector,
extender: parser.extender,
in_keyframes: parser.in_keyframes,
}
.parse_selector(allows_parent, true, String::new())
}