allow loading of builtin modules

src/builtin/functions/mod.rs

@@ -0,0 +1,60 @@
+// A reference to the parser is only necessary for some functions
+#![allow(unused_variables)]
+
+use std::{
+    collections::HashMap,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+use once_cell::sync::Lazy;
+
+use crate::{args::CallArgs, error::SassResult, parse::Parser, value::Value};
+
+#[macro_use]
+mod macros;
+
+mod color;
+mod list;
+mod map;
+mod math;
+mod meta;
+mod selector;
+mod string;
+
+pub(crate) type GlobalFunctionMap = HashMap<&'static str, Builtin>;
+
+static FUNCTION_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+// TODO: impl Fn
+#[derive(Clone)]
+pub(crate) struct Builtin(
+    pub fn(CallArgs, &mut Parser<'_>) -> SassResult<Value>,
+    usize,
+);
+
+impl Builtin {
+    pub fn new(body: fn(CallArgs, &mut Parser<'_>) -> SassResult<Value>) -> Builtin {
+        let count = FUNCTION_COUNT.fetch_add(1, Ordering::Relaxed);
+        Self(body, count)
+    }
+}
+
+impl PartialEq for Builtin {
+    fn eq(&self, other: &Self) -> bool {
+        self.1 == other.1
+    }
+}
+
+impl Eq for Builtin {}
+
+pub(crate) static GLOBAL_FUNCTIONS: Lazy<GlobalFunctionMap> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    color::declare(&mut m);
+    list::declare(&mut m);
+    map::declare(&mut m);
+    math::declare(&mut m);
+    meta::declare(&mut m);
+    selector::declare(&mut m);
+    string::declare(&mut m);
+    m
+});

src/builtin/mod.rs

@@ -1,60 +1,5 @@
-// A reference to the parser is only necessary for some functions
+mod functions;
-#![allow(unused_variables)]
+mod modules;
 
-use std::{
+pub(crate) use functions::{Builtin, GLOBAL_FUNCTIONS};
-    collections::HashMap,
+pub(crate) use modules::*;
-    sync::atomic::{AtomicUsize, Ordering},
-};
-
-use once_cell::sync::Lazy;
-
-use crate::{args::CallArgs, error::SassResult, parse::Parser, value::Value};
-
-#[macro_use]
-mod macros;
-
-mod color;
-mod list;
-mod map;
-mod math;
-mod meta;
-mod selector;
-mod string;
-
-pub(crate) type GlobalFunctionMap = HashMap<&'static str, Builtin>;
-
-static FUNCTION_COUNT: AtomicUsize = AtomicUsize::new(0);
-
-// TODO: impl Fn
-#[derive(Clone)]
-pub(crate) struct Builtin(
-    pub fn(CallArgs, &mut Parser<'_>) -> SassResult<Value>,
-    usize,
-);
-
-impl Builtin {
-    pub fn new(body: fn(CallArgs, &mut Parser<'_>) -> SassResult<Value>) -> Builtin {
-        let count = FUNCTION_COUNT.fetch_add(1, Ordering::Relaxed);
-        Self(body, count)
-    }
-}
-
-impl PartialEq for Builtin {
-    fn eq(&self, other: &Self) -> bool {
-        self.1 == other.1
-    }
-}
-
-impl Eq for Builtin {}
-
-pub(crate) static GLOBAL_FUNCTIONS: Lazy<GlobalFunctionMap> = Lazy::new(|| {
-    let mut m = HashMap::new();
-    color::declare(&mut m);
-    list::declare(&mut m);
-    map::declare(&mut m);
-    math::declare(&mut m);
-    meta::declare(&mut m);
-    selector::declare(&mut m);
-    string::declare(&mut m);
-    m
-});

src/builtin/modules/color.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/builtin/modules/list.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/builtin/modules/map.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/builtin/modules/math.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/builtin/modules/meta.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/builtin/modules/mod.rs

@@ -0,0 +1,64 @@
+use std::collections::BTreeMap;
+
+use crate::{
+    atrule::Mixin,
+    common::Identifier,
+    value::{SassFunction, Value},
+};
+
+mod color;
+mod list;
+mod map;
+mod math;
+mod meta;
+mod selector;
+mod string;
+
+#[derive(Debug, Default)]
+pub(crate) struct Module {
+    vars: BTreeMap<Identifier, Value>,
+    mixins: BTreeMap<Identifier, Mixin>,
+    functions: BTreeMap<Identifier, SassFunction>,
+}
+
+pub(crate) fn declare_module_color() -> Module {
+    let mut module = Module::default();
+    color::declare(&mut module);
+    module
+}
+
+pub(crate) fn declare_module_list() -> Module {
+    let mut module = Module::default();
+    list::declare(&mut module);
+    module
+}
+
+pub(crate) fn declare_module_map() -> Module {
+    let mut module = Module::default();
+    map::declare(&mut module);
+    module
+}
+
+pub(crate) fn declare_module_math() -> Module {
+    let mut module = Module::default();
+    math::declare(&mut module);
+    module
+}
+
+pub(crate) fn declare_module_meta() -> Module {
+    let mut module = Module::default();
+    meta::declare(&mut module);
+    module
+}
+
+pub(crate) fn declare_module_selector() -> Module {
+    let mut module = Module::default();
+    selector::declare(&mut module);
+    module
+}
+
+pub(crate) fn declare_module_string() -> Module {
+    let mut module = Module::default();
+    string::declare(&mut module);
+    module
+}

src/builtin/modules/selector.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/builtin/modules/string.rs

@@ -0,0 +1,3 @@
+use crate::builtin::Module;
+
+pub(crate) fn declare(_f: &mut Module) {}

src/parse/mod.rs

@@ -9,6 +9,7 @@ use crate::{
         media::MediaRule,
         AtRuleKind, Content, SupportsRule, UnknownAtRule,
     },
+    builtin::*,
     error::SassResult,
     scope::{Scope, Scopes},
     selector::{
@@ -87,7 +88,7 @@ pub(crate) struct Parser<'a> {
 
     pub options: &'a Options<'a>,
 
-    pub modules: &'a mut HashMap<String, Scope>,
+    pub modules: &'a mut HashMap<String, Module>,
 }
 
 impl<'a> Parser<'a> {
@@ -149,17 +150,27 @@ impl<'a> Parser<'a> {
                     }
 
                     match module.as_ref() {
-                        "sass:color" => todo!("builtin module `sass:color` not yet implemented"),
+                        "sass:color" => self
-                        "sass:list" => todo!("builtin module `sass:list` not yet implemented"),
+                            .modules
-                        "sass:map" => todo!("builtin module `sass:map` not yet implemented"),
+                            .insert("color".to_owned(), declare_module_color()),
-                        "sass:math" => todo!("builtin module `sass:math` not yet implemented"),
+                        "sass:list" => self
-                        "sass:meta" => todo!("builtin module `sass:meta` not yet implemented"),
+                            .modules
-                        "sass:selector" => {
+                            .insert("list".to_owned(), declare_module_list()),
-                            todo!("builtin module `sass:selector` not yet implemented")
+                        "sass:map" => self.modules.insert("map".to_owned(), declare_module_map()),
-                        }
+                        "sass:math" => self
-                        "sass:string" => todo!("builtin module `sass:string` not yet implemented"),
+                            .modules
+                            .insert("math".to_owned(), declare_module_math()),
+                        "sass:meta" => self
+                            .modules
+                            .insert("meta".to_owned(), declare_module_meta()),
+                        "sass:selector" => self
+                            .modules
+                            .insert("selector".to_owned(), declare_module_selector()),
+                        "sass:string" => self
+                            .modules
+                            .insert("string".to_owned(), declare_module_string()),
                         _ => todo!("@use not yet implemented"),
-                    }
+                    };
                 }
                 Some(Token { kind: '/', .. }) => {
                     self.toks.advance_cursor();