Merge pull request #4043 from erik-krogh/ts4

JS: Add support for TypeScript 4

Author: asgerf

change-notes/1.25/analysis-javascript.md

@@ -30,7 +30,7 @@
   - [yargs](https://www.npmjs.com/package/yargs)
   - [webpack-dev-server](https://www.npmjs.com/package/webpack-dev-server)
 
-* TypeScript 3.9 is now supported.
+* TypeScript 4.0 is now supported.
 
 * TypeScript code embedded in HTML and Vue files is now extracted and analyzed.
 

javascript/extractor/lib/typescript/package.json

@@ -2,7 +2,7 @@
     "name": "typescript-parser-wrapper",
     "private": true,
     "dependencies": {
-        "typescript": "3.9.2"
+        "typescript": "4.0.2"
     },
     "scripts": {
         "build": "tsc --project tsconfig.json",

javascript/extractor/lib/typescript/yarn.lock

@@ -225,9 +225,9 @@ tsutils@^2.12.1:
   dependencies:
     tslib "^1.8.1"
 
-typescript@3.9.2:
-  version "3.9.2"
-  resolved typescript-3.9.2.tgz#64e9c8e9be6ea583c54607677dd4680a1cf35db9
+typescript@4.0.2:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.0.2.tgz#7ea7c88777c723c681e33bf7988be5d008d05ac2"
 
 wrappy@1:
   version "1.0.2"

javascript/extractor/src/com/semmle/js/ast/NodeCopier.java

@@ -711,7 +711,7 @@ public INode visit(ParenthesizedTypeExpr nd, Void c) {
 
   @Override
   public INode visit(TupleTypeExpr nd, Void c) {
-    return new TupleTypeExpr(visit(nd.getLoc()), copy(nd.getElementTypes()));
+    return new TupleTypeExpr(visit(nd.getLoc()), copy(nd.getElementTypes()), copy(nd.getElementNames()));
   }
 
   @Override

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

@@ -1830,6 +1830,10 @@ public Label visit(ParenthesizedTypeExpr nd, Context c) {
     @Override
     public Label visit(TupleTypeExpr nd, Context c) {
       Label key = super.visit(nd, c);
+      if (nd.getElementNames() != null) {
+        // Element names are index -1, -2, -3...
+        visitAll(nd.getElementNames(), key, IdContext.typeLabel, -1, -1);
+      }
       visitAll(nd.getElementTypes(), key, IdContext.typeBind, 0);
       return key;
     }

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

@@ -1551,8 +1551,27 @@ public Void visit(MemberDefinition<?> nd, SuccessorInfo i) {
 
     @Override
     public Void visit(AssignmentExpression nd, SuccessorInfo i) {
-      visitAssign(nd, nd.getLeft(), nd.getRight());
-      succ(nd, i.getGuardedSuccessors(nd));
+      // `a &&= b` expands to `a || (a = b);`
+      // The CFG is a conditional assignment, so we go through the assignment `nd` last.
+      if ("&&=".equals(nd.getOperator()) || "||=".equals(nd.getOperator()) || "??=".equals(nd.getOperator())) {
+        if ("&&=".equals(nd.getOperator())) {
+          // from lhs to rhs on truthy. from lhs to false-branch on falsy.
+          visit(nd.getLeft(), First.of(nd.getRight()), i.getSuccessors(false));
+        } else if ("||=".equals(nd.getOperator())) {
+          // from lhs to true-branch on truthy. from lhs to rhs on falsy.
+          visit(nd.getLeft(), i.getSuccessors(true), First.of(nd.getRight()));
+        } else { // "??="
+          // the union of the above - truthyness is unknown.
+          visit(nd.getLeft(), union(First.of(nd.getRight()), i.getAllSuccessors()), null);
+        }
+        
+        visit(nd.getRight(), First.of(nd), null); // from right to assignment.
+
+        succ(nd, i.getGuardedSuccessors(nd));
+      } else {
+        visitAssign(nd, nd.getLeft(), nd.getRight());
+        succ(nd, i.getGuardedSuccessors(nd));
+      }
       return null;
     }
 

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

@@ -79,6 +79,9 @@ public class ExprKinds {
     binOpKinds.put("**", 87);
     binOpKinds.put("**=", 88);
     binOpKinds.put("??", 107);
+    binOpKinds.put("&&=", 116);
+    binOpKinds.put("||=", 117);
+    binOpKinds.put("??=", 118);
   }
 
   private static final Map<String, Integer> unOpKinds = new LinkedHashMap<String, Integer>();

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

@@ -5,6 +5,7 @@
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
@@ -586,6 +587,8 @@ private Node convertNodeUntyped(JsonObject node, String defaultKind) throws Pars
         return convertTryStatement(node, loc);
       case "TupleType":
         return convertTupleType(node, loc);
+      case "NamedTupleMember": 
+        return convertNamedTupleMember(node, loc);
       case "TypeAliasDeclaration":
         return convertTypeAliasDeclaration(node, loc);
       case "TypeAssertionExpression":
@@ -850,6 +853,9 @@ private Node convertBinaryExpression(JsonObject node, SourceLocation loc) throws
       case ">>=":
       case "<<=":
       case ">>>=":
+      case "??=":
+      case "&&=":
+      case "||=":
         return new AssignmentExpression(loc, operator, convertLValue(left), right);
 
       default:
@@ -2178,7 +2184,22 @@ private Node convertTryStatement(JsonObject node, SourceLocation loc) throws Par
   }
 
   private Node convertTupleType(JsonObject node, SourceLocation loc) throws ParseError {
-    return new TupleTypeExpr(loc, convertChildrenAsTypes(node, "elementTypes"));
+    List<Identifier> names = new ArrayList<>();
+
+    for (JsonElement element : node.get("elements").getAsJsonArray()) {
+      Identifier id = null;
+      if (getKind(element).equals("NamedTupleMember")) {
+        id = (Identifier)convertNode(element.getAsJsonObject().get("name").getAsJsonObject());
+      }
+      names.add(id);
+    }
+
+    return new TupleTypeExpr(loc, convertChildrenAsTypes(node, "elements"), names);
+  }
+
+  // This method just does a trivial forward to the type. The names have already been extracted in `convertTupleType`.
+  private Node convertNamedTupleMember(JsonObject node, SourceLocation loc) throws ParseError {
+    return convertChild(node, "type");
   }
 
   private Node convertTypeAliasDeclaration(JsonObject node, SourceLocation loc) throws ParseError {

javascript/extractor/src/com/semmle/ts/ast/TupleTypeExpr.java

@@ -1,22 +1,29 @@
 package com.semmle.ts.ast;
 
+import com.semmle.js.ast.Identifier;
 import com.semmle.js.ast.SourceLocation;
 import com.semmle.js.ast.Visitor;
 import java.util.List;
 
 /** A tuple type, such as <tt>[number, string]</tt>. */
 public class TupleTypeExpr extends TypeExpression {
   private final List<ITypeExpression> elementTypes;
+  private final List<Identifier> elementNames;
 
-  public TupleTypeExpr(SourceLocation loc, List<ITypeExpression> elementTypes) {
+  public TupleTypeExpr(SourceLocation loc, List<ITypeExpression> elementTypes, List<Identifier> elementNames) {
     super("TupleTypeExpr", loc);
     this.elementTypes = elementTypes;
+    this.elementNames = elementNames;
   }
 
   public List<ITypeExpression> getElementTypes() {
     return elementTypes;
   }
 
+  public List<Identifier> getElementNames() {
+    return elementNames;
+  }
+
   @Override
   public <C, R> R accept(Visitor<C, R> v, C c) {
     return v.visit(this, c);

javascript/ql/src/semmle/javascript/Expr.qll

@@ -1851,7 +1851,8 @@ class AssignExpr extends @assignexpr, Assignment {
 private class TCompoundAssignExpr =
   @assignaddexpr or @assignsubexpr or @assignmulexpr or @assigndivexpr or @assignmodexpr or
       @assignexpexpr or @assignlshiftexpr or @assignrshiftexpr or @assignurshiftexpr or
-      @assignorexpr or @assignxorexpr or @assignandexpr;
+      @assignorexpr or @assignxorexpr or @assignandexpr or @assignlogandexpr or @assignlogorexpr or
+      @assignnullishcoalescingexpr;
 
 /**
  * A compound assign expression.
@@ -1997,6 +1998,39 @@ class AssignXOrExpr extends @assignxorexpr, CompoundAssignExpr { }
  */
 class AssignAndExpr extends @assignandexpr, CompoundAssignExpr { }
 
+/**
+ * A logical-'or'-assign expression.
+ *
+ * Example:
+ *
+ * ```
+ * x ||= y
+ * ```
+ */
+class AssignLogOrExpr extends @assignlogandexpr, CompoundAssignExpr { }
+
+/**
+ * A logical-'and'-assign expression.
+ *
+ * Example:
+ *
+ * ```
+ * x &&= y
+ * ```
+ */
+class AssignLogAndExpr extends @assignlogorexpr, CompoundAssignExpr { }
+
+/**
+ * A 'nullish-coalescing'-assign expression.
+ *
+ * Example:
+ *
+ * ```
+ * x ??= y
+ * ```
+ */
+class AssignNullishCoalescingExpr extends @assignnullishcoalescingexpr, CompoundAssignExpr { }
+
 /**
  * An update expression, that is, an increment or decrement expression.
  *