JS: Convert TypeScript import assertions

Author: asgerf

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

@@ -224,6 +224,7 @@ const astProperties: string[] = [
     "argument",
     "argumentExpression",
     "arguments",
+    "assertClause",
     "assertsModifier",
     "asteriskToken",
     "attributes",

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

@@ -342,6 +342,10 @@ private Node convertNodeUntyped(JsonObject node, String defaultKind) throws Pars
         return convertArrowFunction(node, loc);
       case "AsExpression":
         return convertTypeAssertionExpression(node, loc);
+      case "AssertClause":
+        return convertAssertClause(node, loc);
+      case "AssertEntry":
+        return convertAssertEntry(node, loc);
       case "SatisfiesExpression":
         return convertSatisfiesExpression(node, loc);
       case "AwaitExpression":
@@ -887,8 +891,8 @@ private Node convertBreakStatement(JsonObject node, SourceLocation loc) throws P
 
   private Node convertCallExpression(JsonObject node, SourceLocation loc) throws ParseError {
     List<Expression> arguments = convertChildren(node, "arguments");
-    if (arguments.size() == 1 && hasKind(node.get("expression"), "ImportKeyword")) {
-      return new DynamicImport(loc, arguments.get(0), null); // TODO: preserve import attributes
+    if (arguments.size() >= 1 && hasKind(node.get("expression"), "ImportKeyword")) {
+      return new DynamicImport(loc, arguments.get(0), arguments.size() > 1 ? arguments.get(1) : null);
     }
     Expression callee = convertChild(node, "expression");
     List<ITypeExpression> typeArguments = convertChildrenAsTypes(node, "typeArguments");
@@ -1193,15 +1197,16 @@ private Node convertExportAssignment(JsonObject node, SourceLocation loc) throws
 
   private Node convertExportDeclaration(JsonObject node, SourceLocation loc) throws ParseError {
     Literal source = tryConvertChild(node, "moduleSpecifier", Literal.class);
+    Expression assertion = convertChild(node, "assertClause");
     if (hasChild(node, "exportClause")) {
       boolean hasTypeKeyword = node.get("isTypeOnly").getAsBoolean();
       List<ExportSpecifier> specifiers =
           hasKind(node.get("exportClause"), "NamespaceExport")
               ? Collections.singletonList(convertChild(node, "exportClause"))
               : convertChildren(node.get("exportClause").getAsJsonObject(), "elements");
-      return new ExportNamedDeclaration(loc, null, specifiers, source, null, hasTypeKeyword); // TODO: preserve import assertions
+      return new ExportNamedDeclaration(loc, null, specifiers, source, assertion, hasTypeKeyword);
     } else {
-      return new ExportAllDeclaration(loc, source, null); // TODO: preserve import assertions
+      return new ExportAllDeclaration(loc, source, assertion);
     }
   }
 
@@ -1383,6 +1388,7 @@ private Node convertImportClause(JsonObject node, SourceLocation loc) throws Par
 
   private Node convertImportDeclaration(JsonObject node, SourceLocation loc) throws ParseError {
     Literal src = tryConvertChild(node, "moduleSpecifier", Literal.class);
+    Expression assertion = convertChild(node, "assertClause");
     List<ImportSpecifier> specifiers = new ArrayList<>();
     boolean hasTypeKeyword = false;
     if (hasChild(node, "importClause")) {
@@ -1400,7 +1406,7 @@ private Node convertImportDeclaration(JsonObject node, SourceLocation loc) throw
       }
       hasTypeKeyword = importClause.get("isTypeOnly").getAsBoolean();
     }
-    ImportDeclaration importDecl = new ImportDeclaration(loc, specifiers, src, null, hasTypeKeyword); // TODO: preserve import assertions
+    ImportDeclaration importDecl = new ImportDeclaration(loc, specifiers, src, assertion, hasTypeKeyword);
     attachSymbolInformation(importDecl, node);
     return importDecl;
   }
@@ -1746,7 +1752,7 @@ private Node convertNamespaceDeclaration(JsonObject node, SourceLocation loc) th
     if (hasFlag(node, "NestedNamespace")) {
       // In a nested namespace declaration `namespace A.B`, the nested namespace `B`
       // is implicitly exported.
-      return new ExportNamedDeclaration(loc, decl, new ArrayList<>(), null, null); // TODO: preserve import assertion
+      return new ExportNamedDeclaration(loc, decl, new ArrayList<>(), null, null);
     } else {
       return fixExports(loc, decl);
     }
@@ -2276,6 +2282,24 @@ private Node convertTypeAssertionExpression(JsonObject node, SourceLocation loc)
     return new TypeAssertion(loc, convertChild(node, "expression"), type, false);
   }
 
+  private Node convertAssertClause(JsonObject node, SourceLocation loc) throws ParseError {
+    List<Property> properties = new ArrayList<>();
+    for (INode child : convertChildren(node, "elements")) {
+      properties.add((Property)child);
+    }
+    return new ObjectExpression(loc, properties);
+  }
+
+  private Node convertAssertEntry(JsonObject node, SourceLocation loc) throws ParseError {
+    return new Property(
+        loc,
+        convertChild(node, "key"),
+        convertChild(node, "value"),
+        "init",
+        false,
+        false);
+  }
+
   private Node convertSatisfiesExpression(JsonObject node, SourceLocation loc) throws ParseError {
     ITypeExpression type = convertChildAsType(node, "type");
     return new SatisfiesExpr(loc, convertChild(node, "expression"), type);
@@ -2455,7 +2479,7 @@ private Node fixExports(SourceLocation loc, Node decl) {
       advance(loc, skipped);
       // capture group 1 is `default`, if present
       if (m.group(1) == null)
-        return new ExportNamedDeclaration(outerLoc, (Statement) decl, new ArrayList<>(), null, null); // TODO: preserve import assertions
+        return new ExportNamedDeclaration(outerLoc, (Statement) decl, new ArrayList<>(), null, null);
       return new ExportDefaultDeclaration(outerLoc, decl);
     }
     return decl;

javascript/extractor/tests/ts/input/import-assertion.ts

@@ -0,0 +1,13 @@
+import "module" assert { type: "json" };
+import * as v1 from "module" assert { type: "json" };
+import { v2 } from "module" assert { type: "json" };
+import v3 from "module" assert { type: "json" };
+
+export { v4 } from "module" assert { type: "json" };
+export * from "module" assert { type: "json" };
+export * as v5 from "module" assert { type: "json" };
+
+const v6 = import("module", { assert: { type: "json" } });
+
+import "module"; // missing semicolon
+assert({ type: "json" }); // function call, not import assertion