[WIP] Replace postcss-scss with sass-parser

package.json

@@ -96,6 +96,7 @@
     "remark-footnotes": "2.0.0",
     "remark-math": "3.0.1",
     "remark-parse": "8.0.3",
+    "sass-parser": "0.4.28",
     "sdbm": "3.0.0",
     "search-closest": "1.1.0",
     "smol-toml": "1.4.2",

src/language-sassparser/embed.js

@@ -0,0 +1,18 @@
+import { hardline } from "../document/builders.js";
+import printFrontMatter from "../utils/front-matter/print.js";
+
+function embed(path) {
+  const { node } = path;
+
+  if (node.type === "front-matter") {
+    return async (textToDoc) => {
+      const doc = await printFrontMatter(node, textToDoc);
+      return doc ? [doc, hardline] : undefined;
+    };
+  }
+}
+
+// `front-matter` only available on `root`
+embed.getVisitorKeys = (node) => (node.type === "root" ? ["frontMatter"] : []);
+
+export default embed;

src/language-sassparser/get-visitor-keys.js

@@ -0,0 +1,6 @@
+import createGetVisitorKeys from "../utils/create-get-visitor-keys.js";
+import visitorKeys from "./visitor-keys.js";
+
+const getVisitorKeys = createGetVisitorKeys(visitorKeys, "sassType");
+
+export default getVisitorKeys;

src/language-sassparser/index.js

@@ -0,0 +1,8 @@
+import printer from "./printer-postcss.js";
+
+export const printers = {
+  postcss: printer,
+};
+export { default as languages } from "./languages.evaluate.js";
+export { default as options } from "./options.js";
+export * as parsers from "./parser-postcss.js";

src/language-sassparser/languages.evaluate.js

@@ -0,0 +1,12 @@
+import * as linguistLanguages from "linguist-languages";
+import createLanguage from "../utils/create-language.js";
+
+const languages = [
+  createLanguage(linguistLanguages.SCSS, (data) => ({
+    parsers: ["sassparser"],
+    vscodeLanguageIds: ["scss"],
+    extensions: [...data.extensions, ".sassparser"],
+  })),
+];
+
+export default languages;

src/language-sassparser/loc.js

@@ -0,0 +1,77 @@
+import isNonEmptyArray from "../utils/is-non-empty-array.js";
+import lineColumnToIndex from "../utils/line-column-to-index.js";
+import { skipEverythingButNewLine } from "../utils/skip.js";
+
+function calculateLocStart(node, text) {
+  // `postcss>=8`
+  if (typeof node.source?.start?.offset === "number") {
+    return node.source.start.offset;
+  }
+
+  if (node.source?.start) {
+    return lineColumnToIndex(node.source.start, text);
+  }
+
+  /* c8 ignore next */
+  throw Object.assign(new Error("Can not locate node."), { node });
+}
+
+function calculateLocEnd(node, text) {
+  if (node.sassType === "sass-comment") {
+    return skipEverythingButNewLine(text, node.source.startOffset);
+  }
+
+  // `postcss>=8`
+  if (typeof node.source?.end?.offset === "number") {
+    return node.source.end.offset;
+  }
+
+  if (node.source) {
+    if (node.source.end) {
+      const index = lineColumnToIndex(node.source.end, text);
+      return index;
+    }
+
+    if (isNonEmptyArray(node.nodes)) {
+      return calculateLocEnd(node.nodes.at(-1), text);
+    }
+  }
+
+  return null;
+}
+
+function calculateLoc(node, text) {
+  // TODO: "configuration" nodes do not have `source.span` implemented yet
+  if (node.sassType === "configuration") {
+    return;
+  }
+
+  if (node.source) {
+    node.source.startOffset = calculateLocStart(node, text);
+    node.source.endOffset = calculateLocEnd(node, text);
+  }
+
+  for (const key in node) {
+    const child = node[key];
+
+    if (
+      ["parent", "source"].includes(key) ||
+      !child ||
+      typeof child !== "object"
+    ) {
+      continue;
+    }
+
+    calculateLoc(child, text);
+  }
+}
+
+function locStart(node) {
+  return node.source?.startOffset;
+}
+
+function locEnd(node) {
+  return node.source?.endOffset;
+}
+
+export { calculateLoc, locEnd, locStart };

src/language-sassparser/options.js

@@ -0,0 +1,8 @@
+import commonOptions from "../common/common-options.evaluate.js";
+
+// format based on https://github.com/prettier/prettier/blob/main/src/main/core-options.evaluate.js
+const options = {
+  singleQuote: commonOptions.singleQuote,
+};
+
+export default options;

src/language-sassparser/parser-postcss.js

@@ -0,0 +1,63 @@
+import { scss as postcssScssParse } from "sass-parser";
+import createError from "../common/parser-create-error.js";
+import parseFrontMatter from "../utils/front-matter/parse.js";
+import { calculateLoc, locEnd, locStart } from "./loc.js";
+import { hasIgnorePragma, hasPragma } from "./pragma.js";
+
+function parseWithParser(parse, text, options) {
+  const parsed = parseFrontMatter(text);
+  const { frontMatter } = parsed;
+  text = parsed.content;
+
+  let result;
+
+  try {
+    result = parse(text, {
+      // Prevent file access https://github.com/postcss/postcss/blob/4f4e2932fc97e2c117e1a4b15f0272ed551ed59d/lib/previous-map.js#L18
+      map: false,
+    });
+  } catch (/** @type {any} */ error) {
+    const { name, reason, line, column } = error;
+    /* c8 ignore 3 */
+    if (typeof line !== "number") {
+      throw error;
+    }
+
+    throw createError(`${name}: ${reason}`, {
+      loc: { start: { line, column } },
+      cause: error,
+    });
+  }
+
+  options.originalText = text;
+
+  calculateLoc(result, text);
+
+  if (frontMatter) {
+    frontMatter.source = {
+      startOffset: 0,
+      endOffset: frontMatter.raw.length,
+    };
+    result.frontMatter = frontMatter;
+  }
+
+  return result;
+}
+
+function parseScss(text, options = {}) {
+  return parseWithParser(
+    (text, opts) => postcssScssParse.parse(text, opts),
+    text,
+    options,
+  );
+}
+
+const postCssParser = {
+  astFormat: "postcss",
+  hasPragma,
+  hasIgnorePragma,
+  locStart,
+  locEnd,
+};
+
+export const sassparser = { ...postCssParser, parse: parseScss };

src/language-sassparser/pragma.js

@@ -0,0 +1,23 @@
+import {
+  hasIgnorePragma as jsHasIgnorePragma,
+  hasPragma as jsHasPragma,
+  insertPragma as jsInsertPragma,
+} from "../language-js/pragma.js";
+import parseFrontMatter from "../utils/front-matter/parse.js";
+
+function hasPragma(text) {
+  return jsHasPragma(parseFrontMatter(text).content);
+}
+
+function hasIgnorePragma(text) {
+  return jsHasIgnorePragma(parseFrontMatter(text).content);
+}
+
+function insertPragma(text) {
+  const { frontMatter, content } = parseFrontMatter(text);
+  return (
+    (frontMatter ? frontMatter.raw + "\n\n" : "") + jsInsertPragma(content)
+  );
+}
+
+export { hasIgnorePragma, hasPragma, insertPragma };

src/language-sassparser/print/css-units.evaluate.js

@@ -0,0 +1,5 @@
+import cssUnits from "css-units-list";
+
+const CSS_UNITS = new Map(cssUnits.map((unit) => [unit.toLowerCase(), unit]));
+
+export default CSS_UNITS;

src/language-sassparser/print/misc.js

@@ -0,0 +1,45 @@
+import { ifBreak } from "../../document/builders.js";
+import printNumber from "../../utils/print-number.js";
+import { hasComma, isVarFunctionNode } from "../utils/index.js";
+import CSS_UNITS from "./css-units.evaluate.js";
+
+function printUnit(unit) {
+  const lowercased = unit.toLowerCase();
+  return CSS_UNITS.has(lowercased) ? CSS_UNITS.get(lowercased) : unit;
+}
+
+function printCssNumber(rawNumber) {
+  return (
+    printNumber(rawNumber)
+      // Remove trailing `.0`.
+      .replace(/\.0(?=$|e)/u, "")
+  );
+}
+
+function shouldPrintTrailingComma(options) {
+  return options.trailingComma === "es5" || options.trailingComma === "all";
+}
+
+function printTrailingComma(path, options) {
+  if (isVarFunctionNode(path.grandparent) && hasComma(path, options)) {
+    return ",";
+  }
+  if (
+    path.node.type !== "comment" &&
+    shouldPrintTrailingComma(options) &&
+    path.callParent(
+      () => path.node.sassType === "map" || path.node.sassType === "list",
+    )
+  ) {
+    return ifBreak(",");
+  }
+
+  return "";
+}
+
+export {
+  printCssNumber,
+  printTrailingComma,
+  printUnit,
+  shouldPrintTrailingComma,
+};

src/language-sassparser/print/sequence.js

@@ -0,0 +1,50 @@
+import { hardline, line } from "../../document/builders.js";
+import isFrontMatter from "../../utils/front-matter/is-front-matter.js";
+import hasNewline from "../../utils/has-newline.js";
+import isNextLineEmpty from "../../utils/is-next-line-empty.js";
+import { locEnd, locStart } from "../loc.js";
+
+function printSequence(path, options, print) {
+  const parts = [];
+  path.each(() => {
+    const { node, previous } = path;
+    if (
+      previous?.type === "comment" &&
+      previous.text.trim() === "prettier-ignore"
+    ) {
+      parts.push(options.originalText.slice(locStart(node), locEnd(node)));
+    } else {
+      parts.push(print());
+    }
+
+    if (path.isLast) {
+      return;
+    }
+
+    const { next } = path;
+    if (
+      (next.type === "comment" &&
+        !hasNewline(options.originalText, locStart(next), {
+          backwards: true,
+        }) &&
+        !isFrontMatter(node)) ||
+      (next.type === "atrule" &&
+        next.name === "else" &&
+        node.type !== "comment")
+    ) {
+      parts.push(" ");
+    } else {
+      parts.push(options.__isHTMLStyleAttribute ? line : hardline);
+      if (
+        isNextLineEmpty(options.originalText, locEnd(node)) &&
+        !isFrontMatter(node)
+      ) {
+        parts.push(hardline);
+      }
+    }
+  }, "nodes");
+
+  return parts;
+}
+
+export default printSequence;