Merge pull request #4709 from asgerf/js/typescript-4.1

JS: Support for TypeScript 4.1

Author: asgerf

javascript/change-notes/2020-12-02-typescript-4.1.md

@@ -0,0 +1,2 @@
+lgtm,codescanning
+* TypeScript 4.1 is now supported.

javascript/extractor/lib/typescript/package.json

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

javascript/extractor/lib/typescript/yarn.lock

@@ -6,6 +6,7 @@
   version "12.7.11"
   resolved node-12.7.11.tgz#be879b52031cfb5d295b047f5462d8ef1a716446
 
-typescript@4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.0.2.tgz#7ea7c88777c723c681e33bf7988be5d008d05ac2"
+typescript@4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.1.2.tgz#6369ef22516fe5e10304aae5a5c4862db55380e9"
+  integrity sha512-thGloWsGH3SOxv1SoY7QojKi0tc+8FnOmiarEGMbd/lar7QOEd3hvlx3Fp5y6FlDUGl9L+pd4n2e+oToGMmhRQ==

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

@@ -43,6 +43,7 @@
 import com.semmle.ts.ast.ParenthesizedTypeExpr;
 import com.semmle.ts.ast.PredicateTypeExpr;
 import com.semmle.ts.ast.RestTypeExpr;
+import com.semmle.ts.ast.TemplateLiteralTypeExpr;
 import com.semmle.ts.ast.TupleTypeExpr;
 import com.semmle.ts.ast.TypeAliasDeclaration;
 import com.semmle.ts.ast.TypeAssertion;
@@ -368,6 +369,11 @@ public R visit(TemplateLiteral nd, C c) {
     return visit((Expression) nd, c);
   }
 
+  @Override
+  public R visit(TemplateLiteralTypeExpr nd, C c) {
+    return visit((TypeExpression) nd, c);
+  }
+
   @Override
   public R visit(TaggedTemplateExpression nd, C c) {
     return visit((Expression) nd, c);

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

@@ -39,6 +39,7 @@
 import com.semmle.ts.ast.ParenthesizedTypeExpr;
 import com.semmle.ts.ast.PredicateTypeExpr;
 import com.semmle.ts.ast.RestTypeExpr;
+import com.semmle.ts.ast.TemplateLiteralTypeExpr;
 import com.semmle.ts.ast.TupleTypeExpr;
 import com.semmle.ts.ast.TypeAliasDeclaration;
 import com.semmle.ts.ast.TypeAssertion;
@@ -419,6 +420,11 @@ public TemplateLiteral visit(TemplateLiteral nd, Void q) {
     return new TemplateLiteral(visit(nd.getLoc()), copy(nd.getExpressions()), copy(nd.getQuasis()));
   }
 
+  @Override
+  public TemplateLiteralTypeExpr visit(TemplateLiteralTypeExpr nd, Void q) {
+    return new TemplateLiteralTypeExpr(visit(nd.getLoc()), copy(nd.getExpressions()), copy(nd.getQuasis()));
+  }
+
   @Override
   public TaggedTemplateExpression visit(TaggedTemplateExpression nd, Void q) {
     return new TaggedTemplateExpression(

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

@@ -21,20 +21,23 @@ public TemplateLiteral(
     super("TemplateLiteral", loc);
     this.expressions = expressions;
     this.quasis = quasis;
-    this.children = mergeChildren(expressions, quasis);
+    this.children = TemplateLiteral.<Expression>mergeChildren(expressions, quasis);
   }
 
   /*
    * Merge quasis and expressions into a single array in textual order.
    * Also filter out the empty constant strings that the parser likes to generate.
    */
-  private List<Expression> mergeChildren(
-      List<Expression> expressions, List<TemplateElement> quasis) {
-    List<Expression> children = new ArrayList<Expression>();
+  @SuppressWarnings("unchecked")
+  public static <E extends INode> List<E> mergeChildren(
+      List<? extends INode> expressions,
+      List<TemplateElement> quasis) {
+
+    List<INode> children = new ArrayList<INode>();
     int j = 0, n = quasis.size();
 
     for (int i = 0, m = expressions.size(); i < m; ++i) {
-      Expression expr = expressions.get(i);
+      INode expr = expressions.get(i);
       for (; j < n; ++j) {
         TemplateElement quasi = quasis.get(j);
         if (quasi.getLoc().getStart().compareTo(expr.getLoc().getStart()) > 0) break;
@@ -48,7 +51,7 @@ private List<Expression> mergeChildren(
       if (!quasi.getRaw().isEmpty()) children.add(quasi);
     }
 
-    return children;
+    return (List<E>)children;
   }
 
   @Override

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

@@ -39,6 +39,7 @@
 import com.semmle.ts.ast.ParenthesizedTypeExpr;
 import com.semmle.ts.ast.PredicateTypeExpr;
 import com.semmle.ts.ast.RestTypeExpr;
+import com.semmle.ts.ast.TemplateLiteralTypeExpr;
 import com.semmle.ts.ast.TupleTypeExpr;
 import com.semmle.ts.ast.TypeAliasDeclaration;
 import com.semmle.ts.ast.TypeAssertion;
@@ -157,6 +158,8 @@ public interface Visitor<C, R> {
 
   public R visit(TemplateLiteral nd, C q);
 
+  public R visit(TemplateLiteralTypeExpr nd, C q);
+
   public R visit(TaggedTemplateExpression nd, C q);
 
   public R visit(ArrowFunctionExpression nd, C q);

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

@@ -143,6 +143,7 @@
 import com.semmle.ts.ast.ParenthesizedTypeExpr;
 import com.semmle.ts.ast.PredicateTypeExpr;
 import com.semmle.ts.ast.RestTypeExpr;
+import com.semmle.ts.ast.TemplateLiteralTypeExpr;
 import com.semmle.ts.ast.TupleTypeExpr;
 import com.semmle.ts.ast.TypeAliasDeclaration;
 import com.semmle.ts.ast.TypeAssertion;
@@ -1270,6 +1271,13 @@ public Label visit(TemplateLiteral nd, Context c) {
       return key;
     }
 
+    @Override
+    public Label visit(TemplateLiteralTypeExpr nd, Context c) {
+      Label key = super.visit(nd, c);
+      visitAll(nd.getChildren(), key, IdContext.typeBind, 0);
+      return key;
+    }
+
     @Override
     public Label visit(TemplateElement nd, Context c) {
       Label key = super.visit(nd, c);

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

@@ -6,6 +6,7 @@
 import com.semmle.js.ast.Identifier;
 import com.semmle.js.ast.Literal;
 import com.semmle.js.ast.MemberExpression;
+import com.semmle.js.ast.TemplateElement;
 import com.semmle.js.extractor.ASTExtractor.IdContext;
 import com.semmle.ts.ast.ArrayTypeExpr;
 import com.semmle.ts.ast.ConditionalTypeExpr;
@@ -22,6 +23,7 @@
 import com.semmle.ts.ast.ParenthesizedTypeExpr;
 import com.semmle.ts.ast.PredicateTypeExpr;
 import com.semmle.ts.ast.RestTypeExpr;
+import com.semmle.ts.ast.TemplateLiteralTypeExpr;
 import com.semmle.ts.ast.TupleTypeExpr;
 import com.semmle.ts.ast.TypeParameter;
 import com.semmle.ts.ast.TypeofTypeExpr;
@@ -67,6 +69,7 @@ public class TypeExprKinds {
   private static final int restTypeExpr = 34;
   private static final int bigintLiteralTypeExpr = 35;
   private static final int readonlyTypeExpr = 36;
+  private static final int templateLiteralTypeExpr = 37;
 
   public static int getTypeExprKind(final INode type, final IdContext idcontext) {
     Integer kind =
@@ -241,6 +244,16 @@ public Integer visit(OptionalTypeExpr nd, Void c) {
               public Integer visit(RestTypeExpr nd, Void c) {
                 return restTypeExpr;
               }
+
+              @Override
+              public Integer visit(TemplateLiteralTypeExpr nd, Void c) {
+                return templateLiteralTypeExpr;
+              }
+
+              @Override
+              public Integer visit(TemplateElement nd, Void c) {
+                return stringLiteralTypeExpr;
+              }
             },
             null);
     if (kind == null)

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

@@ -0,0 +1,49 @@
+package com.semmle.ts.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.semmle.js.ast.Expression;
+import com.semmle.js.ast.INode;
+import com.semmle.js.ast.Node;
+import com.semmle.js.ast.SourceLocation;
+import com.semmle.js.ast.TemplateElement;
+import com.semmle.js.ast.TemplateLiteral;
+import com.semmle.js.ast.Visitor;
+
+/**
+ * A template literal used in a type, such as in <code>type T = `Hello, ${name}!`</code>.
+ */
+public class TemplateLiteralTypeExpr extends TypeExpression {
+  private final List<ITypeExpression> expressions;
+  private final List<TemplateElement> quasis;
+  private final List<Node> children;
+
+  public TemplateLiteralTypeExpr(
+      SourceLocation loc, List<ITypeExpression> expressions, List<TemplateElement> quasis) {
+    super("TemplateLiteralTypeExpr", loc);
+    this.expressions = expressions;
+    this.quasis = quasis;
+    this.children = TemplateLiteral.<Node>mergeChildren(expressions, quasis);
+  }
+
+  @Override
+  public <Q, A> A accept(Visitor<Q, A> v, Q q) {
+    return v.visit(this, q);
+  }
+
+  /** The type expressions in this template. */
+  public List<ITypeExpression> getExpressions() {
+    return expressions;
+  }
+
+  /** The template elements in this template. */
+  public List<TemplateElement> getQuasis() {
+    return quasis;
+  }
+
+  /** All type expressions and template elements in this template, in lexical order. */
+  public List<Node> getChildren() {
+    return children;
+  }
+}