TS: add support for bigints

Author: asger-semmle

javascript/extractor/lib/typescript/src/type_table.ts

@@ -505,6 +505,9 @@ export class TypeTable {
     if (flags === ts.TypeFlags.Never) {
       return "never";
     }
+    if (flags === ts.TypeFlags.BigInt) {
+      return "bigint";
+    }
     if (flags & ts.TypeFlags.Null) {
       return "null";
     }
@@ -536,6 +539,11 @@ export class TypeTable {
     if (flags & ts.TypeFlags.StringLiteral) {
       return "strlit;" + (type as ts.LiteralType).value;
     }
+    if (flags & ts.TypeFlags.BigIntLiteral) {
+      let literalType = type as ts.LiteralType;
+      let value = literalType.value as ts.PseudoBigInt;
+      return "bigintlit;" + (value.negative ? "-" : "") + value.base10Value;
+    }
     if (flags & ts.TypeFlags.Union) {
       let unionType = type as ts.UnionType;
       if (unionType.types.length === 0) {

javascript/extractor/src/com/semmle/js/extractor/TypeExprKinds.java

@@ -1,5 +1,6 @@
 package com.semmle.js.extractor;
 
+import com.semmle.jcorn.TokenType;
 import com.semmle.js.ast.DefaultVisitor;
 import com.semmle.js.ast.INode;
 import com.semmle.js.ast.Identifier;
@@ -64,6 +65,7 @@ public class TypeExprKinds {
 	private static final int importVarTypeAccess = 32;
 	private static final int optionalTypeExpr = 33;
 	private static final int restTypeExpr = 34;
+	private static final int bigintLiteralTypeExpr = 35;
 
 	public static int getTypeExprKind(final INode type, final IdContext idcontext) {
 		Integer kind = type.accept(new DefaultVisitor<Void, Integer>() {
@@ -159,6 +161,7 @@ public Integer visit(InterfaceTypeExpr nd, Void c) {
 
 			@Override
 			public Integer visit(Literal nd, Void c) {
+				TokenType type = nd.getTokenType();
 				if (nd.getValue() == null) {
 					// We represent the null type as a keyword type in QL, but in the extractor AST
 					// it is a Literal because the TypeScript AST does not distinguish those.
@@ -167,12 +170,14 @@ public Integer visit(Literal nd, Void c) {
 					// - TypeScript documentation does not treat the null type as a literal type.
 					// - There is an "undefined" type, but there is no "undefined" literal.
 					return keywordTypeExpr;
-				} else if (nd.getValue() instanceof String) {
+				} else if (type == TokenType.string) {
 					return stringLiteralTypeExpr;
-				} else if (nd.getValue() instanceof Number) {
+				} else if (type == TokenType.num) {
 					return numberLiteralTypeExpr;
-				} else if (nd.getValue() instanceof Boolean) {
+				} else if (type == TokenType._true || type == TokenType._false) {
 					return booeleanLiteralTypeExpr;
+				} else if (type == TokenType.bigint) {
+					return bigintLiteralTypeExpr;
 				} else {
 					throw new CatastrophicError("Unsupported literal type expression kind: " + nd.getValue().getClass());
 				}

javascript/extractor/src/com/semmle/js/parser/TypeScriptASTConverter.java

@@ -369,6 +369,10 @@ private Node convertNodeUntyped(JsonObject node, String defaultKind) throws Pars
 			return convertAsExpression(node, loc);
 		case "AwaitExpression":
 			return convertAwaitExpression(node, loc);
+		case "BigIntKeyword":
+			return convertKeywordTypeExpr(node, loc, "bigint");
+		case "BigIntLiteral":
+			return convertBigIntLiteral(node, loc);
 		case "BinaryExpression":
 			return convertBinaryExpression(node, loc);
 		case "Block":
@@ -822,6 +826,12 @@ private Node convertAwaitExpression(JsonObject node, SourceLocation loc) throws
 		return new AwaitExpression(loc, convertChild(node, "expression"));
 	}
 
+	private Node convertBigIntLiteral(JsonObject node, SourceLocation loc) throws ParseError {
+		String text = node.get("text").getAsString();
+		String value = text.substring(0, text.length() - 1); // Remove the 'n' suffix.
+		return new Literal(loc, TokenType.bigint, value);
+	}
+
 	private Node convertBinaryExpression(JsonObject node, SourceLocation loc) throws ParseError {
 		Expression left = convertChild(node, "left");
 		Expression right = convertChild(node, "right");

javascript/extractor/src/com/semmle/ts/extractor/TypeExtractor.java

@@ -31,6 +31,7 @@ public class TypeExtractor {
 	private static final int thisKind = 20;
 	private static final int numberLiteralTypeKind = 21;
 	private static final int stringLiteralTypeKind = 22;
+	private static final int bigintLiteralTypeKind = 25;
 
 	static {
 		tagToKind.put("any", 0);
@@ -57,6 +58,8 @@ public class TypeExtractor {
 		tagToKind.put("numlit", numberLiteralTypeKind);
 		tagToKind.put("strlit", stringLiteralTypeKind);
 		tagToKind.put("unknown", 23);
+		tagToKind.put("bigint", 24);
+		tagToKind.put("bigintlit", bigintLiteralTypeKind);
 	}
 
 	private static final Map<String, Integer> symbolKind = new LinkedHashMap<String, Integer>();
@@ -126,6 +129,7 @@ private void extractType(int id) {
 
 		case numberLiteralTypeKind:
 		case stringLiteralTypeKind:
+		case bigintLiteralTypeKind:
 			firstChild = parts.length; // No children.
 			// The string value may contain `;` so don't use the split().
 			String value = contents.substring(parts[0].length() + 1);

javascript/ql/src/semmle/javascript/TypeScript.qll

@@ -582,6 +582,9 @@ class TypeExpr extends ExprOrType, @typeexpr {
   /** Holds if this is the `unknown` type. */
   predicate isUnknownKeyword() { none() }
 
+  /** Holds if this is the `bigint` type. */
+  predicate isBigInt() { none() }
+
   /** Gets this type expression, with any surrounding parentheses removed. */
   override TypeExpr stripParens() { result = this }
 
@@ -633,6 +636,8 @@ private class KeywordTypeExpr extends @keywordtypeexpr, TypeExpr {
   override predicate isObjectKeyword() { getName() = "object" }
 
   override predicate isUnknownKeyword() { getName() = "unknown" }
+
+  override predicate isBigInt() { getName() = "bigint" }
 }
 
 /**
@@ -798,6 +803,18 @@ class BooleanLiteralTypeExpr extends @booleanliteraltypeexpr, LiteralTypeExpr {
   predicate isFalse() { getValue() = "false" }
 }
 
+/** A bigint literal used as a TypeScript type annotation. */
+class BigIntLiteralTypeExpr extends @bigintliteraltypeexpr, LiteralTypeExpr {
+  /** Gets the integer value of the bigint literal, if it can be represented as a QL integer. */
+  int getIntValue() { result = getValue().toInt() }
+
+  /**
+   * Gets the floating point value of this literal if it can be represented
+   * as a QL floating point value.
+   */
+  float getFloatValue() { result = getValue().toFloat() }
+}
+
 /**
  * An array type, such as `number[]`, or in general `T[]` where `T` is a type.
  *
@@ -1950,6 +1967,11 @@ class StringType extends Type, @stringtype { }
  */
 class NumberType extends Type, @numbertype { }
 
+/**
+ * The predefined `bigint` type.
+ */
+class BigIntType extends Type, @biginttype { }
+
 /**
  * A boolean, number, or string literal type.
  */
@@ -1998,6 +2020,23 @@ class StringLiteralType extends LiteralType, @stringliteraltype {
   override string getStringValue() { type_literal_value(this, result) }
 }
 
+/**
+ * A bigint literal as a static type.
+ */
+class BigIntLiteralType extends LiteralType {
+  override string getStringValue() { type_literal_value(this, result) }
+
+  /**
+   * Gets the value of the literal as an integer.
+   */
+  int getIntValue() { result = getStringValue().toInt() }
+
+  /**
+   * Gets the value of the literal as a floating-point value.
+   */
+  float getFloatValue() { result = getStringValue().toFloat() }
+}
+
 /**
  * The `boolean` type, internally represented as the union type `true | false`.
  */

javascript/ql/src/semmlecode.javascript.dbscheme

@@ -560,12 +560,13 @@ case @typeexpr.kind of
 | 32 = @importvartypeaccess
 | 33 = @optionaltypeexpr
 | 34 = @resttypeexpr
+| 35 = @bigintliteraltypeexpr
 ;
 
 @typeref = @typeaccess | @typedecl;
 @typeidentifier = @typedecl | @localtypeaccess | @typelabel | @localvartypeaccess | @localnamespaceaccess;
 @typeexpr_parent = @expr | @stmt | @property | @typeexpr;
-@literaltypeexpr = @stringliteraltypeexpr | @numberliteraltypeexpr | @booleanliteraltypeexpr;
+@literaltypeexpr = @stringliteraltypeexpr | @numberliteraltypeexpr | @booleanliteraltypeexpr | @bigintliteraltypeexpr;
 @typeaccess = @localtypeaccess | @qualifiedtypeaccess | @importtypeaccess;
 @vartypeaccess = @localvartypeaccess | @qualifiedvartypeaccess | @thisvartypeaccess | @importvartypeaccess;
 @namespaceaccess = @localnamespaceaccess | @qualifiednamespaceaccess | @importnamespaceaccess;
@@ -612,6 +613,8 @@ case @type.kind of
 | 21 = @numberliteraltype
 | 22 = @stringliteraltype
 | 23 = @unknowntype
+| 24 = @biginttype
+| 25 = @bigintliteraltype
 ;
 
 @booleanliteraltype = @truetype | @falsetype;
@@ -678,8 +681,8 @@ type_property(
   varchar(900) name: string ref,
   int propertyType: @type ref);
 
-@literaltype = @stringliteraltype | @numberliteraltype | @booleanliteraltype;
-@type_with_literal_value = @stringliteraltype | @numberliteraltype;
+@literaltype = @stringliteraltype | @numberliteraltype | @booleanliteraltype | @bigintliteraltype;
+@type_with_literal_value = @stringliteraltype | @numberliteraltype | @bigintliteraltype;
 type_literal_value(
   unique int typ: @type_with_literal_value ref,
   varchar(900) value: string ref);

javascript/ql/test/library-tests/TypeScript/BigInts/ExprFloatValue.expected

@@ -0,0 +1,3 @@
+| tst.ts:1:25:1:28 | 100n | 100.0 |
+| tst.ts:2:25:2:56 | 1000000 ... 000000n | 1.0E30 |
+| tst.ts:3:25:3:56 | 1000000 ... 000000n | 1.0E30 |

javascript/ql/test/library-tests/TypeScript/BigInts/ExprFloatValue.ql

@@ -0,0 +1,4 @@
+import javascript
+
+from BigIntLiteral literal
+select literal, literal.getFloatValue()

javascript/ql/test/library-tests/TypeScript/BigInts/ExprIntValue.expected

@@ -0,0 +1 @@
+| tst.ts:1:25:1:28 | 100n | 100 |

javascript/ql/test/library-tests/TypeScript/BigInts/ExprIntValue.ql

@@ -0,0 +1,4 @@
+import javascript
+
+from BigIntLiteral literal
+select literal, literal.getIntValue()