reduce size of Namespace and Toplevel

src/output.rs

@@ -12,23 +12,20 @@ use crate::{
     style::Style,
 };
 
+#[derive(Debug, Clone)]
+struct ToplevelUnknownAtRule {
+    name: String,
+    params: String,
+    body: Vec<Stmt>,
+}
+
 #[derive(Debug, Clone)]
 enum Toplevel {
     RuleSet(Selector, Vec<BlockEntry>),
     MultilineComment(String),
-    UnknownAtRule {
+    UnknownAtRule(Box<ToplevelUnknownAtRule>),
-        name: String,
+    Media { query: String, body: Vec<Stmt> },
-        params: String,
+    Supports { params: String, body: Vec<Stmt> },
-        body: Vec<Stmt>,
-    },
-    Media {
-        query: String,
-        body: Vec<Stmt>,
-    },
-    Supports {
-        params: String,
-        body: Vec<Stmt>,
-    },
     Newline,
     Style(Style),
 }
@@ -113,7 +110,11 @@ impl Css {
                             let UnknownAtRule {
                                 params, body, name, ..
                             } = *u;
-                            vals.push(Toplevel::UnknownAtRule { params, body, name })
+                            vals.push(Toplevel::UnknownAtRule(Box::new(ToplevelUnknownAtRule {
+                                params,
+                                body,
+                                name,
+                            })))
                         }
                         Stmt::Return(..) => unreachable!(),
                         Stmt::AtRoot { body } => body
@@ -138,7 +139,11 @@ impl Css {
                 let UnknownAtRule {
                     params, body, name, ..
                 } = *u;
-                vec![Toplevel::UnknownAtRule { params, name, body }]
+                vec![Toplevel::UnknownAtRule(Box::new(ToplevelUnknownAtRule {
+                    params,
+                    name,
+                    body,
+                }))]
             }
             Stmt::Return(..) => unreachable!("@return: {:?}", stmt),
             Stmt::AtRoot { .. } => unreachable!("@at-root: {:?}", stmt),
@@ -206,7 +211,8 @@ impl Css {
                     has_written = true;
                     writeln!(buf, "{}/*{}*/", padding, s)?;
                 }
-                Toplevel::UnknownAtRule { params, name, body } => {
+                Toplevel::UnknownAtRule(u) => {
+                    let ToplevelUnknownAtRule { params, name, body } = *u;
                     if should_emit_newline {
                         should_emit_newline = false;
                         writeln!(buf)?;

src/selector/attribute.rs

@@ -84,7 +84,7 @@ fn attribute_name(parser: &mut Parser<'_>, start: Span) -> SassResult<QualifiedN
     let ident = parser.parse_identifier()?.node;
     Ok(QualifiedName {
         ident,
-        namespace: Namespace::Other(name_or_namespace.node),
+        namespace: Namespace::Other(name_or_namespace.node.into_boxed_str()),
     })
 }
 

src/selector/common.rs

@@ -10,7 +10,7 @@ use std::fmt;
 pub(crate) enum Namespace {
     Empty,
     Asterisk,
-    Other(String),
+    Other(Box<str>),
     None,
 }
 

src/selector/parse.rs

@@ -427,11 +427,11 @@ impl<'a, 'b> SelectorParser<'a, 'b> {
                 self.parser.toks.next();
                 if let Some(Token { kind: '*', .. }) = self.parser.toks.peek() {
                     self.parser.toks.next();
-                    SimpleSelector::Universal(Namespace::Other(name_or_namespace))
+                    SimpleSelector::Universal(Namespace::Other(name_or_namespace.into_boxed_str()))
                 } else {
                     SimpleSelector::Type(QualifiedName {
                         ident: self.parser.parse_identifier()?.node,
-                        namespace: Namespace::Other(name_or_namespace),
+                        namespace: Namespace::Other(name_or_namespace.into_boxed_str()),
                     })
                 }
             }