Flatten "size" ParseNode and also simplify its uses. (#1554)

src/Parser.js

@@ -793,11 +793,8 @@ export default class Parser {
         return newArgument({
             type: "size",
             mode: this.mode,
-            value: {
-                type: "size",
-                value: data,
-                isBlank: isBlank,
-            },
+            value: data,
+            isBlank,
         }, res);
     }
 

src/environments/array.js

@@ -16,6 +16,7 @@ import type Parser from "../Parser";
 import type {ParseNode, AnyParseNode} from "../parseNode";
 import type {StyleStr} from "../types";
 import type {HtmlBuilder, MathMLBuilder} from "../defineFunction";
+import type {Measurement} from "../units";
 
 // Data stored in the ParseNode associated with the environment.
 type AlignSpec = { type: "separator", separator: string } | {
@@ -32,7 +33,7 @@ export type ArrayEnvNodeData = {|
     cols?: AlignSpec[],
     arraystretch: number,
     body: AnyParseNode[][], // List of rows in the (2D) array.
-    rowGaps: (?ParseNode<"size">)[],
+    rowGaps: (?Measurement)[],
     hLinesBeforeRow: Array<boolean[]>,
 |};
 // Same as above but with some fields not yet filled.
@@ -44,7 +45,7 @@ type ArrayEnvNodeDataIncomplete = {|
     // Before these fields are filled.
     arraystretch?: number,
     body?: AnyParseNode[][],
-    rowGaps?: (?ParseNode<"size">)[],
+    rowGaps?: (?Measurement)[],
     hLinesBeforeRow?: Array<boolean[]>,
 |};
 
@@ -241,7 +242,7 @@ const htmlBuilder: HtmlBuilder<"array"> = function(group, options) {
         const rowGap = group.value.rowGaps[r];
         let gap = 0;
         if (rowGap) {
-            gap = calculateSize(rowGap.value.value, options);
+            gap = calculateSize(rowGap, options);
             if (gap > 0) { // \@argarraycr
                 gap += arstrutDepth;
                 if (depth < gap) {

src/functions/cr.js

@@ -23,7 +23,7 @@ defineFunction({
         allowedInText: true,
     },
 
-    handler: ({parser, funcName}, args, optArgs) => {
+    handler({parser, funcName}, args, optArgs) {
         const size = optArgs[0];
         const newRow = (funcName === "\\cr");
         let newLine = false;
@@ -42,14 +42,14 @@ defineFunction({
             mode: parser.mode,
             newLine,
             newRow,
-            size: size && assertNodeType(size, "size"),
+            size: size && assertNodeType(size, "size").value,
         };
     },
 
     // The following builders are called only at the top level,
     // not within tabular/array environments.
 
-    htmlBuilder: (group, options) => {
+    htmlBuilder(group, options) {
         if (group.newRow) {
             throw new ParseError(
                 "\\cr valid only within a tabular/array environment");
@@ -59,19 +59,19 @@ defineFunction({
             span.classes.push("newline");
             if (group.size) {
                 span.style.marginTop =
-                    calculateSize(group.size.value.value, options) + "em";
+                    calculateSize(group.size, options) + "em";
             }
         }
         return span;
     },
 
-    mathmlBuilder: (group, options) => {
+    mathmlBuilder(group, options) {
         const node = new mathMLTree.MathNode("mspace");
         if (group.newLine) {
             node.setAttribute("linebreak", "newline");
             if (group.size) {
                 node.setAttribute("height",
-                    calculateSize(group.size.value.value, options) + "em");
+                    calculateSize(group.size, options) + "em");
             }
         }
         return node;

src/functions/genfrac.js

@@ -5,6 +5,7 @@ import delimiter from "../delimiter";
 import mathMLTree from "../mathMLTree";
 import Style from "../Style";
 import {assertNodeType, assertAtomFamily, checkNodeType} from "../parseNode";
+import {assert} from "../utils";
 
 import * as html from "../buildHTML";
 import * as mml from "../buildMathML";
@@ -357,7 +358,7 @@ defineFunction({
         greediness: 6,
         argTypes: ["math", "math", "size", "text", "math", "math"],
     },
-    handler: ({parser}, args) => {
+    handler({parser}, args) {
         const numer = args[4];
         const denom = args[5];
 
@@ -381,13 +382,13 @@ defineFunction({
         const barNode = assertNodeType(args[2], "size");
         let hasBarLine;
         let barSize = null;
-        if (barNode.value.isBlank) {
+        if (barNode.isBlank) {
             // \genfrac acts differently than \above.
             // \genfrac treats an empty size group as a signal to use a
             // standard bar size. \above would see size = 0 and omit the bar.
             hasBarLine = true;
         } else {
-            barSize = barNode.value.value;
+            barSize = barNode.value;
             hasBarLine = barSize.number > 0;
         }
 
@@ -432,12 +433,11 @@ defineFunction({
         infix: true,
     },
     handler({parser, funcName, token}, args) {
-        const sizeNode = assertNodeType(args[0], "size");
         return {
             type: "infix",
             mode: parser.mode,
             replaceWith: "\\\\abovefrac",
-            sizeNode,
+            size: assertNodeType(args[0], "size").value,
             token,
         };
     },
@@ -452,11 +452,9 @@ defineFunction({
     },
     handler: ({parser, funcName}, args) => {
         const numer = args[0];
-        const infixNode = assertNodeType(args[1], "infix");
-        const sizeNode = assertNodeType(infixNode.sizeNode, "size");
+        const barSize = assert(assertNodeType(args[1], "infix").size);
         const denom = args[2];
 
-        const barSize = sizeNode.value.value;
         const hasBarLine = barSize.number > 0;
         return {
             type: "genfrac",

src/functions/kern.js

@@ -17,16 +17,16 @@ defineFunction({
         argTypes: ["size"],
         allowedInText: true,
     },
-    handler: ({parser, funcName}, args) => {
+    handler({parser, funcName}, args) {
         const size = assertNodeType(args[0], "size");
         if (parser.settings.strict) {
             const mathFunction = (funcName[1] === 'm');  // \mkern, \mskip
-            const muUnit = (size.value.value.unit === 'mu');
+            const muUnit = (size.value.unit === 'mu');
             if (mathFunction) {
                 if (!muUnit) {
                     parser.settings.reportNonstrict("mathVsTextUnits",
                         `LaTeX's ${funcName} supports only mu units, ` +
-                        `not ${size.value.value.unit} units`);
+                        `not ${size.value.unit} units`);
                 }
                 if (parser.mode !== "math") {
                     parser.settings.reportNonstrict("mathVsTextUnits",
@@ -42,13 +42,13 @@ defineFunction({
         return {
             type: "kern",
             mode: parser.mode,
-            dimension: size.value.value,
+            dimension: size.value,
         };
     },
-    htmlBuilder: (group, options) => {
+    htmlBuilder(group, options) {
         return buildCommon.makeGlue(group.dimension, options);
     },
-    mathmlBuilder: (group, options) => {
+    mathmlBuilder(group, options) {
         const dimension = calculateSize(group.dimension, options);
         return new mathMLTree.SpaceNode(dimension);
     },

src/functions/raisebox.js

@@ -18,7 +18,7 @@ defineFunction({
         allowedInText: true,
     },
     handler({parser}, args) {
-        const amount = assertNodeType(args[0], "size");
+        const amount = assertNodeType(args[0], "size").value;
         const body = args[1];
         return {
             type: "raisebox",
@@ -44,7 +44,7 @@ defineFunction({
             size: 6,                // simulate \normalsize
         };
         const body = sizing.htmlBuilder(sizedText, options);
-        const dy = calculateSize(group.dy.value.value, options);
+        const dy = calculateSize(group.dy, options);
         return buildCommon.makeVList({
             positionType: "shift",
             positionData: -dy,
@@ -54,7 +54,7 @@ defineFunction({
     mathmlBuilder(group, options) {
         const node = new mathMLTree.MathNode(
             "mpadded", [mml.buildGroup(group.body, options)]);
-        const dy = group.dy.value.value.number + group.dy.value.value.unit;
+        const dy = group.dy.number + group.dy.unit;
         node.setAttribute("voffset", dy);
         return node;
     },

src/functions/rule.js

@@ -20,9 +20,9 @@ defineFunction({
         return {
             type: "rule",
             mode: parser.mode,
-            shift: shift && assertNodeType(shift, "size").value.value,
-            width: width.value.value,
-            height: height.value.value,
+            shift: shift && assertNodeType(shift, "size").value,
+            width: width.value,
+            height: height.value,
         };
     },
     htmlBuilder(group, options) {

src/parseNode.js

@@ -78,11 +78,8 @@ type ParseNodeTypes = {
         type: "size",
         mode: Mode,
         loc?: ?SourceLocation,
-        value: {|
-            type: "size",
-            value: Measurement,
-            isBlank: boolean,
-        |},
+        value: Measurement,
+        isBlank: boolean,
     |},
     "styling": {|
         type: "styling",
@@ -199,7 +196,7 @@ type ParseNodeTypes = {
         loc?: ?SourceLocation,
         newRow: boolean,
         newLine: boolean,
-        size: ?ParseNode<"size">,
+        size: ?Measurement,
     |},
     "delimsizing": {|
         type: "delimsizing",
@@ -272,7 +269,7 @@ type ParseNodeTypes = {
         mode: Mode,
         loc?: ?SourceLocation,
         replaceWith: string,
-        sizeNode?: ParseNode<"size">,
+        size?: Measurement,
         token: ?Token,
     |},
     "kern": {|
@@ -358,7 +355,7 @@ type ParseNodeTypes = {
         type: "raisebox",
         mode: Mode,
         loc?: ?SourceLocation,
-        dy: ParseNode<"size">,
+        dy: Measurement,
         body: AnyParseNode,
     |},
     "rule": {|