Merge pull request #678 from benjamn/literal-type-improvements

Use `makeLiteralExtra` helper function to unify `node.extra` field definitions for literal types

Author: benjamn

def/babel-core.ts

@@ -7,10 +7,13 @@ import { namedTypes as N } from "../gen/namedTypes";
 export default function (fork: Fork) {
   fork.use(esProposalsDef);
 
-  var types = fork.use(typesPlugin);
-  var defaults = fork.use(sharedPlugin).defaults;
-  var def = types.Type.def;
-  var or = types.Type.or;
+  const types = fork.use(typesPlugin);
+  const defaults = fork.use(sharedPlugin).defaults;
+  const def = types.Type.def;
+  const or = types.Type.or;
+  const {
+    undefined: isUndefined,
+  } = types.builtInTypes;
 
   def("Noop")
     .bases("Statement")
@@ -78,58 +81,60 @@ export default function (fork: Fork) {
     .field("directives", [def("Directive")], defaults.emptyArray)
     .field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]);
 
+  function makeLiteralExtra<
+    // Allowing N.RegExpLiteral explicitly here is important because the
+    // node.value field of RegExpLiteral nodes can be undefined, which is not
+    // allowed for other Literal subtypes.
+    TNode extends Omit<N.Literal, "type"> | N.RegExpLiteral
+  >(
+    rawValueType: any = String,
+    toRaw?: (value: any) => string,
+  ): Parameters<import("../lib/types").Def["field"]> {
+    return [
+      "extra",
+      {
+        rawValue: rawValueType,
+        raw: String,
+      },
+      function getDefault(this: TNode) {
+        const value = types.getFieldValue(this, "value");
+        return {
+          rawValue: value,
+          raw: toRaw ? toRaw(value) : String(value),
+        };
+      },
+    ];
+  }
+
   // Split Literal
   def("StringLiteral")
     .bases("Literal")
     .build("value")
-    .field("value", String);
+    .field("value", String)
+    .field(...makeLiteralExtra<N.StringLiteral>(String, val => JSON.stringify(val)));
 
   def("NumericLiteral")
     .bases("Literal")
     .build("value")
     .field("value", Number)
     .field("raw", or(String, null), defaults["null"])
-    .field("extra", {
-      rawValue: Number,
-      raw: String
-    }, function getDefault(this: N.NumericLiteral) {
-      return {
-        rawValue: this.value,
-        raw: this.value + ""
-      }
-    });
+    .field(...makeLiteralExtra<N.NumericLiteral>(Number));
 
   def("BigIntLiteral")
     .bases("Literal")
     .build("value")
     // Only String really seems appropriate here, since BigInt values
     // often exceed the limits of JS numbers.
     .field("value", or(String, Number))
-    .field("extra", {
-      rawValue: String,
-      raw: String
-    }, function getDefault(this: N.BigIntLiteral) {
-      return {
-        rawValue: String(this.value),
-        raw: this.value + "n",
-      };
-    });
+    .field(...makeLiteralExtra<N.BigIntLiteral>(String, val => val + "n"));
 
   // https://github.com/tc39/proposal-decimal
   // https://github.com/babel/babel/pull/11640
   def("DecimalLiteral")
     .bases("Literal")
     .build("value")
     .field("value", String)
-    .field("extra", {
-      rawValue: String,
-      raw: String
-    }, function getDefault(this: N.DecimalLiteral) {
-      return {
-        rawValue: String(this.value),
-        raw: this.value + "m",
-      };
-    });
+    .field(...makeLiteralExtra<N.DecimalLiteral>(String, val => val + "m"));
 
   def("NullLiteral")
     .bases("Literal")
@@ -148,6 +153,21 @@ export default function (fork: Fork) {
     .field("flags", String)
     .field("value", RegExp, function (this: N.RegExpLiteral) {
       return new RegExp(this.pattern, this.flags);
+    })
+    .field(...makeLiteralExtra<N.RegExpLiteral>(
+      or(RegExp, isUndefined),
+      exp => `/${exp.pattern}/${exp.flags || ""}`,
+    ))
+    // I'm not sure why this field exists, but it's "specified" by estree:
+    // https://github.com/estree/estree/blob/master/es5.md#regexpliteral
+    .field("regex", {
+      pattern: String,
+      flags: String
+    }, function (this: N.RegExpLiteral) {
+      return {
+        pattern: this.pattern,
+        flags: this.flags,
+      };
     });
 
   var ObjectExpressionProperty = or(

def/core.ts

@@ -335,26 +335,7 @@ export default function (fork: Fork) {
   def("Literal")
     .bases("Expression")
     .build("value")
-    .field("value", or(String, Boolean, null, Number, RegExp))
-    .field("regex", or({
-      pattern: String,
-      flags: String
-    }, null), function (this: N.Literal) {
-      if (this.value instanceof RegExp) {
-        var flags = "";
-
-        if (this.value.ignoreCase) flags += "i";
-        if (this.value.multiline) flags += "m";
-        if (this.value.global) flags += "g";
-
-        return {
-          pattern: this.value.source,
-          flags: flags
-        };
-      }
-
-      return null;
-    });
+    .field("value", or(String, Boolean, null, Number, RegExp, BigInt));
 
   // Abstract (non-buildable) comment supertype. Not a Node.
   def("Comment")

gen/builders.ts

@@ -432,16 +432,12 @@ export interface PropertyBuilder {
 }
 
 export interface LiteralBuilder {
-  (value: string | boolean | null | number | RegExp): namedTypes.Literal;
+  (value: string | boolean | null | number | RegExp | BigInt): namedTypes.Literal;
   from(
     params: {
       comments?: K.CommentKind[] | null,
       loc?: K.SourceLocationKind | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
-      value: string | boolean | null | number | RegExp
+      value: string | boolean | null | number | RegExp | BigInt
     }
   ): namedTypes.Literal;
 }
@@ -1484,10 +1480,6 @@ export interface JSXTextBuilder {
       comments?: K.CommentKind[] | null,
       loc?: K.SourceLocationKind | null,
       raw?: string,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value: string
     }
   ): namedTypes.JSXText;
@@ -2659,11 +2651,11 @@ export interface StringLiteralBuilder {
   from(
     params: {
       comments?: K.CommentKind[] | null,
+      extra?: {
+        rawValue: string,
+        raw: string
+      },
       loc?: K.SourceLocationKind | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value: string
     }
   ): namedTypes.StringLiteral;
@@ -2680,10 +2672,6 @@ export interface NumericLiteralBuilder {
       },
       loc?: K.SourceLocationKind | null,
       raw?: string | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value: number
     }
   ): namedTypes.NumericLiteral;
@@ -2699,10 +2687,6 @@ export interface BigIntLiteralBuilder {
         raw: string
       },
       loc?: K.SourceLocationKind | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value: string | number
     }
   ): namedTypes.BigIntLiteral;
@@ -2718,10 +2702,6 @@ export interface DecimalLiteralBuilder {
         raw: string
       },
       loc?: K.SourceLocationKind | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value: string
     }
   ): namedTypes.DecimalLiteral;
@@ -2733,10 +2713,6 @@ export interface NullLiteralBuilder {
     params: {
       comments?: K.CommentKind[] | null,
       loc?: K.SourceLocationKind | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value?: null
     }
   ): namedTypes.NullLiteral;
@@ -2748,10 +2724,6 @@ export interface BooleanLiteralBuilder {
     params: {
       comments?: K.CommentKind[] | null,
       loc?: K.SourceLocationKind | null,
-      regex?: {
-        pattern: string,
-        flags: string
-      } | null,
       value: boolean
     }
   ): namedTypes.BooleanLiteral;
@@ -2762,13 +2734,17 @@ export interface RegExpLiteralBuilder {
   from(
     params: {
       comments?: K.CommentKind[] | null,
+      extra?: {
+        rawValue: RegExp | undefined,
+        raw: string
+      },
       flags: string,
       loc?: K.SourceLocationKind | null,
       pattern: string,
       regex?: {
         pattern: string,
         flags: string
-      } | null,
+      },
       value?: RegExp
     }
   ): namedTypes.RegExpLiteral;

gen/namedTypes.ts

@@ -233,11 +233,7 @@ export namespace namedTypes {
 
   export interface Literal extends Omit<Expression, "type"> {
     type: "Literal";
-    value: string | boolean | null | number | RegExp;
-    regex?: {
-      pattern: string,
-      flags: string
-    } | null;
+    value: string | boolean | null | number | RegExp | BigInt;
   }
 
   export interface SequenceExpression extends Omit<Expression, "type"> {
@@ -1222,6 +1218,10 @@ export namespace namedTypes {
   export interface StringLiteral extends Omit<Literal, "type" | "value"> {
     type: "StringLiteral";
     value: string;
+    extra?: {
+      rawValue: string,
+      raw: string
+    };
   }
 
   export interface NumericLiteral extends Omit<Literal, "type" | "value"> {
@@ -1267,6 +1267,14 @@ export namespace namedTypes {
     pattern: string;
     flags: string;
     value?: RegExp;
+    extra?: {
+      rawValue: RegExp | undefined,
+      raw: string
+    };
+    regex?: {
+      pattern: string,
+      flags: string
+    };
   }
 
   export interface ClassMethod extends Omit<Declaration, "type">, Omit<Function, "type" | "body"> {

lib/types.ts

@@ -400,6 +400,7 @@ export default function typesPlugin(_fork: Fork) {
     boolean: boolean;
     null: null;
     undefined: undefined;
+    BigInt: BigInt;
   };
 
   function defBuiltInType<K extends keyof BuiltInTypes>(
@@ -434,6 +435,9 @@ export default function typesPlugin(_fork: Fork) {
   const isBoolean = defBuiltInType("boolean", true);
   const isNull = defBuiltInType("null", null);
   const isUndefined = defBuiltInType("undefined", undefined);
+  const isBigInt = typeof BigInt === "function"
+    ? defBuiltInType("BigInt", BigInt(1234))
+    : new PredicateType<BigInt>("BigInt", () => false);
 
   const builtInTypes = {
     string: isString,
@@ -446,6 +450,7 @@ export default function typesPlugin(_fork: Fork) {
     boolean: isBoolean,
     null: isNull,
     undefined: isUndefined,
+    BigInt: isBigInt,
   };
 
   // In order to return the same Def instance every time Type.def is called

test/ecmascript.ts

@@ -2331,15 +2331,16 @@ describe("RegExpLiteral nodes", function() {
 
   it("should typecheck with explicit .regex field", function() {
     var stringLiteral = b.literal("asdf");
-    assert.strictEqual(stringLiteral.regex, null);
+    assert.strictEqual(hasOwn.call(stringLiteral, "regex"), false);
     n.Literal.assert(stringLiteral, true);
 
-    var regExpLiteral: any = b.literal(/a.b/gi);
-    assert.strictEqual(regExpLiteral.regex.pattern, "a.b");
-    assert.strictEqual(regExpLiteral.regex.flags, "ig");
+    const regExpLiteral = b.regExpLiteral("a.b", "gi");
+    const regex = rawTypes.getFieldValue(regExpLiteral, "regex");
+    assert.strictEqual(regex.pattern, "a.b");
+    assert.strictEqual(regex.flags, "gi");
     n.Literal.assert(regExpLiteral, true);
 
-    regExpLiteral.regex.pattern = 1234;
+    regex.pattern = 1234;
     assert.strictEqual(n.Literal.check(regExpLiteral, true), false);
   });
 });