Merge pull request #299 from prettier/stricter-types

kddnewton · web-flow · commit 06023cdf6d72 · 2021-09-23T12:02:35.000-04:00
Stricter types for development
diff --git a/.prettierignore b/.prettierignore
@@ -6,5 +6,6 @@
 /yarn.lock
 /LICENSE
 
+/src/types.ts
 /test/fixture.xml
 /test/__snapshots__/*
diff --git a/bin/print.ts b/bin/print.ts
@@ -4,15 +4,14 @@ import fs from "fs";
 import prettier from "prettier";
 
 import plugin from "../src/plugin";
-import { XMLOptions } from "../src/types";
 
 const code = fs.existsSync(process.argv[2])
   ? fs.readFileSync(process.argv[2], "utf-8")
   : process.argv.slice(2).join(" ").replace(/\\n/g, "\n");
 
-const options: Partial<XMLOptions> = {
+const options = {
   parser: "xml",
-  plugins: [plugin],
+  plugins: [plugin as any as string],
   xmlWhitespaceSensitivity: "ignore"
 };
 
diff --git a/src/embed.ts b/src/embed.ts
@@ -1,8 +1,13 @@
-import { ContentCtx, ElementCstNode } from "@xml-tools/parser";
-import type { AstPath, Doc, ParserOptions, Printer } from "prettier";
 import { builders, utils } from "prettier/doc";
-
-import { XMLAst, XMLOptions } from "./types";
+import {
+  AnyNode,
+  ContentCtx,
+  Doc,
+  ElementCstNode,
+  Embed,
+  Options,
+  Path
+} from "./types";
 
 const {
   dedentToRoot,
@@ -27,11 +32,11 @@ function replaceNewlines(doc: Doc) {
 
 // Get the start and end element tags from the current node on the tree
 function getElementTags(
-  path: AstPath<XMLAst>,
-  opts: XMLOptions,
-  print: (path: AstPath<XMLAst>) => Doc
+  path: Path<ElementCstNode>,
+  opts: Options,
+  print: (path: Path<AnyNode>) => Doc
 ) {
-  const node = path.getValue() as ElementCstNode;
+  const node = path.getValue();
   const { OPEN, Name, attribute, START_CLOSE, SLASH_OPEN, END_NAME, END } =
     node.children;
 
@@ -55,7 +60,7 @@ function getElementTags(
 
 // Get the name of the parser that is represented by the given element node,
 // return null if a matching parser cannot be found
-function getParser(node: ElementCstNode, opts: ParserOptions<XMLAst>) {
+function getParser(node: ElementCstNode, opts: Options) {
   const { Name, attribute } = node.children;
   const parser = Name[0].image.toLowerCase();
 
@@ -114,7 +119,7 @@ function getSource(content: ContentCtx) {
     .join("");
 }
 
-const embed: Printer<XMLAst>["embed"] = (path, print, textToDoc, opts) => {
+const embed: Embed = (path, print, textToDoc, opts) => {
   const node = path.getValue();
 
   // If the node isn't an element node, then skip
@@ -138,14 +143,17 @@ const embed: Printer<XMLAst>["embed"] = (path, print, textToDoc, opts) => {
 
   // Get the open and close tags of this element, then return the properly
   // formatted content enclosed within them
-  const { openTag, closeTag } = getElementTags(path, opts as XMLOptions, print);
+  const nodePath = path as Path<typeof node>;
+  const { openTag, closeTag } = getElementTags(nodePath, opts, print);
 
   return group([
     openTag,
     literalline,
     dedentToRoot(
       replaceNewlines(
-        utils.stripTrailingHardline(textToDoc(getSource(content), { parser }))
+        utils.stripTrailingHardline(
+          textToDoc(getSource(content), { ...opts, parser })
+        )
       )
     ),
     hardline,
diff --git a/src/parser.ts b/src/parser.ts
@@ -1,5 +1,5 @@
-import type { Parser } from "prettier";
 import { parse as xmlToolsParse } from "@xml-tools/parser";
+import type { Parser } from "./types";
 
 const parser: Parser = {
   parse(text) {
@@ -13,16 +13,10 @@ const parser: Parser = {
   },
   astFormat: "xml",
   locStart(node) {
-    if (node.location) {
-      return node.location.startOffset;
-    }
-    return node.startOffset;
+    return node.location!.startOffset;
   },
   locEnd(node) {
-    if (node.location) {
-      return node.location.endOffset;
-    }
-    return node.endOffset;
+    return node.location!.endOffset!;
   }
 };
 
diff --git a/src/plugin.ts b/src/plugin.ts
@@ -1,12 +1,11 @@
-import type { Plugin } from "prettier";
 import prettier from "prettier";
 
-import type { XMLAst } from "./types";
+import type { Plugin } from "./types";
 import parser from "./parser";
 import printer from "./printer";
 
 // These are the extra options defined by this plugin.
-const options: Plugin<XMLAst>["options"] = {
+const options: Plugin["options"] = {
   xmlWhitespaceSensitivity: {
     type: "choice",
     category: "XML",
@@ -44,7 +43,7 @@ if (
   };
 }
 
-const plugin: Plugin<XMLAst> = {
+const plugin: Plugin = {
   languages: [
     {
       name: "XML",
diff --git a/src/printer.ts b/src/printer.ts
@@ -1,15 +1,6 @@
-import type {
-  ChardataCstNode,
-  ContentCstNode,
-  ReferenceCstNode
-} from "@xml-tools/parser";
-import type { IToken } from "chevrotain";
-import type { AstPath, Doc, Printer } from "prettier";
 import { builders } from "prettier/doc";
-
 import embed from "./embed";
-
-import { ContentCstNodeExt, XMLAst, XMLOptions } from "./types";
+import type { ContentCstNode, Doc, IToken, Path, Printer } from "./types";
 
 const { fill, group, hardline, indent, join, line, literalline, softline } =
   builders;
@@ -42,13 +33,20 @@ function isWhitespaceIgnorable(node: ContentCstNode) {
   return !CData && !reference && !hasIgnoreRanges(Comment);
 }
 
-function printIToken(path: AstPath<XMLAst>) {
-  const node = path.getValue() as any as IToken;
+type Fragment = {
+  offset: number;
+  printed: Doc;
+  startLine?: number;
+  endLine?: number;
+};
+
+function printIToken(path: Path<IToken>): Fragment {
+  const node = path.getValue();
 
   return {
     offset: node.startOffset,
-    startLine: node.startLine!,
-    endLine: node.endLine!,
+    startLine: node.startLine,
+    endLine: node.endLine,
     printed: node.image
   };
 }
@@ -59,9 +57,9 @@ function replaceNewlinesWithLiteralLines(content: string) {
     .map((value, idx) => (idx % 2 === 0 ? value : literalline));
 }
 
-const printer: Printer<XMLAst> = {
+const printer: Printer = {
   embed,
-  print(path, opts: XMLOptions, print) {
+  print(path, opts, print) {
     const node = path.getValue();
 
     switch (node.name) {
@@ -79,22 +77,25 @@ const printer: Printer<XMLAst> = {
           .map((value, index) => (index % 2 === 0 ? value : literalline));
       }
       case "content": {
-        let fragments = path.call((childrenPath) => {
-          let response: { offset: number; printed: Doc }[] = [];
-          const children =
-            childrenPath.getValue() as any as ContentCstNodeExt["children"];
+        const nodePath = path as Path<typeof node>;
+
+        let fragments = nodePath.call((childrenPath) => {
+          let response: Fragment[] = [];
+          const children = childrenPath.getValue();
 
           if (children.CData) {
-            response = response.concat(path.map(printIToken, "CData"));
+            response = response.concat(childrenPath.map(printIToken, "CData"));
           }
 
           if (children.Comment) {
-            response = response.concat(path.map(printIToken, "Comment"));
+            response = response.concat(
+              childrenPath.map(printIToken, "Comment")
+            );
           }
 
           if (children.chardata) {
             response = response.concat(
-              path.map(
+              childrenPath.map(
                 (charDataPath) => ({
                   offset: charDataPath.getValue().location!.startOffset,
                   printed: print(charDataPath)
@@ -106,7 +107,7 @@ const printer: Printer<XMLAst> = {
 
           if (children.element) {
             response = response.concat(
-              path.map(
+              childrenPath.map(
                 (elementPath) => ({
                   offset: elementPath.getValue().location!.startOffset,
                   printed: print(elementPath)
@@ -118,15 +119,14 @@ const printer: Printer<XMLAst> = {
 
           if (children.PROCESSING_INSTRUCTION) {
             response = response.concat(
-              path.map(printIToken, "PROCESSING_INSTRUCTION")
+              childrenPath.map(printIToken, "PROCESSING_INSTRUCTION")
             );
           }
 
           if (children.reference) {
             response = response.concat(
-              path.map((referencePath) => {
-                const referenceNode =
-                  referencePath.getValue() as any as ReferenceCstNode;
+              childrenPath.map((referencePath) => {
+                const referenceNode = referencePath.getValue();
 
                 return {
                   offset: referenceNode.location!.startOffset,
@@ -199,17 +199,17 @@ const printer: Printer<XMLAst> = {
       }
       case "document": {
         const { docTypeDecl, element, misc, prolog } = node.children;
-        const parts: { offset: number; printed: Doc }[] = [];
+        const fragments: Fragment[] = [];
 
         if (docTypeDecl) {
-          parts.push({
+          fragments.push({
             offset: docTypeDecl[0].location!.startOffset,
             printed: path.call(print, "children", "docTypeDecl", 0)
           });
         }
 
         if (prolog) {
-          parts.push({
+          fragments.push({
             offset: prolog[0].location!.startOffset,
             printed: path.call(print, "children", "prolog", 0)
           });
@@ -218,12 +218,12 @@ const printer: Printer<XMLAst> = {
         if (misc) {
           misc.forEach((node) => {
             if (node.children.PROCESSING_INSTRUCTION) {
-              parts.push({
+              fragments.push({
                 offset: node.location!.startOffset,
                 printed: node.children.PROCESSING_INSTRUCTION[0].image
               });
             } else if (node.children.Comment) {
-              parts.push({
+              fragments.push({
                 offset: node.location!.startOffset,
                 printed: node.children.Comment[0].image
               });
@@ -232,18 +232,18 @@ const printer: Printer<XMLAst> = {
         }
 
         if (element) {
-          parts.push({
+          fragments.push({
             offset: element[0].location!.startOffset,
             printed: path.call(print, "children", "element", 0)
           });
         }
 
-        parts.sort((left, right) => left.offset - right.offset);
+        fragments.sort((left, right) => left.offset - right.offset);
 
         return [
           join(
             hardline,
-            parts.map(({ printed }) => printed)
+            fragments.map(({ printed }) => printed)
           ),
           hardline
         ];
@@ -297,24 +297,22 @@ const printer: Printer<XMLAst> = {
           opts.xmlWhitespaceSensitivity === "ignore" &&
           isWhitespaceIgnorable(content[0])
         ) {
-          const fragments = path.call(
+          const nodePath = path as Path<typeof node>;
+
+          const fragments = nodePath.call(
             (childrenPath) => {
-              const children =
-                childrenPath.getValue() as any as ContentCstNodeExt["children"];
-              let response: {
-                offset: number;
-                startLine: number;
-                endLine: number;
-                printed: Doc;
-              }[] = [];
+              const children = childrenPath.getValue();
+              let response: Fragment[] = [];
 
               if (children.Comment) {
-                response = response.concat(path.map(printIToken, "Comment"));
+                response = response.concat(
+                  childrenPath.map(printIToken, "Comment")
+                );
               }
 
               if (children.chardata) {
-                path.each((charDataPath) => {
-                  const chardata = charDataPath.getValue() as ChardataCstNode;
+                childrenPath.each((charDataPath) => {
+                  const chardata = charDataPath.getValue();
                   if (!chardata.children.TEXT) {
                     return;
                   }
@@ -348,7 +346,7 @@ const printer: Printer<XMLAst> = {
 
               if (children.element) {
                 response = response.concat(
-                  path.map((elementPath) => {
+                  childrenPath.map((elementPath) => {
                     const location = elementPath.getValue().location!;
 
                     return {
@@ -363,7 +361,7 @@ const printer: Printer<XMLAst> = {
 
               if (children.PROCESSING_INSTRUCTION) {
                 response = response.concat(
-                  path.map(printIToken, "PROCESSING_INSTRUCTION")
+                  childrenPath.map(printIToken, "PROCESSING_INSTRUCTION")
                 );
               }
 
@@ -398,17 +396,17 @@ const printer: Printer<XMLAst> = {
           }
 
           const docs: Doc[] = [];
-          let lastLine: number = fragments[0].startLine;
+          let lastLine: number = fragments[0].startLine!;
 
           fragments.forEach((node) => {
-            if (node.startLine - lastLine >= 2) {
+            if (node.startLine! - lastLine >= 2) {
               docs.push(hardline, hardline);
             } else {
               docs.push(hardline);
             }
 
             docs.push(node.printed);
-            lastLine = node.endLine;
+            lastLine = node.endLine!;
           });
 
           return group([openTag, indent(docs), hardline, closeTag]);
diff --git a/src/types.ts b/src/types.ts
diff --git a/test/format.test.ts b/test/format.test.ts
