Merge pull request #766 from asger-semmle/ts-compiler-3.2

TS: Support TypeScript 3.2

Author: Max Schaefer

change-notes/1.20/extractor-javascript.md

@@ -20,4 +20,5 @@
 
 * The extractor now supports additional [Flow](https://flow.org/) syntax.
 * The extractor now supports [Nullish Coalescing](https://github.com/tc39/proposal-nullish-coalescing) expressions.
+* The extractor now supports [TypeScript 3.2](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-2.html).
 * The TypeScript extractor now handles the control-flow of logical operators and destructuring assignments more accurately.

javascript/extractor/lib/typescript/package.json

@@ -2,7 +2,7 @@
     "name": "typescript-parser-wrapper",
     "private": true,
     "dependencies": {
-        "typescript": "3.0.1"
+        "typescript": "3.2.1"
     },
     "scripts": {
         "build": "tsc --project tsconfig.json && rollup -c",

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/lib/typescript/yarn.lock

@@ -509,9 +509,9 @@ tsutils@^2.12.1:
   dependencies:
     tslib "^1.8.1"
 
-typescript@3.0.1:
-  version "3.0.1"
-  resolved "typescript-3.0.1.tgz#43738f29585d3a87575520a4b93ab6026ef11fdb"
+typescript@3.2.1:
+  version "3.2.1"
+  resolved "typescript-3.2.1.tgz#0b7a04b8cf3868188de914d9568bd030f0c56192"
 
 wrappy@1:
   version "1.0.2"

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

@@ -41,7 +41,7 @@ public class Main {
 	 * such a way that it may produce different tuples for the same file under the same
 	 * {@link ExtractorConfig}.
 	 */
-	public static final String EXTRACTOR_VERSION = "2019-09-01";
+	public static final String EXTRACTOR_VERSION = "2019-14-01";
 
 	public static final Pattern NEWLINE = Pattern.compile("\n");
 

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);