Add support for using and await using

FEATURE: Support `using` and `await using` syntax.

Issue #1369

Author: baseballyama

acorn-loose/src/statement.js

@@ -54,8 +54,19 @@ lp.parseStatement = function() {
     this.expect(tt.parenL)
     if (this.tok.type === tt.semi) return this.parseFor(node, null)
     let isLet = this.toks.isLet()
-    if (isLet || this.tok.type === tt._var || this.tok.type === tt._const) {
-      let init = this.parseVar(this.startNode(), true, isLet ? "let" : this.tok.value)
+    let isAwaitUsing = this.toks.isAwaitUsing(true)
+    let isUsing = !isAwaitUsing && this.toks.isUsing(true)
+
+    if (isLet || this.tok.type === tt._var || this.tok.type === tt._const || isUsing || isAwaitUsing) {
+      let kind = isLet ? "let" : isUsing ? "using" : isAwaitUsing ? "await using" : this.tok.value
+      let init = this.startNode()
+      if (isUsing || isAwaitUsing) {
+        if (isAwaitUsing) this.next()
+        this.parseVar(init, true, kind)
+      } else {
+        init = this.parseVar(init, true, kind)
+      }
+
       if (init.declarations.length === 1 && (this.tok.type === tt._in || this.isContextual("of"))) {
         if (this.options.ecmaVersion >= 9 && this.tok.type !== tt._in) {
           node.await = isAwait
@@ -196,6 +207,16 @@ lp.parseStatement = function() {
       this.next()
       return this.parseFunction(node, true, true)
     }
+
+    if (this.toks.isUsing(false)) {
+      return this.parseVar(node, false, "using")
+    }
+
+    if (this.toks.isAwaitUsing(false)) {
+      this.next()
+      return this.parseVar(node, false, "await using")
+    }
+
     let expr = this.parseExpression()
     if (isDummy(expr)) {
       this.next()

acorn/src/acorn.d.ts

@@ -169,7 +169,7 @@ export interface FunctionDeclaration extends Function {
 export interface VariableDeclaration extends Node {
   type: "VariableDeclaration"
   declarations: Array<VariableDeclarator>
-  kind: "var" | "let" | "const"
+  kind: "var" | "let" | "const" | "using" | "await using"
 }
 
 export interface VariableDeclarator extends Node {
@@ -600,7 +600,7 @@ export function tokenizer(input: string, options: Options): {
   [Symbol.iterator](): Iterator<Token>
 }
 
-export type ecmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | "latest"
+export type ecmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | "latest"
 
 export interface Options {
   /**

acorn/src/statement.js

@@ -72,6 +72,49 @@ pp.isAsyncFunction = function() {
      !(isIdentifierChar(after = this.input.charCodeAt(next + 8)) || after > 0xd7ff && after < 0xdc00))
 }
 
+pp.isUsingKeyword = function(isAwaitUsing, isFor) {
+  if (this.options.ecmaVersion < 17 || !this.isContextual(isAwaitUsing ? "await" : "using"))
+    return false
+
+  skipWhiteSpace.lastIndex = this.pos
+  let skip = skipWhiteSpace.exec(this.input)
+  let next = this.pos + skip[0].length
+
+  if (lineBreak.test(this.input.slice(this.pos, next))) return false
+
+  if (isAwaitUsing) {
+    let awaitEndPos = next + 5 /* await */, after
+    if (this.input.slice(next, awaitEndPos) !== "using" ||
+      awaitEndPos === this.input.length ||
+      isIdentifierChar(after = this.input.charCodeAt(awaitEndPos)) ||
+      (after > 0xd7ff && after < 0xdc00)
+    ) return false
+
+    skipWhiteSpace.lastIndex = awaitEndPos
+    let skipAfterUsing = skipWhiteSpace.exec(this.input)
+    if (skipAfterUsing && lineBreak.test(this.input.slice(awaitEndPos, awaitEndPos + skipAfterUsing[0].length))) return false
+  }
+
+  if (isFor) {
+    let ofEndPos = next + 2 /* of */, after
+    if (this.input.slice(next, ofEndPos) === "of") {
+      if (ofEndPos === this.input.length ||
+        (!isIdentifierChar(after = this.input.charCodeAt(ofEndPos)) && !(after > 0xd7ff && after < 0xdc00))) return false
+    }
+  }
+
+  let ch = this.input.charCodeAt(next)
+  return isIdentifierStart(ch, true) || ch === 92 // '\'
+}
+
+pp.isAwaitUsing = function(isFor) {
+  return this.isUsingKeyword(true, isFor)
+}
+
+pp.isUsing = function(isFor) {
+  return this.isUsingKeyword(false, isFor)
+}
+
 // Parse a single statement.
 //
 // If expecting a statement and finding a slash operator, parse a
@@ -148,6 +191,23 @@ pp.parseStatement = function(context, topLevel, exports) {
       return this.parseFunctionStatement(node, true, !context)
     }
 
+    let usingKind = this.isAwaitUsing(false) ? "await using" : this.isUsing(false) ? "using" : null
+    if (usingKind) {
+      if (topLevel && this.options.sourceType === "script") {
+        this.raise(this.start, "Using declaration cannot appear in the top level when source type is `script`")
+      }
+      if (usingKind === "await using") {
+        if (!this.canAwait) {
+          this.raise(this.start, "Await using cannot appear outside of async function")
+        }
+        this.next()
+      }
+      this.next()
+      this.parseVar(node, false, usingKind)
+      this.semicolon()
+      return this.finishNode(node, "VariableDeclaration")
+    }
+
     let maybeName = this.value, expr = this.parseExpression()
     if (starttype === tt.name && expr.type === "Identifier" && this.eat(tt.colon))
       return this.parseLabeledStatement(node, maybeName, expr, context)
@@ -223,18 +283,19 @@ pp.parseForStatement = function(node) {
     this.next()
     this.parseVar(init, true, kind)
     this.finishNode(init, "VariableDeclaration")
-    if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1) {
-      if (this.options.ecmaVersion >= 9) {
-        if (this.type === tt._in) {
-          if (awaitAt > -1) this.unexpected(awaitAt)
-        } else node.await = awaitAt > -1
-      }
-      return this.parseForIn(node, init)
-    }
-    if (awaitAt > -1) this.unexpected(awaitAt)
-    return this.parseFor(node, init)
+    return this.parseForAfterInit(node, init, awaitAt)
   }
   let startsWithLet = this.isContextual("let"), isForOf = false
+
+  let usingKind = this.isUsing(true) ? "using" : this.isAwaitUsing(true) ? "await using" : null
+  if (usingKind) {
+    let init = this.startNode()
+    this.next()
+    if (usingKind === "await using") this.next()
+    this.parseVar(init, true, usingKind)
+    this.finishNode(init, "VariableDeclaration")
+    return this.parseForAfterInit(node, init, awaitAt)
+  }
   let containsEsc = this.containsEsc
   let refDestructuringErrors = new DestructuringErrors
   let initPos = this.start
@@ -260,6 +321,20 @@ pp.parseForStatement = function(node) {
   return this.parseFor(node, init)
 }
 
+// Helper method to parse for loop after variable initialization
+pp.parseForAfterInit = function(node, init, awaitAt) {
+  if ((this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1) {
+    if (this.options.ecmaVersion >= 9) {
+      if (this.type === tt._in) {
+        if (awaitAt > -1) this.unexpected(awaitAt)
+      } else node.await = awaitAt > -1
+    }
+    return this.parseForIn(node, init)
+  }
+  if (awaitAt > -1) this.unexpected(awaitAt)
+  return this.parseFor(node, init)
+}
+
 pp.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next()
   return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
@@ -511,6 +586,8 @@ pp.parseVar = function(node, isFor, kind, allowMissingInitializer) {
       decl.init = this.parseMaybeAssign(isFor)
     } else if (!allowMissingInitializer && kind === "const" && !(this.type === tt._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
       this.unexpected()
+    } else if (!allowMissingInitializer && (kind === "using" || kind === "await using") && this.options.ecmaVersion >= 17 && this.type !== tt._in && !this.isContextual("of")) {
+      this.raise(this.lastTokEnd, `Missing initializer in ${kind} declaration`)
     } else if (!allowMissingInitializer && decl.id.type !== "Identifier" && !(isFor && (this.type === tt._in || this.isContextual("of")))) {
       this.raise(this.lastTokEnd, "Complex binding patterns require an initialization value")
     } else {
@@ -523,7 +600,10 @@ pp.parseVar = function(node, isFor, kind, allowMissingInitializer) {
 }
 
 pp.parseVarId = function(decl, kind) {
-  decl.id = this.parseBindingAtom()
+  decl.id = kind === "using" || kind === "await using"
+    ? this.parseIdent()
+    : this.parseBindingAtom()
+
   this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false)
 }
 

bin/test262.unsupported-features

@@ -1,4 +1,3 @@
 decorators
-explicit-resource-management
 import-defer
 source-phase-imports

test/run.js

@@ -30,6 +30,7 @@
   require("./tests-class-features-2022.js");
   require("./tests-module-string-names.js");
   require("./tests-import-attributes.js");
+  require("./tests-using.js");
   var acorn = require("../acorn")
   var acorn_loose = require("../acorn-loose")